use byteorder::{ByteOrder, LE, BE};
use tokio_socketcan_bcm::{CANMessageId, BCMSocket};
use futures::stream::Stream;
use futures_util::compat::Stream01CompatExt;
use futures_util::stream::StreamExt;

#[allow(dead_code)]
pub const MESSAGE_ID_DISP1: u32 = 2561212158;

#[allow(dead_code)]
pub const MESSAGE_ID_DRC: u32 = 2566746366;

#[allow(dead_code)]
pub const MESSAGE_ID_EC2: u32 = 2566750206;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC7: u32 = 2566755582;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC8: u32 = 2566746110;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P5: u32 = 2566752510;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P6: u32 = 2566752254;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P7: u32 = 2566751998;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P8: u32 = 2566751742;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P9: u32 = 2566751486;

#[allow(dead_code)]
pub const MESSAGE_ID_EGRBV: u32 = 2499641854;

#[allow(dead_code)]
pub const MESSAGE_ID_ESV1: u32 = 2566748158;

#[allow(dead_code)]
pub const MESSAGE_ID_ESV2: u32 = 2566747902;

#[allow(dead_code)]
pub const MESSAGE_ID_ESV3: u32 = 2566747646;

#[allow(dead_code)]
pub const MESSAGE_ID_ESV4: u32 = 2566747390;

#[allow(dead_code)]
pub const MESSAGE_ID_ESV5: u32 = 2566747134;

#[allow(dead_code)]
pub const MESSAGE_ID_ESV6: u32 = 2566746878;

#[allow(dead_code)]
pub const MESSAGE_ID_FLIC: u32 = 2561277694;

#[allow(dead_code)]
pub const MESSAGE_ID_J2012: u32 = 2633861886;

#[allow(dead_code)]
pub const MESSAGE_ID_PTC1: u32 = 2566749438;

#[allow(dead_code)]
pub const MESSAGE_ID_SAS: u32 = 2565873150;

#[allow(dead_code)]
pub const MESSAGE_ID_SCR1: u32 = 2566745854;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI: u32 = 2566751230;

#[allow(dead_code)]
pub const MESSAGE_ID_TRF2: u32 = 2566755838;

#[allow(dead_code)]
pub const MESSAGE_ID_VDS2: u32 = 2566752766;

#[allow(dead_code)]
pub const MESSAGE_ID_LF: u32 = 2633938942;

#[allow(dead_code)]
pub const MESSAGE_ID_LD: u32 = 2566799614;

#[allow(dead_code)]
pub const MESSAGE_ID_LC: u32 = 2365473278;

#[allow(dead_code)]
pub const MESSAGE_ID_LBC: u32 = 2365485822;

#[allow(dead_code)]
pub const MESSAGE_ID_IT6: u32 = 2633926654;

#[allow(dead_code)]
pub const MESSAGE_ID_IT5: u32 = 2633926398;

#[allow(dead_code)]
pub const MESSAGE_ID_IT4: u32 = 2633926142;

#[allow(dead_code)]
pub const MESSAGE_ID_IT3: u32 = 2633925886;

#[allow(dead_code)]
pub const MESSAGE_ID_IT2: u32 = 2633925630;

#[allow(dead_code)]
pub const MESSAGE_ID_IT1: u32 = 2633925374;

#[allow(dead_code)]
pub const MESSAGE_ID_ISO3: u32 = 2633927422;

#[allow(dead_code)]
pub const MESSAGE_ID_ISO2: u32 = 2633927166;

#[allow(dead_code)]
pub const MESSAGE_ID_ISO1: u32 = 2633926910;

#[allow(dead_code)]
pub const MESSAGE_ID_ISCS: u32 = 2566768894;

#[allow(dead_code)]
pub const MESSAGE_ID_ISC: u32 = 2566769406;

#[allow(dead_code)]
pub const MESSAGE_ID_IO: u32 = 2566839550;

#[allow(dead_code)]
pub const MESSAGE_ID_IMT2: u32 = 2633934334;

#[allow(dead_code)]
pub const MESSAGE_ID_IMT1: u32 = 2566825726;

#[allow(dead_code)]
pub const MESSAGE_ID_IC2: u32 = 2566770942;

#[allow(dead_code)]
pub const MESSAGE_ID_IC1: u32 = 2566846206;

#[allow(dead_code)]
pub const MESSAGE_ID_HTR: u32 = 2566811134;

#[allow(dead_code)]
pub const MESSAGE_ID_HRW: u32 = 2298375934;

#[allow(dead_code)]
pub const MESSAGE_ID_HPG: u32 = 2565867774;

#[allow(dead_code)]
pub const MESSAGE_ID_HOURS: u32 = 2566841854;

#[allow(dead_code)]
pub const MESSAGE_ID_HBS: u32 = 2365449982;

#[allow(dead_code)]
pub const MESSAGE_ID_GTFI: u32 = 2633939198;

#[allow(dead_code)]
pub const MESSAGE_ID_GFP: u32 = 2633927678;

#[allow(dead_code)]
pub const MESSAGE_ID_GFI2: u32 = 2633925118;

#[allow(dead_code)]
pub const MESSAGE_ID_GFI1: u32 = 2633937662;

#[allow(dead_code)]
pub const MESSAGE_ID_GFD: u32 = 2566804990;

#[allow(dead_code)]
pub const MESSAGE_ID_GFC: u32 = 2633936894;

#[allow(dead_code)]
pub const MESSAGE_ID_SEP2: u32 = 2566757630;

#[allow(dead_code)]
pub const MESSAGE_ID_SEP1: u32 = 2566757886;

#[allow(dead_code)]
pub const MESSAGE_ID_PTODE: u32 = 2566759678;

#[allow(dead_code)]
pub const MESSAGE_ID_GFI3: u32 = 2432541438;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P4: u32 = 2566761214;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC6: u32 = 2432541694;

#[allow(dead_code)]
pub const MESSAGE_ID_DC2: u32 = 2566759934;

#[allow(dead_code)]
pub const MESSAGE_ID_CRI1: u32 = 2566757374;

#[allow(dead_code)]
pub const MESSAGE_ID_AHI2: u32 = 2566756862;

#[allow(dead_code)]
pub const MESSAGE_ID_AFC2: u32 = 2566758654;

#[allow(dead_code)]
pub const MESSAGE_ID_AFC1: u32 = 2566758910;

#[allow(dead_code)]
pub const MESSAGE_ID_AAC2: u32 = 2566758142;

#[allow(dead_code)]
pub const MESSAGE_ID_AAC1: u32 = 2566758398;

#[allow(dead_code)]
pub const MESSAGE_ID_AHI1: u32 = 2566756606;

#[allow(dead_code)]
pub const MESSAGE_ID_RGAAQ: u32 = 2364546302;

#[allow(dead_code)]
pub const MESSAGE_ID_TFAC: u32 = 2431654654;

#[allow(dead_code)]
pub const MESSAGE_ID_KL3: u32 = 2364545534;

#[allow(dead_code)]
pub const MESSAGE_ID_KL2: u32 = 2364545278;

#[allow(dead_code)]
pub const MESSAGE_ID_KL1: u32 = 2364545022;

#[allow(dead_code)]
pub const MESSAGE_ID_CCS: u32 = 2364544766;

#[allow(dead_code)]
pub const MESSAGE_ID_RGTARP: u32 = 2364544510;

#[allow(dead_code)]
pub const MESSAGE_ID_BI: u32 = 2364544254;

#[allow(dead_code)]
pub const MESSAGE_ID_EBS11: u32 = 2349006590;

#[allow(dead_code)]
pub const MESSAGE_ID_EBS12: u32 = 2566834686;

#[allow(dead_code)]
pub const MESSAGE_ID_EBS21: u32 = 2550398718;

#[allow(dead_code)]
pub const MESSAGE_ID_EBS22: u32 = 2566833406;

#[allow(dead_code)]
pub const MESSAGE_ID_EBS23: u32 = 2365507326;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM11: u32 = 2565013246;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM12: u32 = 2566807038;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM13: u32 = 2365480958;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM14: u32 = 2566808062;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM15: u32 = 2566808574;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM16: u32 = 2566809086;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM21: u32 = 2564947710;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM22: u32 = 2566834430;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM23: u32 = 2365481214;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM24: u32 = 2566808318;

#[allow(dead_code)]
pub const MESSAGE_ID_GPM25: u32 = 2566808830;

#[allow(dead_code)]
pub const MESSAGE_ID_ISO15765_FUNCT: u32 = 2564554494;

#[allow(dead_code)]
pub const MESSAGE_ID_ISO15765_PHYS: u32 = 2564488958;

#[allow(dead_code)]
pub const MESSAGE_ID_NETWORK: u32 = 2565734142;

#[allow(dead_code)]
pub const MESSAGE_ID_RGE11: u32 = 2565144318;

#[allow(dead_code)]
pub const MESSAGE_ID_RGE21: u32 = 2565209854;

#[allow(dead_code)]
pub const MESSAGE_ID_RGE22: u32 = 2566806782;

#[allow(dead_code)]
pub const MESSAGE_ID_RGE23: u32 = 2566807294;

#[allow(dead_code)]
pub const MESSAGE_ID_DM26: u32 = 2566764798;

#[allow(dead_code)]
pub const MESSAGE_ID_DM18: u32 = 2564095742;

#[allow(dead_code)]
pub const MESSAGE_ID_XBR: u32 = 2349137662;

#[allow(dead_code)]
pub const MESSAGE_ID_WFI: u32 = 2566848510;

#[allow(dead_code)]
pub const MESSAGE_ID_VW: u32 = 2566843134;

#[allow(dead_code)]
pub const MESSAGE_ID_VEP3: u32 = 2566804222;

#[allow(dead_code)]
pub const MESSAGE_ID_VEP2: u32 = 2633928190;

#[allow(dead_code)]
pub const MESSAGE_ID_VP: u32 = 2566845438;

#[allow(dead_code)]
pub const MESSAGE_ID_VI: u32 = 2566843646;

#[allow(dead_code)]
pub const MESSAGE_ID_VH: u32 = 2566842366;

#[allow(dead_code)]
pub const MESSAGE_ID_VF: u32 = 2566809854;

#[allow(dead_code)]
pub const MESSAGE_ID_VDS: u32 = 2566842622;

#[allow(dead_code)]
pub const MESSAGE_ID_VDHR: u32 = 2566832638;

#[allow(dead_code)]
pub const MESSAGE_ID_VDC2: u32 = 2565868030;

#[allow(dead_code)]
pub const MESSAGE_ID_VDC1: u32 = 2566803454;

#[allow(dead_code)]
pub const MESSAGE_ID_VD: u32 = 2566840574;

#[allow(dead_code)]
pub const MESSAGE_ID_TVI: u32 = 2633938686;

#[allow(dead_code)]
pub const MESSAGE_ID_TTI2: u32 = 2633937150;

#[allow(dead_code)]
pub const MESSAGE_ID_TTI1: u32 = 2633938174;

#[allow(dead_code)]
pub const MESSAGE_ID_TSI: u32 = 2633938430;

#[allow(dead_code)]
pub const MESSAGE_ID_TSC1: u32 = 2348875518;

#[allow(dead_code)]
pub const MESSAGE_ID_TR7: u32 = 2566766846;

#[allow(dead_code)]
pub const MESSAGE_ID_TR6: u32 = 2566765310;

#[allow(dead_code)]
pub const MESSAGE_ID_TR5: u32 = 2566765566;

#[allow(dead_code)]
pub const MESSAGE_ID_TR4: u32 = 2566765822;

#[allow(dead_code)]
pub const MESSAGE_ID_TR3: u32 = 2566766078;

#[allow(dead_code)]
pub const MESSAGE_ID_TR2: u32 = 2566766590;

#[allow(dead_code)]
pub const MESSAGE_ID_TR1: u32 = 2566766334;

#[allow(dead_code)]
pub const MESSAGE_ID_TPRS: u32 = 2561605374;

#[allow(dead_code)]
pub const MESSAGE_ID_TPRI: u32 = 2566765054;

#[allow(dead_code)]
pub const MESSAGE_ID_TP3: u32 = 2633923326;

#[allow(dead_code)]
pub const MESSAGE_ID_TP2: u32 = 2633923070;

#[allow(dead_code)]
pub const MESSAGE_ID_TP1: u32 = 2633922814;

#[allow(dead_code)]
pub const MESSAGE_ID_TIRE: u32 = 2566845694;

#[allow(dead_code)]
pub const MESSAGE_ID_TI1: u32 = 2566805246;

#[allow(dead_code)]
pub const MESSAGE_ID_TFI: u32 = 2633939966;

#[allow(dead_code)]
pub const MESSAGE_ID_TDI: u32 = 2633939710;

#[allow(dead_code)]
pub const MESSAGE_ID_TDA: u32 = 2564161278;

#[allow(dead_code)]
pub const MESSAGE_ID_TD: u32 = 2566842110;

#[allow(dead_code)]
pub const MESSAGE_ID_TCW: u32 = 2566821630;

#[allow(dead_code)]
pub const MESSAGE_ID_TCO1: u32 = 2365484286;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI6: u32 = 2566771710;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI5: u32 = 2566821886;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI4: u32 = 2566822142;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI3: u32 = 2566822398;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI2: u32 = 2566822654;

#[allow(dead_code)]
pub const MESSAGE_ID_TCI1: u32 = 2633931774;

#[allow(dead_code)]
pub const MESSAGE_ID_TCFG2: u32 = 2566802430;

#[allow(dead_code)]
pub const MESSAGE_ID_TCFG: u32 = 2566841086;

#[allow(dead_code)]
pub const MESSAGE_ID_TC1: u32 = 2348941054;

#[allow(dead_code)]
pub const MESSAGE_ID_TC: u32 = 2566839806;

#[allow(dead_code)]
pub const MESSAGE_ID_TAVG: u32 = 2633911806;

#[allow(dead_code)]
pub const MESSAGE_ID_SPR: u32 = 2566775550;

#[allow(dead_code)]
pub const MESSAGE_ID_SP2: u32 = 2566819838;

#[allow(dead_code)]
pub const MESSAGE_ID_SOFT: u32 = 2566839038;

#[allow(dead_code)]
pub const MESSAGE_ID_SHUTDOW: u32 = 2566841598;

#[allow(dead_code)]
pub const MESSAGE_ID_SERV: u32 = 2566832382;

#[allow(dead_code)]
pub const MESSAGE_ID_S2: u32 = 2633928446;

#[allow(dead_code)]
pub const MESSAGE_ID_RTC1: u32 = 2566804478;

#[allow(dead_code)]
pub const MESSAGE_ID_RF: u32 = 2566847486;

#[allow(dead_code)]
pub const MESSAGE_ID_RESET: u32 = 2631859966;

#[allow(dead_code)]
pub const MESSAGE_ID_RC: u32 = 2566840830;

#[allow(dead_code)]
pub const MESSAGE_ID_RBI: u32 = 2633930238;

#[allow(dead_code)]
pub const MESSAGE_ID_PTO: u32 = 2566844670;

#[allow(dead_code)]
pub const MESSAGE_ID_OWW: u32 = 2566770174;

#[allow(dead_code)]
pub const MESSAGE_ID_OHECS: u32 = 2566769662;

#[allow(dead_code)]
pub const MESSAGE_ID_OHCSS: u32 = 2566768638;

#[allow(dead_code)]
pub const MESSAGE_ID_OEL: u32 = 2365443326;

#[allow(dead_code)]
pub const MESSAGE_ID_MVS: u32 = 2566776318;

#[allow(dead_code)]
pub const MESSAGE_ID_ML: u32 = 2566802686;

#[allow(dead_code)]
pub const MESSAGE_ID_MCI: u32 = 2566774014;

#[allow(dead_code)]
pub const MESSAGE_ID_MBT3: u32 = 2566823166;

#[allow(dead_code)]
pub const MESSAGE_ID_MBT2: u32 = 2566823422;

#[allow(dead_code)]
pub const MESSAGE_ID_MBT1: u32 = 2566823678;

#[allow(dead_code)]
pub const MESSAGE_ID_LVDD: u32 = 2432595710;

#[allow(dead_code)]
pub const MESSAGE_ID_LVD: u32 = 2365486590;

#[allow(dead_code)]
pub const MESSAGE_ID_LTP: u32 = 2365485566;

#[allow(dead_code)]
pub const MESSAGE_ID_LTFI: u32 = 2633939454;

#[allow(dead_code)]
pub const MESSAGE_ID_LSP: u32 = 2365486334;

#[allow(dead_code)]
pub const MESSAGE_ID_LOI: u32 = 2364542462;

#[allow(dead_code)]
pub const MESSAGE_ID_LMP: u32 = 2365486078;

#[allow(dead_code)]
pub const MESSAGE_ID_LFI: u32 = 2633937918;

#[allow(dead_code)]
pub const MESSAGE_ID_LFE: u32 = 2566845182;

#[allow(dead_code)]
pub const MESSAGE_ID_LFC: u32 = 2566842878;

#[allow(dead_code)]
pub const MESSAGE_ID_FWD: u32 = 2633883646;

#[allow(dead_code)]
pub const MESSAGE_ID_FMS: u32 = 2633880062;

#[allow(dead_code)]
pub const MESSAGE_ID_FLI2: u32 = 2566806526;

#[allow(dead_code)]
pub const MESSAGE_ID_FLI1: u32 = 2431649790;

#[allow(dead_code)]
pub const MESSAGE_ID_FL: u32 = 2633929214;

#[allow(dead_code)]
pub const MESSAGE_ID_FD: u32 = 2566831614;

#[allow(dead_code)]
pub const MESSAGE_ID_ETH: u32 = 2566820094;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC8: u32 = 2364542206;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC7: u32 = 2566802174;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC6: u32 = 2633935870;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC5: u32 = 2633942014;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC4: u32 = 2633942526;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC3: u32 = 2633943038;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC2: u32 = 2565867006;

#[allow(dead_code)]
pub const MESSAGE_ID_ETC1: u32 = 2364539646;

#[allow(dead_code)]
pub const MESSAGE_ID_ET3: u32 = 2566810110;

#[allow(dead_code)]
pub const MESSAGE_ID_ET2: u32 = 2566825214;

#[allow(dead_code)]
pub const MESSAGE_ID_ET1: u32 = 2566844158;

#[allow(dead_code)]
pub const MESSAGE_ID_ET: u32 = 2566785022;

#[allow(dead_code)]
pub const MESSAGE_ID_ESC1: u32 = 2565868542;

#[allow(dead_code)]
pub const MESSAGE_ID_ERC2: u32 = 2633941758;

#[allow(dead_code)]
pub const MESSAGE_ID_ERC1: u32 = 2565865726;

#[allow(dead_code)]
pub const MESSAGE_ID_EPT5: u32 = 2633932798;

#[allow(dead_code)]
pub const MESSAGE_ID_EPT4: u32 = 2566824190;

#[allow(dead_code)]
pub const MESSAGE_ID_EPT3: u32 = 2633933310;

#[allow(dead_code)]
pub const MESSAGE_ID_EPT2: u32 = 2633933566;

#[allow(dead_code)]
pub const MESSAGE_ID_EPT1: u32 = 2633933822;

#[allow(dead_code)]
pub const MESSAGE_ID_EPD: u32 = 2566776062;

#[allow(dead_code)]
pub const MESSAGE_ID_EP: u32 = 2566771454;

#[allow(dead_code)]
pub const MESSAGE_ID_EOAC: u32 = 2566775806;

#[allow(dead_code)]
pub const MESSAGE_ID_EO1: u32 = 2633935358;

#[allow(dead_code)]
pub const MESSAGE_ID_EJM3: u32 = 2365447166;

#[allow(dead_code)]
pub const MESSAGE_ID_EJM2: u32 = 2365446654;

#[allow(dead_code)]
pub const MESSAGE_ID_EJM1: u32 = 2365446142;

#[allow(dead_code)]
pub const MESSAGE_ID_EI: u32 = 2633929470;

#[allow(dead_code)]
pub const MESSAGE_ID_EH: u32 = 2633937406;

#[allow(dead_code)]
pub const MESSAGE_ID_EGF1: u32 = 2364541694;

#[allow(dead_code)]
pub const MESSAGE_ID_EFS: u32 = 2566810366;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P3: u32 = 2566767102;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P2: u32 = 2566839294;

#[allow(dead_code)]
pub const MESSAGE_ID_EFL_P1: u32 = 2566844414;

#[allow(dead_code)]
pub const MESSAGE_ID_EES: u32 = 2633929726;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC5: u32 = 2566772222;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC4: u32 = 2633940734;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC3: u32 = 2566840318;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC2: u32 = 2364539902;

#[allow(dead_code)]
pub const MESSAGE_ID_EEC1: u32 = 2364540158;

#[allow(dead_code)]
pub const MESSAGE_ID_ECUID: u32 = 2566768126;

#[allow(dead_code)]
pub const MESSAGE_ID_ECT1: u32 = 2566804734;

#[allow(dead_code)]
pub const MESSAGE_ID_EC1: u32 = 2566841342;

#[allow(dead_code)]
pub const MESSAGE_ID_EBC5: u32 = 2566767870;

#[allow(dead_code)]
pub const MESSAGE_ID_EBC4: u32 = 2633936126;

#[allow(dead_code)]
pub const MESSAGE_ID_EBC3: u32 = 2566827518;

#[allow(dead_code)]
pub const MESSAGE_ID_EBC2: u32 = 2566832126;

#[allow(dead_code)]
pub const MESSAGE_ID_EBC1: u32 = 2565865982;

#[allow(dead_code)]
pub const MESSAGE_ID_EAC1: u32 = 2565867262;

#[allow(dead_code)]
pub const MESSAGE_ID_EAC: u32 = 2566821118;

#[allow(dead_code)]
pub const MESSAGE_ID_DI: u32 = 2566810622;

#[allow(dead_code)]
pub const MESSAGE_ID_DD: u32 = 2566847742;

#[allow(dead_code)]
pub const MESSAGE_ID_CSA: u32 = 2566768382;

#[allow(dead_code)]
pub const MESSAGE_ID_CVW: u32 = 2566811902;

#[allow(dead_code)]
pub const MESSAGE_ID_CTL: u32 = 2563768062;

#[allow(dead_code)]
pub const MESSAGE_ID_CT6: u32 = 2633924862;

#[allow(dead_code)]
pub const MESSAGE_ID_CT5: u32 = 2633924606;

#[allow(dead_code)]
pub const MESSAGE_ID_CT4: u32 = 2633924350;

#[allow(dead_code)]
pub const MESSAGE_ID_CT3: u32 = 2633924094;

#[allow(dead_code)]
pub const MESSAGE_ID_CT2: u32 = 2633923838;

#[allow(dead_code)]
pub const MESSAGE_ID_CT1: u32 = 2633923582;

#[allow(dead_code)]
pub const MESSAGE_ID_CMI: u32 = 2633878014;

#[allow(dead_code)]
pub const MESSAGE_ID_CM3: u32 = 2566771966;

#[allow(dead_code)]
pub const MESSAGE_ID_CM1: u32 = 2564882174;

#[allow(dead_code)]
pub const MESSAGE_ID_CL: u32 = 2563833598;

#[allow(dead_code)]
pub const MESSAGE_ID_CI: u32 = 2566843390;

#[allow(dead_code)]
pub const MESSAGE_ID_CCVS: u32 = 2566844926;

#[allow(dead_code)]
pub const MESSAGE_ID_CCSS: u32 = 2566843902;

#[allow(dead_code)]
pub const MESSAGE_ID_CCC: u32 = 2566809598;

#[allow(dead_code)]
pub const MESSAGE_ID_CBI: u32 = 2633940222;

#[allow(dead_code)]
pub const MESSAGE_ID_CACI: u32 = 2566775294;

#[allow(dead_code)]
pub const MESSAGE_ID_BT1: u32 = 2566803710;

#[allow(dead_code)]
pub const MESSAGE_ID_BM: u32 = 2566809342;

#[allow(dead_code)]
pub const MESSAGE_ID_BJM3: u32 = 2365446910;

#[allow(dead_code)]
pub const MESSAGE_ID_BJM2: u32 = 2365446398;

#[allow(dead_code)]
pub const MESSAGE_ID_BJM1: u32 = 2365445886;

#[allow(dead_code)]
pub const MESSAGE_ID_B: u32 = 2566847230;

#[allow(dead_code)]
pub const MESSAGE_ID_AWPP: u32 = 2566848254;

#[allow(dead_code)]
pub const MESSAGE_ID_ATS: u32 = 2631728894;

#[allow(dead_code)]
pub const MESSAGE_ID_ATR: u32 = 2631794430;

#[allow(dead_code)]
pub const MESSAGE_ID_AT: u32 = 2633934846;

#[allow(dead_code)]
pub const MESSAGE_ID_ASC6: u32 = 2362572542;

#[allow(dead_code)]
pub const MESSAGE_ID_ASC5: u32 = 2365478910;

#[allow(dead_code)]
pub const MESSAGE_ID_ASC4: u32 = 2566805758;

#[allow(dead_code)]
pub const MESSAGE_ID_ASC3: u32 = 2566806014;

#[allow(dead_code)]
pub const MESSAGE_ID_ASC2: u32 = 2362638078;

#[allow(dead_code)]
pub const MESSAGE_ID_ASC1: u32 = 2365479678;

#[allow(dead_code)]
pub const MESSAGE_ID_AS: u32 = 2566837758;

#[allow(dead_code)]
pub const MESSAGE_ID_AP: u32 = 2633922558;

#[allow(dead_code)]
pub const MESSAGE_ID_AMB2: u32 = 2566775038;

#[allow(dead_code)]
pub const MESSAGE_ID_WSMEM: u32 = 2633895166;

#[allow(dead_code)]
pub const MESSAGE_ID_DM8: u32 = 2566836478;

#[allow(dead_code)]
pub const MESSAGE_ID_DM7: u32 = 2565078782;

#[allow(dead_code)]
pub const MESSAGE_ID_DM6: u32 = 2566836222;

#[allow(dead_code)]
pub const MESSAGE_ID_DM5: u32 = 2566835966;

#[allow(dead_code)]
pub const MESSAGE_ID_DM4: u32 = 2566835710;

#[allow(dead_code)]
pub const MESSAGE_ID_DM3: u32 = 2566835454;

#[allow(dead_code)]
pub const MESSAGE_ID_DM25: u32 = 2566764542;

#[allow(dead_code)]
pub const MESSAGE_ID_DM24: u32 = 2566764286;

#[allow(dead_code)]
pub const MESSAGE_ID_DM23: u32 = 2555576062;

#[allow(dead_code)]
pub const MESSAGE_ID_DM22: u32 = 2562981630;

#[allow(dead_code)]
pub const MESSAGE_ID_DM21: u32 = 2562850558;

#[allow(dead_code)]
pub const MESSAGE_ID_DM20: u32 = 2562916094;

#[allow(dead_code)]
pub const MESSAGE_ID_DM2: u32 = 2566835198;

#[allow(dead_code)]
pub const MESSAGE_ID_DM19: u32 = 2564030206;

#[allow(dead_code)]
pub const MESSAGE_ID_DM17: u32 = 2564226814;

#[allow(dead_code)]
pub const MESSAGE_ID_DM16: u32 = 2564292350;

#[allow(dead_code)]
pub const MESSAGE_ID_DM15: u32 = 2564357886;

#[allow(dead_code)]
pub const MESSAGE_ID_DM14: u32 = 2564423422;

#[allow(dead_code)]
pub const MESSAGE_ID_DM13: u32 = 2564816638;

#[allow(dead_code)]
pub const MESSAGE_ID_DM12: u32 = 2566837502;

#[allow(dead_code)]
pub const MESSAGE_ID_DM11: u32 = 2566837246;

#[allow(dead_code)]
pub const MESSAGE_ID_DM10: u32 = 2566836990;

#[allow(dead_code)]
pub const MESSAGE_ID_DM1: u32 = 2566834942;

#[allow(dead_code)]
pub const MESSAGE_ID_UTACR: u32 = 2566780926;

#[allow(dead_code)]
pub const MESSAGE_ID_UTACP: u32 = 2566781182;

#[allow(dead_code)]
pub const MESSAGE_ID_UTACE: u32 = 2566778366;

#[allow(dead_code)]
pub const MESSAGE_ID_UPCACR: u32 = 2566778622;

#[allow(dead_code)]
pub const MESSAGE_ID_UPCACP: u32 = 2566778878;

#[allow(dead_code)]
pub const MESSAGE_ID_UPCAC: u32 = 2566779134;

#[allow(dead_code)]
pub const MESSAGE_ID_UPBACR: u32 = 2566779390;

#[allow(dead_code)]
pub const MESSAGE_ID_UPBACP: u32 = 2566779646;

#[allow(dead_code)]
pub const MESSAGE_ID_UPBAC: u32 = 2566779902;

#[allow(dead_code)]
pub const MESSAGE_ID_UPACCR: u32 = 2566780158;

#[allow(dead_code)]
pub const MESSAGE_ID_UPAACP: u32 = 2566780414;

#[allow(dead_code)]
pub const MESSAGE_ID_UPAAC: u32 = 2566780670;

#[allow(dead_code)]
pub const MESSAGE_ID_UAAC: u32 = 2566781438;

#[allow(dead_code)]
pub const MESSAGE_ID_GTACR: u32 = 2566784254;

#[allow(dead_code)]
pub const MESSAGE_ID_GTACP: u32 = 2566784510;

#[allow(dead_code)]
pub const MESSAGE_ID_GTACE: u32 = 2566781694;

#[allow(dead_code)]
pub const MESSAGE_ID_GPCACR: u32 = 2566781950;

#[allow(dead_code)]
pub const MESSAGE_ID_GPCACP: u32 = 2566782206;

#[allow(dead_code)]
pub const MESSAGE_ID_GPCAC: u32 = 2566782462;

#[allow(dead_code)]
pub const MESSAGE_ID_GPBACRP: u32 = 2566782718;

#[allow(dead_code)]
pub const MESSAGE_ID_GPBACP: u32 = 2566782974;

#[allow(dead_code)]
pub const MESSAGE_ID_GPBAC: u32 = 2566783230;

#[allow(dead_code)]
pub const MESSAGE_ID_GPAACR: u32 = 2566783486;

#[allow(dead_code)]
pub const MESSAGE_ID_GPAACP: u32 = 2566783742;

#[allow(dead_code)]
pub const MESSAGE_ID_GPAAC: u32 = 2566783998;

#[allow(dead_code)]
pub const MESSAGE_ID_GAAC: u32 = 2566784766;

#[allow(dead_code)]
pub const MESSAGE_ID_BUSC: u32 = 2566776830;

#[allow(dead_code)]
pub const MESSAGE_ID_BPCAC: u32 = 2566777342;

#[allow(dead_code)]
pub const MESSAGE_ID_BPBAC: u32 = 2566777598;

#[allow(dead_code)]
pub const MESSAGE_ID_BPAAC: u32 = 2566777854;

#[allow(dead_code)]
pub const MESSAGE_ID_BGSC: u32 = 2566777086;

#[allow(dead_code)]
pub const MESSAGE_ID_BAAC: u32 = 2566778110;

#[allow(dead_code)]
pub const MESSAGE_ID_WSMSTR: u32 = 2633895422;

#[allow(dead_code)]
pub const MESSAGE_ID_CA: u32 = 2566838526;

#[allow(dead_code)]
pub const MESSAGE_ID_ACL: u32 = 2565799678;

#[allow(dead_code)]
pub const MESSAGE_ID_XFER: u32 = 2563440382;

#[allow(dead_code)]
pub const MESSAGE_ID_TPDT: u32 = 2565603070;

#[allow(dead_code)]
pub const MESSAGE_ID_TPCM: u32 = 2565668606;

#[allow(dead_code)]
pub const MESSAGE_ID_RQST2: u32 = 2563374846;

#[allow(dead_code)]
pub const MESSAGE_ID_RQST: u32 = 2565537534;

#[allow(dead_code)]
pub const MESSAGE_ID_DM29: u32 = 2560556798;

#[allow(dead_code)]
pub const MESSAGE_ID_DM28: u32 = 2566750462;

#[allow(dead_code)]
pub const MESSAGE_ID_DM27: u32 = 2566750974;

#[allow(dead_code)]
pub const MESSAGE_ID_ATI2: u32 = 2566748414;

#[allow(dead_code)]
pub const MESSAGE_ID_ATI1: u32 = 2566748670;

#[allow(dead_code)]
pub const MESSAGE_ID_AAC3: u32 = 2566745598;

#[allow(dead_code)]
pub const MESSAGE_ID_AAC4: u32 = 2566745342;

#[allow(dead_code)]
pub const MESSAGE_ID_AETC: u32 = 2566754558;

#[allow(dead_code)]
pub const MESSAGE_ID_AFSS: u32 = 2566749950;

#[allow(dead_code)]
pub const MESSAGE_ID_AT1I1: u32 = 2565869310;

#[allow(dead_code)]
pub const MESSAGE_ID_AT1I2: u32 = 2566763774;

#[allow(dead_code)]
pub const MESSAGE_ID_AT1O1: u32 = 2565869566;

#[allow(dead_code)]
pub const MESSAGE_ID_AT1O2: u32 = 2566763518;

#[allow(dead_code)]
pub const MESSAGE_ID_AT2I1: u32 = 2565869822;

#[allow(dead_code)]
pub const MESSAGE_ID_AT2I2: u32 = 2566763006;

#[allow(dead_code)]
pub const MESSAGE_ID_AT2O1: u32 = 2565870078;

#[allow(dead_code)]
pub const MESSAGE_ID_AT2O2: u32 = 2566762750;

#[allow(dead_code)]
pub const MESSAGE_ID_ATGP1: u32 = 2566753534;

#[allow(dead_code)]
pub const MESSAGE_ID_ATGP2: u32 = 2566753278;

#[allow(dead_code)]
pub const MESSAGE_ID_ATM2: u32 = 2566762494;

#[allow(dead_code)]
pub const MESSAGE_ID_ATS1: u32 = 2566749182;

#[allow(dead_code)]
pub const MESSAGE_ID_ATS2: u32 = 2566748926;

#[allow(dead_code)]
pub const MESSAGE_ID_AUXIO1: u32 = 2566838782;

#[allow(dead_code)]
pub const MESSAGE_ID_AUXIO2: u32 = 2561146622;

#[allow(dead_code)]
pub const MESSAGE_ID_AUXIO3: u32 = 2561081086;

#[allow(dead_code)]
pub const MESSAGE_ID_AUXIO4: u32 = 2561015550;

#[allow(dead_code)]
pub const MESSAGE_ID_BSA: u32 = 2566746622;

#[allow(dead_code)]
pub const MESSAGE_ID_AMB: u32 = 2566845950;

#[allow(dead_code)]
pub const MESSAGE_ID_AIR2: u32 = 2566840062;

#[allow(dead_code)]
pub const MESSAGE_ID_AIR1: u32 = 2566827774;

#[allow(dead_code)]
pub const MESSAGE_ID_AI: u32 = 2566846974;

#[allow(dead_code)]
pub const MESSAGE_ID_AF2: u32 = 2633935614;

#[allow(dead_code)]
pub const MESSAGE_ID_ACC2: u32 = 2566803966;

#[allow(dead_code)]
pub const MESSAGE_ID_ACC1: u32 = 2432593918;

#[allow(dead_code)]
pub const MESSAGE_ID_AC: u32 = 2633935102;

#[allow(dead_code)]
pub const MESSAGE_ID_AAI: u32 = 2633927934;

#[allow(dead_code)]
pub const MESSAGE_ID_A1: u32 = 2566847998;

#[allow(dead_code)]
pub const MESSAGE_ID_ACKM: u32 = 2565406462;

#[allow(dead_code)]
pub const MESSAGE_ID_ATM1: u32 = 2566763262;

#[allow(dead_code)]
pub const MESSAGE_ID_DC1: u32 = 2566803198;

#[allow(dead_code)]
pub const MESSAGE_ID_FWSS1: u32 = 2565870334;

#[allow(dead_code)]
pub const MESSAGE_ID_FWSS2: u32 = 2566762238;

#[allow(dead_code)]
pub const MESSAGE_ID_SSI: u32 = 2364543998;

#[allow(dead_code)]
pub const MESSAGE_ID_TRF1: u32 = 2566846718;

#[allow(dead_code)]
pub const MESSAGE_ID_VEP1: u32 = 2566846462;

#[allow(dead_code)]
pub const MESSAGE_ID_WCM2: u32 = 2566760702;

#[allow(dead_code)]
pub const MESSAGE_ID_WCM1: u32 = 2566760958;

#[allow(dead_code)]
pub const MESSAGE_ID_VROM: u32 = 2633869310;

#[allow(dead_code)]
pub const MESSAGE_ID_VREP: u32 = 2365433598;

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TextDisplayInstructions2561212158 {
    HldDsplyPrsntlyDsplydInfrmtnShl,
    ClrDsplyDsplydInfrmtnShldBDltdN,
    X1110reserved,
    OvrwrtSbstrngAPrtnOfPrsntlyDspl,
    OvrwrtDsplyPrsntlyDsplydInfrmtn,
    AppndAtEndOfDsplyTrnsmttdInfrmt,
    XValue(u64),
}

impl From<u64> for TextDisplayInstructions2561212158 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TextDisplayInstructions2561212158::HldDsplyPrsntlyDsplydInfrmtnShl,
            0 => TextDisplayInstructions2561212158::ClrDsplyDsplydInfrmtnShldBDltdN,
            5 => TextDisplayInstructions2561212158::X1110reserved,
            4 => TextDisplayInstructions2561212158::OvrwrtSbstrngAPrtnOfPrsntlyDspl,
            3 => TextDisplayInstructions2561212158::OvrwrtDsplyPrsntlyDsplydInfrmtn,
            2 => TextDisplayInstructions2561212158::AppndAtEndOfDsplyTrnsmttdInfrmt,
            value => TextDisplayInstructions2561212158::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MovementStatusOfRamp32566746366 {
    NotAvailable,
    Error,
    RampBeingMoved,
    RampNotBeingMoved,
    XValue(u64),
}

impl From<u64> for MovementStatusOfRamp32566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MovementStatusOfRamp32566746366::NotAvailable,
            2 => MovementStatusOfRamp32566746366::Error,
            1 => MovementStatusOfRamp32566746366::RampBeingMoved,
            0 => MovementStatusOfRamp32566746366::RampNotBeingMoved,
            value => MovementStatusOfRamp32566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfRamp32566746366 {
    NotAvailable,
    Error,
    RampEnabled,
    RampDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfRamp32566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfRamp32566746366::NotAvailable,
            2 => EnableStatusOfRamp32566746366::Error,
            1 => EnableStatusOfRamp32566746366::RampEnabled,
            0 => EnableStatusOfRamp32566746366::RampDisabled,
            value => EnableStatusOfRamp32566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetractStatusOfRamp32566746366 {
    NotAvailable,
    Error,
    RampEx,
    RampRetracted,
    XValue(u64),
}

impl From<u64> for RetractStatusOfRamp32566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RetractStatusOfRamp32566746366::NotAvailable,
            2 => RetractStatusOfRamp32566746366::Error,
            1 => RetractStatusOfRamp32566746366::RampEx,
            0 => RetractStatusOfRamp32566746366::RampRetracted,
            value => RetractStatusOfRamp32566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MovementStatusOfRamp22566746366 {
    NotAvailable,
    Error,
    RampBeingMoved,
    RampNotBeingMoved,
    XValue(u64),
}

impl From<u64> for MovementStatusOfRamp22566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MovementStatusOfRamp22566746366::NotAvailable,
            2 => MovementStatusOfRamp22566746366::Error,
            1 => MovementStatusOfRamp22566746366::RampBeingMoved,
            0 => MovementStatusOfRamp22566746366::RampNotBeingMoved,
            value => MovementStatusOfRamp22566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfRamp22566746366 {
    NotAvailable,
    Error,
    RampEnabled,
    RampDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfRamp22566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfRamp22566746366::NotAvailable,
            2 => EnableStatusOfRamp22566746366::Error,
            1 => EnableStatusOfRamp22566746366::RampEnabled,
            0 => EnableStatusOfRamp22566746366::RampDisabled,
            value => EnableStatusOfRamp22566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetractStatusOfRamp22566746366 {
    NotAvailable,
    Error,
    RampEx,
    RampRetracted,
    XValue(u64),
}

impl From<u64> for RetractStatusOfRamp22566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RetractStatusOfRamp22566746366::NotAvailable,
            2 => RetractStatusOfRamp22566746366::Error,
            1 => RetractStatusOfRamp22566746366::RampEx,
            0 => RetractStatusOfRamp22566746366::RampRetracted,
            value => RetractStatusOfRamp22566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MovementStatusOfRamp12566746366 {
    NotAvailable,
    Error,
    RampBeingMoved,
    RampNotBeingMoved,
    XValue(u64),
}

impl From<u64> for MovementStatusOfRamp12566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MovementStatusOfRamp12566746366::NotAvailable,
            2 => MovementStatusOfRamp12566746366::Error,
            1 => MovementStatusOfRamp12566746366::RampBeingMoved,
            0 => MovementStatusOfRamp12566746366::RampNotBeingMoved,
            value => MovementStatusOfRamp12566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfRamp12566746366 {
    NotAvailable,
    Error,
    RampEnabled,
    RampDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfRamp12566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfRamp12566746366::NotAvailable,
            2 => EnableStatusOfRamp12566746366::Error,
            1 => EnableStatusOfRamp12566746366::RampEnabled,
            0 => EnableStatusOfRamp12566746366::RampDisabled,
            value => EnableStatusOfRamp12566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetractStatusOfRamp12566746366 {
    NotAvailable,
    Error,
    RampEx,
    RampRetracted,
    XValue(u64),
}

impl From<u64> for RetractStatusOfRamp12566746366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RetractStatusOfRamp12566746366::NotAvailable,
            2 => RetractStatusOfRamp12566746366::Error,
            1 => RetractStatusOfRamp12566746366::RampEx,
            0 => RetractStatusOfRamp12566746366::RampRetracted,
            value => RetractStatusOfRamp12566746366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaneDepartureWarningEnableCmd2561277694 {
    DonTCare,
    Reserved,
    EnableLaneDepartureWarning,
    DisableLaneDepartureWarning,
    XValue(u64),
}

impl From<u64> for LaneDepartureWarningEnableCmd2561277694 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LaneDepartureWarningEnableCmd2561277694::DonTCare,
            2 => LaneDepartureWarningEnableCmd2561277694::Reserved,
            1 => LaneDepartureWarningEnableCmd2561277694::EnableLaneDepartureWarning,
            0 => LaneDepartureWarningEnableCmd2561277694::DisableLaneDepartureWarning,
            value => LaneDepartureWarningEnableCmd2561277694::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum J2012dtcStatus2633861886 {
    DtcIsActive,
    DtcIsPreviouslyActive,
    XValue(u64),
}

impl From<u64> for J2012dtcStatus2633861886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => J2012dtcStatus2633861886::DtcIsActive,
            0 => J2012dtcStatus2633861886::DtcIsPreviouslyActive,
            value => J2012dtcStatus2633861886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRgnrtnInhbtdStatus2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Inhibited,
    NotInhibited,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRgnrtnInhbtdStatus2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRgnrtnInhbtdStatus2566749438::NotAvailable,
            2 => PrtcltTrpActvRgnrtnInhbtdStatus2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpActvRgnrtnInhbtdStatus2566749438::Inhibited,
            0 => PrtcltTrpActvRgnrtnInhbtdStatus2566749438::NotInhibited,
            value => PrtcltTrpActvRgnrtnInhbtdStatus2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParticulateTrapStatus2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    RegenerationNeededHighestLevel,
    RegenerationNeededModerateLevel,
    RegenerationNeededLowestLevel,
    RegenerationNotNeeded,
    XValue(u64),
}

impl From<u64> for ParticulateTrapStatus2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => ParticulateTrapStatus2566749438::NotAvailable,
            6 => ParticulateTrapStatus2566749438::ReservedForSaeAssignment,
            3 => ParticulateTrapStatus2566749438::RegenerationNeededHighestLevel,
            2 => ParticulateTrapStatus2566749438::RegenerationNeededModerateLevel,
            1 => ParticulateTrapStatus2566749438::RegenerationNeededLowestLevel,
            0 => ParticulateTrapStatus2566749438::RegenerationNotNeeded,
            value => ParticulateTrapStatus2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpActvRegenerationStatus2566749438 {
    NotAvailable,
    RgnrtnNddAtmtcllyInttdActvRgnrt,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for PrtcltTrpActvRegenerationStatus2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpActvRegenerationStatus2566749438::NotAvailable,
            2 => PrtcltTrpActvRegenerationStatus2566749438::RgnrtnNddAtmtcllyInttdActvRgnrt,
            1 => PrtcltTrpActvRegenerationStatus2566749438::Active,
            0 => PrtcltTrpActvRegenerationStatus2566749438::NotActive,
            value => PrtcltTrpActvRegenerationStatus2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PrtcltTrpPssvRegenerationStatus2566749438 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for PrtcltTrpPssvRegenerationStatus2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PrtcltTrpPssvRegenerationStatus2566749438::NotAvailable,
            2 => PrtcltTrpPssvRegenerationStatus2566749438::ReservedForSaeAssignment,
            1 => PrtcltTrpPssvRegenerationStatus2566749438::Active,
            0 => PrtcltTrpPssvRegenerationStatus2566749438::NotActive,
            value => PrtcltTrpPssvRegenerationStatus2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParticulateTrapLampCmd2566749438 {
    NotAvailable,
    OnFastBlink,
    ReservedForSaeAssignment,
    OnSolid,
    Off,
    XValue(u64),
}

impl From<u64> for ParticulateTrapLampCmd2566749438 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => ParticulateTrapLampCmd2566749438::NotAvailable,
            4 => ParticulateTrapLampCmd2566749438::OnFastBlink,
            6 => ParticulateTrapLampCmd2566749438::ReservedForSaeAssignment,
            1 => ParticulateTrapLampCmd2566749438::OnSolid,
            0 => ParticulateTrapLampCmd2566749438::Off,
            value => ParticulateTrapLampCmd2566749438::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteerAngleSensorCalibrated2565873150 {
    NotAvailable,
    Reserved,
    SasCalibrated,
    SasNotCalibrated,
    XValue(u64),
}

impl From<u64> for SteerAngleSensorCalibrated2565873150 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SteerAngleSensorCalibrated2565873150::NotAvailable,
            2 => SteerAngleSensorCalibrated2565873150::Reserved,
            1 => SteerAngleSensorCalibrated2565873150::SasCalibrated,
            0 => SteerAngleSensorCalibrated2565873150::SasNotCalibrated,
            value => SteerAngleSensorCalibrated2565873150::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteerAngleSensorActiveMode2565873150 {
    NotAvailable,
    Reserved,
    NormalModeActive,
    ProgrammingModeActive,
    XValue(u64),
}

impl From<u64> for SteerAngleSensorActiveMode2565873150 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SteerAngleSensorActiveMode2565873150::NotAvailable,
            2 => SteerAngleSensorActiveMode2565873150::Reserved,
            1 => SteerAngleSensorActiveMode2565873150::NormalModeActive,
            0 => SteerAngleSensorActiveMode2565873150::ProgrammingModeActive,
            value => SteerAngleSensorActiveMode2565873150::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteerWheelAngleRangeCounterType2565873150 {
    SignalNotAvailable,
    NotDefined,
    AbsNumberOfCounts,
    RelativeNumberOfCounts,
    XValue(u64),
}

impl From<u64> for SteerWheelAngleRangeCounterType2565873150 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SteerWheelAngleRangeCounterType2565873150::SignalNotAvailable,
            2 => SteerWheelAngleRangeCounterType2565873150::NotDefined,
            1 => SteerWheelAngleRangeCounterType2565873150::AbsNumberOfCounts,
            0 => SteerWheelAngleRangeCounterType2565873150::RelativeNumberOfCounts,
            value => SteerWheelAngleRangeCounterType2565873150::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransferCaseStatus2566751230 {
    Error,
    TrnsfrCsShftInPrgrssGrNtCnfrmed,
    WheelLow,
    Neutral,
    WheelHigh,
    XValue(u64),
}

impl From<u64> for TransferCaseStatus2566751230 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => TransferCaseStatus2566751230::Error,
            5 => TransferCaseStatus2566751230::TrnsfrCsShftInPrgrssGrNtCnfrmed,
            4 => TransferCaseStatus2566751230::WheelLow,
            2 => TransferCaseStatus2566751230::Neutral,
            1 => TransferCaseStatus2566751230::WheelHigh,
            value => TransferCaseStatus2566751230::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransOilLevelSwitch2566755838 {
    NotAvailable,
    Error,
    FullNotEmpty,
    Empty,
    XValue(u64),
}

impl From<u64> for TransOilLevelSwitch2566755838 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransOilLevelSwitch2566755838::NotAvailable,
            2 => TransOilLevelSwitch2566755838::Error,
            1 => TransOilLevelSwitch2566755838::FullNotEmpty,
            0 => TransOilLevelSwitch2566755838::Empty,
            value => TransOilLevelSwitch2566755838::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransOilFilterRestrictionSwitch2566755838 {
    NotAvailable,
    Error,
    RestrictionExistsOnOilFilter,
    NoRestriction,
    XValue(u64),
}

impl From<u64> for TransOilFilterRestrictionSwitch2566755838 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransOilFilterRestrictionSwitch2566755838::NotAvailable,
            2 => TransOilFilterRestrictionSwitch2566755838::Error,
            1 => TransOilFilterRestrictionSwitch2566755838::RestrictionExistsOnOilFilter,
            0 => TransOilFilterRestrictionSwitch2566755838::NoRestriction,
            value => TransOilFilterRestrictionSwitch2566755838::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementRearWorkLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementRearWorkLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementRearWorkLight2566799614::NotAvailable,
            2 => ImplementRearWorkLight2566799614::FaultDetected,
            1 => ImplementRearWorkLight2566799614::Activate,
            0 => ImplementRearWorkLight2566799614::Deactivate,
            value => ImplementRearWorkLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementLeftForwardWorkLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementLeftForwardWorkLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementLeftForwardWorkLight2566799614::NotAvailable,
            2 => ImplementLeftForwardWorkLight2566799614::FaultDetected,
            1 => ImplementLeftForwardWorkLight2566799614::Activate,
            0 => ImplementLeftForwardWorkLight2566799614::Deactivate,
            value => ImplementLeftForwardWorkLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementRightForwardWorkLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementRightForwardWorkLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementRightForwardWorkLight2566799614::NotAvailable,
            2 => ImplementRightForwardWorkLight2566799614::FaultDetected,
            1 => ImplementRightForwardWorkLight2566799614::Activate,
            0 => ImplementRightForwardWorkLight2566799614::Deactivate,
            value => ImplementRightForwardWorkLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementLeftFacingWorkLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementLeftFacingWorkLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementLeftFacingWorkLight2566799614::NotAvailable,
            2 => ImplementLeftFacingWorkLight2566799614::FaultDetected,
            1 => ImplementLeftFacingWorkLight2566799614::Activate,
            0 => ImplementLeftFacingWorkLight2566799614::Deactivate,
            value => ImplementLeftFacingWorkLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementRightFacingWorkLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementRightFacingWorkLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementRightFacingWorkLight2566799614::NotAvailable,
            2 => ImplementRightFacingWorkLight2566799614::FaultDetected,
            1 => ImplementRightFacingWorkLight2566799614::Activate,
            0 => ImplementRightFacingWorkLight2566799614::Deactivate,
            value => ImplementRightFacingWorkLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementOemOption1Light2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementOemOption1Light2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementOemOption1Light2566799614::NotAvailable,
            2 => ImplementOemOption1Light2566799614::FaultDetected,
            1 => ImplementOemOption1Light2566799614::Activate,
            0 => ImplementOemOption1Light2566799614::Deactivate,
            value => ImplementOemOption1Light2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementOemOption2Light2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementOemOption2Light2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementOemOption2Light2566799614::NotAvailable,
            2 => ImplementOemOption2Light2566799614::FaultDetected,
            1 => ImplementOemOption2Light2566799614::Activate,
            0 => ImplementOemOption2Light2566799614::Deactivate,
            value => ImplementOemOption2Light2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrFrontHighMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrFrontHighMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrFrontHighMountedWorkLights2566799614::NotAvailable,
            2 => TrctrFrontHighMountedWorkLights2566799614::FaultDetected,
            1 => TrctrFrontHighMountedWorkLights2566799614::Activate,
            0 => TrctrFrontHighMountedWorkLights2566799614::Deactivate,
            value => TrctrFrontHighMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctorFrontLowMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctorFrontLowMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctorFrontLowMountedWorkLights2566799614::NotAvailable,
            2 => TrctorFrontLowMountedWorkLights2566799614::FaultDetected,
            1 => TrctorFrontLowMountedWorkLights2566799614::Activate,
            0 => TrctorFrontLowMountedWorkLights2566799614::Deactivate,
            value => TrctorFrontLowMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctorSideHighMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for TrctorSideHighMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctorSideHighMountedWorkLights2566799614::NotAvailable,
            2 => TrctorSideHighMountedWorkLights2566799614::FaultDetected,
            1 => TrctorSideHighMountedWorkLights2566799614::Activated,
            0 => TrctorSideHighMountedWorkLights2566799614::Deactivated,
            value => TrctorSideHighMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorSideLowMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for TractorSideLowMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorSideLowMountedWorkLights2566799614::NotAvailable,
            2 => TractorSideLowMountedWorkLights2566799614::FaultDetected,
            1 => TractorSideLowMountedWorkLights2566799614::Activated,
            0 => TractorSideLowMountedWorkLights2566799614::Deactivated,
            value => TractorSideLowMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctorRearHighMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for TrctorRearHighMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctorRearHighMountedWorkLights2566799614::NotAvailable,
            2 => TrctorRearHighMountedWorkLights2566799614::FaultDetected,
            1 => TrctorRearHighMountedWorkLights2566799614::Activated,
            0 => TrctorRearHighMountedWorkLights2566799614::Deactivated,
            value => TrctorRearHighMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorRearLowMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TractorRearLowMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorRearLowMountedWorkLights2566799614::NotAvailable,
            2 => TractorRearLowMountedWorkLights2566799614::FaultDetected,
            1 => TractorRearLowMountedWorkLights2566799614::Activate,
            0 => TractorRearLowMountedWorkLights2566799614::Deactivate,
            value => TractorRearLowMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrUndersideMountedWorkLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrUndersideMountedWorkLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrUndersideMountedWorkLights2566799614::NotAvailable,
            2 => TrctrUndersideMountedWorkLights2566799614::FaultDetected,
            1 => TrctrUndersideMountedWorkLights2566799614::Activate,
            0 => TrctrUndersideMountedWorkLights2566799614::Deactivate,
            value => TrctrUndersideMountedWorkLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearFogLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for RearFogLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RearFogLights2566799614::NotAvailable,
            2 => RearFogLights2566799614::FaultDetected,
            1 => RearFogLights2566799614::Activated,
            0 => RearFogLights2566799614::Deactivated,
            value => RearFogLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorMarkerLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for TractorMarkerLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorMarkerLight2566799614::NotAvailable,
            2 => TractorMarkerLight2566799614::FaultDetected,
            1 => TractorMarkerLight2566799614::Activated,
            0 => TractorMarkerLight2566799614::Deactivated,
            value => TractorMarkerLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementMarkerLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for ImplementMarkerLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementMarkerLight2566799614::NotAvailable,
            2 => ImplementMarkerLight2566799614::FaultDetected,
            1 => ImplementMarkerLight2566799614::Activated,
            0 => ImplementMarkerLight2566799614::Deactivated,
            value => ImplementMarkerLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorClearanceLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for TractorClearanceLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorClearanceLight2566799614::NotAvailable,
            2 => TractorClearanceLight2566799614::FaultDetected,
            1 => TractorClearanceLight2566799614::Activated,
            0 => TractorClearanceLight2566799614::Deactivated,
            value => TractorClearanceLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementClearanceLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for ImplementClearanceLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementClearanceLight2566799614::NotAvailable,
            2 => ImplementClearanceLight2566799614::FaultDetected,
            1 => ImplementClearanceLight2566799614::Activated,
            0 => ImplementClearanceLight2566799614::Deactivated,
            value => ImplementClearanceLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LeftStopLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for LeftStopLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LeftStopLight2566799614::NotAvailable,
            2 => LeftStopLight2566799614::FaultDetected,
            1 => LeftStopLight2566799614::Activated,
            0 => LeftStopLight2566799614::Deactivated,
            value => LeftStopLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RightStopLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for RightStopLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RightStopLight2566799614::NotAvailable,
            2 => RightStopLight2566799614::FaultDetected,
            1 => RightStopLight2566799614::Activated,
            0 => RightStopLight2566799614::Deactivated,
            value => RightStopLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CenterStopLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for CenterStopLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CenterStopLight2566799614::NotAvailable,
            2 => CenterStopLight2566799614::FaultDetected,
            1 => CenterStopLight2566799614::Activated,
            0 => CenterStopLight2566799614::Deactivated,
            value => CenterStopLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BackUpLightAndAlarmHorn2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for BackUpLightAndAlarmHorn2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BackUpLightAndAlarmHorn2566799614::NotAvailable,
            2 => BackUpLightAndAlarmHorn2566799614::FaultDetected,
            1 => BackUpLightAndAlarmHorn2566799614::Activated,
            0 => BackUpLightAndAlarmHorn2566799614::Deactivated,
            value => BackUpLightAndAlarmHorn2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LeftTurnSignalLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for LeftTurnSignalLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LeftTurnSignalLights2566799614::NotAvailable,
            2 => LeftTurnSignalLights2566799614::FaultDetected,
            1 => LeftTurnSignalLights2566799614::Activated,
            0 => LeftTurnSignalLights2566799614::Deactivated,
            value => LeftTurnSignalLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RightTurnSignalLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for RightTurnSignalLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RightTurnSignalLights2566799614::NotAvailable,
            2 => RightTurnSignalLights2566799614::FaultDetected,
            1 => RightTurnSignalLights2566799614::Activated,
            0 => RightTurnSignalLights2566799614::Deactivated,
            value => RightTurnSignalLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RotatingBeaconLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for RotatingBeaconLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RotatingBeaconLight2566799614::NotAvailable,
            2 => RotatingBeaconLight2566799614::FaultDetected,
            1 => RotatingBeaconLight2566799614::Activated,
            0 => RotatingBeaconLight2566799614::Deactivated,
            value => RotatingBeaconLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorFrontFogLights2566799614 {
    NotAvailable,
    FaultDetected,
    Activated,
    Deactivated,
    XValue(u64),
}

impl From<u64> for TractorFrontFogLights2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorFrontFogLights2566799614::NotAvailable,
            2 => TractorFrontFogLights2566799614::FaultDetected,
            1 => TractorFrontFogLights2566799614::Activated,
            0 => TractorFrontFogLights2566799614::Deactivated,
            value => TractorFrontFogLights2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HighBeamHeadLightData2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for HighBeamHeadLightData2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HighBeamHeadLightData2566799614::NotAvailable,
            2 => HighBeamHeadLightData2566799614::FaultDetected,
            1 => HighBeamHeadLightData2566799614::Activate,
            0 => HighBeamHeadLightData2566799614::Deactivate,
            value => HighBeamHeadLightData2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LowBeamHeadLightData2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for LowBeamHeadLightData2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LowBeamHeadLightData2566799614::NotAvailable,
            2 => LowBeamHeadLightData2566799614::FaultDetected,
            1 => LowBeamHeadLightData2566799614::Activate,
            0 => LowBeamHeadLightData2566799614::Deactivate,
            value => LowBeamHeadLightData2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AltBeamHeadLightData2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for AltBeamHeadLightData2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AltBeamHeadLightData2566799614::NotAvailable,
            2 => AltBeamHeadLightData2566799614::FaultDetected,
            1 => AltBeamHeadLightData2566799614::Activate,
            0 => AltBeamHeadLightData2566799614::Deactivate,
            value => AltBeamHeadLightData2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RunningLight2566799614 {
    NotAvailable,
    FaultDetected,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for RunningLight2566799614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RunningLight2566799614::NotAvailable,
            2 => RunningLight2566799614::FaultDetected,
            1 => RunningLight2566799614::Activate,
            0 => RunningLight2566799614::Deactivate,
            value => RunningLight2566799614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementRearWorkLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementRearWorkLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementRearWorkLightCmd2365473278::DonTCare,
            2 => ImplementRearWorkLightCmd2365473278::Reserved,
            1 => ImplementRearWorkLightCmd2365473278::Activate,
            0 => ImplementRearWorkLightCmd2365473278::Deactivate,
            value => ImplementRearWorkLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplmentLeftForwardWorkLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplmentLeftForwardWorkLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplmentLeftForwardWorkLightCmd2365473278::DonTCare,
            2 => ImplmentLeftForwardWorkLightCmd2365473278::Reserved,
            1 => ImplmentLeftForwardWorkLightCmd2365473278::Activate,
            0 => ImplmentLeftForwardWorkLightCmd2365473278::Deactivate,
            value => ImplmentLeftForwardWorkLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplmntRightForwardWorkLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplmntRightForwardWorkLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplmntRightForwardWorkLightCmd2365473278::DonTCare,
            2 => ImplmntRightForwardWorkLightCmd2365473278::Reserved,
            1 => ImplmntRightForwardWorkLightCmd2365473278::Activate,
            0 => ImplmntRightForwardWorkLightCmd2365473278::Deactivate,
            value => ImplmntRightForwardWorkLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LightingDataRqCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for LightingDataRqCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LightingDataRqCmd2365473278::DonTCare,
            2 => LightingDataRqCmd2365473278::Reserved,
            1 => LightingDataRqCmd2365473278::Activate,
            0 => LightingDataRqCmd2365473278::Deactivate,
            value => LightingDataRqCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementLeftFacingWorkLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementLeftFacingWorkLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementLeftFacingWorkLightCmd2365473278::DonTCare,
            2 => ImplementLeftFacingWorkLightCmd2365473278::Reserved,
            1 => ImplementLeftFacingWorkLightCmd2365473278::Activate,
            0 => ImplementLeftFacingWorkLightCmd2365473278::Deactivate,
            value => ImplementLeftFacingWorkLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplmentRightFacingWorkLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplmentRightFacingWorkLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplmentRightFacingWorkLightCmd2365473278::DonTCare,
            2 => ImplmentRightFacingWorkLightCmd2365473278::Reserved,
            1 => ImplmentRightFacingWorkLightCmd2365473278::Activate,
            0 => ImplmentRightFacingWorkLightCmd2365473278::Deactivate,
            value => ImplmentRightFacingWorkLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementOemOption1LightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementOemOption1LightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementOemOption1LightCmd2365473278::DonTCare,
            2 => ImplementOemOption1LightCmd2365473278::Reserved,
            1 => ImplementOemOption1LightCmd2365473278::Activate,
            0 => ImplementOemOption1LightCmd2365473278::Deactivate,
            value => ImplementOemOption1LightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementOemOption2LightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementOemOption2LightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementOemOption2LightCmd2365473278::DonTCare,
            2 => ImplementOemOption2LightCmd2365473278::Reserved,
            1 => ImplementOemOption2LightCmd2365473278::Activate,
            0 => ImplementOemOption2LightCmd2365473278::Deactivate,
            value => ImplementOemOption2LightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrFrntHghMuntedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrFrntHghMuntedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrFrntHghMuntedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrFrntHghMuntedWorkLightsCmd2365473278::Reserved,
            1 => TrctrFrntHghMuntedWorkLightsCmd2365473278::Activate,
            0 => TrctrFrntHghMuntedWorkLightsCmd2365473278::Deactivate,
            value => TrctrFrntHghMuntedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrFrntLwMountedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrFrntLwMountedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrFrntLwMountedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrFrntLwMountedWorkLightsCmd2365473278::Reserved,
            1 => TrctrFrntLwMountedWorkLightsCmd2365473278::Activate,
            0 => TrctrFrntLwMountedWorkLightsCmd2365473278::Deactivate,
            value => TrctrFrntLwMountedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrSdHighMountedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrSdHighMountedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrSdHighMountedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrSdHighMountedWorkLightsCmd2365473278::Reserved,
            1 => TrctrSdHighMountedWorkLightsCmd2365473278::Activate,
            0 => TrctrSdHighMountedWorkLightsCmd2365473278::Deactivate,
            value => TrctrSdHighMountedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrSdeLowMountedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrSdeLowMountedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrSdeLowMountedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrSdeLowMountedWorkLightsCmd2365473278::Reserved,
            1 => TrctrSdeLowMountedWorkLightsCmd2365473278::Activate,
            0 => TrctrSdeLowMountedWorkLightsCmd2365473278::Deactivate,
            value => TrctrSdeLowMountedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrRrHighMountedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrRrHighMountedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrRrHighMountedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrRrHighMountedWorkLightsCmd2365473278::Reserved,
            1 => TrctrRrHighMountedWorkLightsCmd2365473278::Activate,
            0 => TrctrRrHighMountedWorkLightsCmd2365473278::Deactivate,
            value => TrctrRrHighMountedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrRarLowMountedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrRarLowMountedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrRarLowMountedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrRarLowMountedWorkLightsCmd2365473278::Reserved,
            1 => TrctrRarLowMountedWorkLightsCmd2365473278::Activate,
            0 => TrctrRarLowMountedWorkLightsCmd2365473278::Deactivate,
            value => TrctrRarLowMountedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrUndrsdMountedWorkLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TrctrUndrsdMountedWorkLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrUndrsdMountedWorkLightsCmd2365473278::DonTCare,
            2 => TrctrUndrsdMountedWorkLightsCmd2365473278::Reserved,
            1 => TrctrUndrsdMountedWorkLightsCmd2365473278::Activate,
            0 => TrctrUndrsdMountedWorkLightsCmd2365473278::Deactivate,
            value => TrctrUndrsdMountedWorkLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearFogLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for RearFogLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RearFogLightCmd2365473278::DonTCare,
            2 => RearFogLightCmd2365473278::Reserved,
            1 => RearFogLightCmd2365473278::Activate,
            0 => RearFogLightCmd2365473278::Deactivate,
            value => RearFogLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorMarkerLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TractorMarkerLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorMarkerLightCmd2365473278::DonTCare,
            2 => TractorMarkerLightCmd2365473278::Reserved,
            1 => TractorMarkerLightCmd2365473278::Activate,
            0 => TractorMarkerLightCmd2365473278::Deactivate,
            value => TractorMarkerLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementMarkerLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementMarkerLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementMarkerLightCmd2365473278::DonTCare,
            2 => ImplementMarkerLightCmd2365473278::Reserved,
            1 => ImplementMarkerLightCmd2365473278::Activate,
            0 => ImplementMarkerLightCmd2365473278::Deactivate,
            value => ImplementMarkerLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorClearanceLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TractorClearanceLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorClearanceLightCmd2365473278::DonTCare,
            2 => TractorClearanceLightCmd2365473278::Reserved,
            1 => TractorClearanceLightCmd2365473278::Activate,
            0 => TractorClearanceLightCmd2365473278::Deactivate,
            value => TractorClearanceLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ImplementClearanceLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for ImplementClearanceLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ImplementClearanceLightCmd2365473278::DonTCare,
            2 => ImplementClearanceLightCmd2365473278::Reserved,
            1 => ImplementClearanceLightCmd2365473278::Activate,
            0 => ImplementClearanceLightCmd2365473278::Deactivate,
            value => ImplementClearanceLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LeftStopLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for LeftStopLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LeftStopLightCmd2365473278::DonTCare,
            2 => LeftStopLightCmd2365473278::Reserved,
            1 => LeftStopLightCmd2365473278::Activate,
            0 => LeftStopLightCmd2365473278::Deactivate,
            value => LeftStopLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RightStopLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for RightStopLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RightStopLightCmd2365473278::DonTCare,
            2 => RightStopLightCmd2365473278::Reserved,
            1 => RightStopLightCmd2365473278::Activate,
            0 => RightStopLightCmd2365473278::Deactivate,
            value => RightStopLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CenterStopLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for CenterStopLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CenterStopLightCmd2365473278::DonTCare,
            2 => CenterStopLightCmd2365473278::Reserved,
            1 => CenterStopLightCmd2365473278::Activate,
            0 => CenterStopLightCmd2365473278::Deactivate,
            value => CenterStopLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BackUpLightAndAlarmHornCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for BackUpLightAndAlarmHornCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BackUpLightAndAlarmHornCmd2365473278::DonTCare,
            2 => BackUpLightAndAlarmHornCmd2365473278::Reserved,
            1 => BackUpLightAndAlarmHornCmd2365473278::Activate,
            0 => BackUpLightAndAlarmHornCmd2365473278::Deactivate,
            value => BackUpLightAndAlarmHornCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LeftTurnSignalLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for LeftTurnSignalLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LeftTurnSignalLightsCmd2365473278::DonTCare,
            2 => LeftTurnSignalLightsCmd2365473278::Reserved,
            1 => LeftTurnSignalLightsCmd2365473278::Activate,
            0 => LeftTurnSignalLightsCmd2365473278::Deactivate,
            value => LeftTurnSignalLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RightTurnSignalLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for RightTurnSignalLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RightTurnSignalLightsCmd2365473278::DonTCare,
            2 => RightTurnSignalLightsCmd2365473278::Reserved,
            1 => RightTurnSignalLightsCmd2365473278::Activate,
            0 => RightTurnSignalLightsCmd2365473278::Deactivate,
            value => RightTurnSignalLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RotatingBeaconLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for RotatingBeaconLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RotatingBeaconLightCmd2365473278::DonTCare,
            2 => RotatingBeaconLightCmd2365473278::Reserved,
            1 => RotatingBeaconLightCmd2365473278::Activate,
            0 => RotatingBeaconLightCmd2365473278::Deactivate,
            value => RotatingBeaconLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorFrontFogLightsCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for TractorFrontFogLightsCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractorFrontFogLightsCmd2365473278::DonTCare,
            2 => TractorFrontFogLightsCmd2365473278::Reserved,
            1 => TractorFrontFogLightsCmd2365473278::Activate,
            0 => TractorFrontFogLightsCmd2365473278::Deactivate,
            value => TractorFrontFogLightsCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HighBeamHeadLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for HighBeamHeadLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HighBeamHeadLightCmd2365473278::DonTCare,
            2 => HighBeamHeadLightCmd2365473278::Reserved,
            1 => HighBeamHeadLightCmd2365473278::Activate,
            0 => HighBeamHeadLightCmd2365473278::Deactivate,
            value => HighBeamHeadLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LowBeamHeadLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for LowBeamHeadLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LowBeamHeadLightCmd2365473278::DonTCare,
            2 => LowBeamHeadLightCmd2365473278::Reserved,
            1 => LowBeamHeadLightCmd2365473278::Activate,
            0 => LowBeamHeadLightCmd2365473278::Deactivate,
            value => LowBeamHeadLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AltBeamHeadLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for AltBeamHeadLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AltBeamHeadLightCmd2365473278::DonTCare,
            2 => AltBeamHeadLightCmd2365473278::Reserved,
            1 => AltBeamHeadLightCmd2365473278::Activate,
            0 => AltBeamHeadLightCmd2365473278::Deactivate,
            value => AltBeamHeadLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RunningLightCmd2365473278 {
    DonTCare,
    Reserved,
    Activate,
    Deactivate,
    XValue(u64),
}

impl From<u64> for RunningLightCmd2365473278 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RunningLightCmd2365473278::DonTCare,
            2 => RunningLightCmd2365473278::Reserved,
            1 => RunningLightCmd2365473278::Activate,
            0 => RunningLightCmd2365473278::Deactivate,
            value => RunningLightCmd2365473278::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BladeCtrlMode2365485822 {
    InactiveAutomaticMode,
    AutomaticMode,
    ManualMode,
    XValue(u64),
}

impl From<u64> for BladeCtrlMode2365485822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => BladeCtrlMode2365485822::InactiveAutomaticMode,
            1 => BladeCtrlMode2365485822::AutomaticMode,
            0 => BladeCtrlMode2365485822::ManualMode,
            value => BladeCtrlMode2365485822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOprtrPrmryIntrmdtSpdSlctStte2566768894 {
    NotAvailable,
    SaeReserved,
    Thr1101CtrlSttIsIscSttng1Thru13,
    CtrlSttIsIscFnctnltyIsNtRqdEngO,
    XValue(u64),
}

impl From<u64> for EngOprtrPrmryIntrmdtSpdSlctStte2566768894 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngOprtrPrmryIntrmdtSpdSlctStte2566768894::NotAvailable,
            14 => EngOprtrPrmryIntrmdtSpdSlctStte2566768894::SaeReserved,
            1 => EngOprtrPrmryIntrmdtSpdSlctStte2566768894::Thr1101CtrlSttIsIscSttng1Thru13,
            0 => EngOprtrPrmryIntrmdtSpdSlctStte2566768894::CtrlSttIsIscFnctnltyIsNtRqdEngO,
            value => EngOprtrPrmryIntrmdtSpdSlctStte2566768894::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOprtrPrmryIntrmdtSpeedSelect2566769406 {
    NotAvailable,
    ErrorCondition,
    Thr1101IndctsThtIscSttng1Thr13I,
    IndctsThtIscFnctnltyIsNtRqdEngO,
    XValue(u64),
}

impl From<u64> for EngOprtrPrmryIntrmdtSpeedSelect2566769406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngOprtrPrmryIntrmdtSpeedSelect2566769406::NotAvailable,
            14 => EngOprtrPrmryIntrmdtSpeedSelect2566769406::ErrorCondition,
            1 => EngOprtrPrmryIntrmdtSpeedSelect2566769406::Thr1101IndctsThtIscSttng1Thr13I,
            0 => EngOprtrPrmryIntrmdtSpeedSelect2566769406::IndctsThtIscFnctnltyIsNtRqdEngO,
            value => EngOprtrPrmryIntrmdtSpeedSelect2566769406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CabHeatingZone2566811134 {
    NotAvailable,
    Reserved,
    CabHeatingZoneOn,
    CabHeatingZoneOff,
    XValue(u64),
}

impl From<u64> for CabHeatingZone2566811134 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CabHeatingZone2566811134::NotAvailable,
            2 => CabHeatingZone2566811134::Reserved,
            1 => CabHeatingZone2566811134::CabHeatingZoneOn,
            0 => CabHeatingZone2566811134::CabHeatingZoneOff,
            value => CabHeatingZone2566811134::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngHeatingZone2566811134 {
    NotAvailable,
    Reserved,
    EngHeatingZoneOn,
    EngHeatingZoneOff,
    XValue(u64),
}

impl From<u64> for EngHeatingZone2566811134 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngHeatingZone2566811134::NotAvailable,
            2 => EngHeatingZone2566811134::Reserved,
            1 => EngHeatingZone2566811134::EngHeatingZoneOn,
            0 => EngHeatingZone2566811134::EngHeatingZoneOff,
            value => EngHeatingZone2566811134::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CabVentilation2566811134 {
    NotAvailable,
    Reserved,
    CabIsVentilated,
    CabNotVentilated,
    XValue(u64),
}

impl From<u64> for CabVentilation2566811134 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CabVentilation2566811134::NotAvailable,
            2 => CabVentilation2566811134::Reserved,
            1 => CabVentilation2566811134::CabIsVentilated,
            0 => CabVentilation2566811134::CabNotVentilated,
            value => CabVentilation2566811134::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxilaryHeaterWaterPumpStatus2566811134 {
    NotAvailable,
    Reserved,
    WaterPumpIsRunning,
    WaterPumpIsNotRunning,
    XValue(u64),
}

impl From<u64> for AuxilaryHeaterWaterPumpStatus2566811134 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxilaryHeaterWaterPumpStatus2566811134::NotAvailable,
            2 => AuxilaryHeaterWaterPumpStatus2566811134::Reserved,
            1 => AuxilaryHeaterWaterPumpStatus2566811134::WaterPumpIsRunning,
            0 => AuxilaryHeaterWaterPumpStatus2566811134::WaterPumpIsNotRunning,
            value => AuxilaryHeaterWaterPumpStatus2566811134::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxHeaterMode2566811134 {
    NotAvailable,
    Error,
    X1101notDefined,
    NormalMode,
    EconomyMode,
    OffDtadrPrErpnRgltnsFrTrnsprtOf,
    HeaterNotActive,
    XValue(u64),
}

impl From<u64> for AuxHeaterMode2566811134 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => AuxHeaterMode2566811134::NotAvailable,
            14 => AuxHeaterMode2566811134::Error,
            4 => AuxHeaterMode2566811134::X1101notDefined,
            3 => AuxHeaterMode2566811134::NormalMode,
            2 => AuxHeaterMode2566811134::EconomyMode,
            1 => AuxHeaterMode2566811134::OffDtadrPrErpnRgltnsFrTrnsprtOf,
            0 => AuxHeaterMode2566811134::HeaterNotActive,
            value => AuxHeaterMode2566811134::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FireApparatusPumpEngagement2565867774 {
    NotAvailableNotInstalled,
    Error,
    PumpEngaged,
    PumpNotEngaged,
    XValue(u64),
}

impl From<u64> for FireApparatusPumpEngagement2565867774 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FireApparatusPumpEngagement2565867774::NotAvailableNotInstalled,
            2 => FireApparatusPumpEngagement2565867774::Error,
            1 => FireApparatusPumpEngagement2565867774::PumpEngaged,
            0 => FireApparatusPumpEngagement2565867774::PumpNotEngaged,
            value => FireApparatusPumpEngagement2565867774::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngHydPressGovernorSwitch2565867774 {
    NotAvailable,
    ErrorIndicator,
    PressModeActive,
    PressModeInactive,
    XValue(u64),
}

impl From<u64> for EngHydPressGovernorSwitch2565867774 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngHydPressGovernorSwitch2565867774::NotAvailable,
            2 => EngHydPressGovernorSwitch2565867774::ErrorIndicator,
            1 => EngHydPressGovernorSwitch2565867774::PressModeActive,
            0 => EngHydPressGovernorSwitch2565867774::PressModeInactive,
            value => EngHydPressGovernorSwitch2565867774::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngHydPrssGovernorModeIndicator2565867774 {
    NotAvailable,
    ErrorIndicator,
    Enabled,
    Disabled,
    XValue(u64),
}

impl From<u64> for EngHydPrssGovernorModeIndicator2565867774 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngHydPrssGovernorModeIndicator2565867774::NotAvailable,
            2 => EngHydPrssGovernorModeIndicator2565867774::ErrorIndicator,
            1 => EngHydPrssGovernorModeIndicator2565867774::Enabled,
            0 => EngHydPrssGovernorModeIndicator2565867774::Disabled,
            value => EngHydPrssGovernorModeIndicator2565867774::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydBrakeFluidLevelSwitch2365449982 {
    NotAvailable,
    ErrorIndicator,
    FluidLevelIsSufficient,
    FluidLevelIsNotSufficient,
    XValue(u64),
}

impl From<u64> for HydBrakeFluidLevelSwitch2365449982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydBrakeFluidLevelSwitch2365449982::NotAvailable,
            2 => HydBrakeFluidLevelSwitch2365449982::ErrorIndicator,
            1 => HydBrakeFluidLevelSwitch2365449982::FluidLevelIsSufficient,
            0 => HydBrakeFluidLevelSwitch2365449982::FluidLevelIsNotSufficient,
            value => HydBrakeFluidLevelSwitch2365449982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydBrakeSystemAudibleWarningCmd2365449982 {
    DontCare,
    Reserved,
    AudibleWarningOn,
    AudibleWarningOff,
    XValue(u64),
}

impl From<u64> for HydBrakeSystemAudibleWarningCmd2365449982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydBrakeSystemAudibleWarningCmd2365449982::DontCare,
            2 => HydBrakeSystemAudibleWarningCmd2365449982::Reserved,
            1 => HydBrakeSystemAudibleWarningCmd2365449982::AudibleWarningOn,
            0 => HydBrakeSystemAudibleWarningCmd2365449982::AudibleWarningOff,
            value => HydBrakeSystemAudibleWarningCmd2365449982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydBrkePressSupplyStateCircuit22365449982 {
    NotAvailable,
    ErrorIndicator,
    SupplyIsReliable,
    SupplyIsNotReliable,
    XValue(u64),
}

impl From<u64> for HydBrkePressSupplyStateCircuit22365449982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydBrkePressSupplyStateCircuit22365449982::NotAvailable,
            2 => HydBrkePressSupplyStateCircuit22365449982::ErrorIndicator,
            1 => HydBrkePressSupplyStateCircuit22365449982::SupplyIsReliable,
            0 => HydBrkePressSupplyStateCircuit22365449982::SupplyIsNotReliable,
            value => HydBrkePressSupplyStateCircuit22365449982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydBrkePressSupplyStateCircuit12365449982 {
    NotAvailable,
    ErrorIndicator,
    SupplyIsReliable,
    SupplyIsNotReliable,
    XValue(u64),
}

impl From<u64> for HydBrkePressSupplyStateCircuit12365449982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydBrkePressSupplyStateCircuit12365449982::NotAvailable,
            2 => HydBrkePressSupplyStateCircuit12365449982::ErrorIndicator,
            1 => HydBrkePressSupplyStateCircuit12365449982::SupplyIsReliable,
            0 => HydBrkePressSupplyStateCircuit12365449982::SupplyIsNotReliable,
            value => HydBrkePressSupplyStateCircuit12365449982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydBrkPressWarningStateCircuit22365449982 {
    NotAvailable,
    ErrorIndicator,
    PressLevelBelowWarningLevel,
    PressLevelSufficient,
    XValue(u64),
}

impl From<u64> for HydBrkPressWarningStateCircuit22365449982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydBrkPressWarningStateCircuit22365449982::NotAvailable,
            2 => HydBrkPressWarningStateCircuit22365449982::ErrorIndicator,
            1 => HydBrkPressWarningStateCircuit22365449982::PressLevelBelowWarningLevel,
            0 => HydBrkPressWarningStateCircuit22365449982::PressLevelSufficient,
            value => HydBrkPressWarningStateCircuit22365449982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydBrkPressWarningStateCircuit12365449982 {
    NotAvailable,
    ErrorIndicator,
    PressLevelBelowWarningLevel,
    PressLevelSufficient,
    XValue(u64),
}

impl From<u64> for HydBrkPressWarningStateCircuit12365449982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydBrkPressWarningStateCircuit12365449982::NotAvailable,
            2 => HydBrkPressWarningStateCircuit12365449982::ErrorIndicator,
            1 => HydBrkPressWarningStateCircuit12365449982::PressLevelBelowWarningLevel,
            0 => HydBrkPressWarningStateCircuit12365449982::PressLevelSufficient,
            value => HydBrkPressWarningStateCircuit12365449982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntSttusTransInputShaftPto12566759678 {
    NotAvailable,
    Error,
    DriveIsEngaged,
    DriveNotEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntSttusTransInputShaftPto12566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntSttusTransInputShaftPto12566759678::NotAvailable,
            2 => EnggmntSttusTransInputShaftPto12566759678::Error,
            1 => EnggmntSttusTransInputShaftPto12566759678::DriveIsEngaged,
            0 => EnggmntSttusTransInputShaftPto12566759678::DriveNotEngaged,
            value => EnggmntSttusTransInputShaftPto12566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntSttusTransInputShaftPto22566759678 {
    NotAvailable,
    Error,
    DriveIsEngaged,
    DriveNotEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntSttusTransInputShaftPto22566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntSttusTransInputShaftPto22566759678::NotAvailable,
            2 => EnggmntSttusTransInputShaftPto22566759678::Error,
            1 => EnggmntSttusTransInputShaftPto22566759678::DriveIsEngaged,
            0 => EnggmntSttusTransInputShaftPto22566759678::DriveNotEngaged,
            value => EnggmntSttusTransInputShaftPto22566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntSttusTransOutputShaftPto2566759678 {
    NotAvailable,
    Error,
    DriveIsEngaged,
    DriveNotEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntSttusTransOutputShaftPto2566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntSttusTransOutputShaftPto2566759678::NotAvailable,
            2 => EnggmntSttusTransOutputShaftPto2566759678::Error,
            1 => EnggmntSttusTransOutputShaftPto2566759678::DriveIsEngaged,
            0 => EnggmntSttusTransOutputShaftPto2566759678::DriveNotEngaged,
            value => EnggmntSttusTransOutputShaftPto2566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntSttsTrnsfrCsOtptShaftPto2566759678 {
    NotAvailable,
    Error,
    DriveIsEngaged,
    DriveNotEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntSttsTrnsfrCsOtptShaftPto2566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntSttsTrnsfrCsOtptShaftPto2566759678::NotAvailable,
            2 => EnggmntSttsTrnsfrCsOtptShaftPto2566759678::Error,
            1 => EnggmntSttsTrnsfrCsOtptShaftPto2566759678::DriveIsEngaged,
            0 => EnggmntSttsTrnsfrCsOtptShaftPto2566759678::DriveNotEngaged,
            value => EnggmntSttsTrnsfrCsOtptShaftPto2566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntCnsntTransInputShaftPto12566759678 {
    NotAvailable,
    Error,
    CnsentGivenPtoDriveMayBeEngaged,
    CnsntNtGvnPtoDrvShldNtBeEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntCnsntTransInputShaftPto12566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntCnsntTransInputShaftPto12566759678::NotAvailable,
            2 => EnggmntCnsntTransInputShaftPto12566759678::Error,
            1 => EnggmntCnsntTransInputShaftPto12566759678::CnsentGivenPtoDriveMayBeEngaged,
            0 => EnggmntCnsntTransInputShaftPto12566759678::CnsntNtGvnPtoDrvShldNtBeEngaged,
            value => EnggmntCnsntTransInputShaftPto12566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntCnsntTransInputShaftPto22566759678 {
    NotAvailable,
    Error,
    CnsentGivenPtoDriveMayBeEngaged,
    CnsntNtGvnPtoDrvShldNtBeEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntCnsntTransInputShaftPto22566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntCnsntTransInputShaftPto22566759678::NotAvailable,
            2 => EnggmntCnsntTransInputShaftPto22566759678::Error,
            1 => EnggmntCnsntTransInputShaftPto22566759678::CnsentGivenPtoDriveMayBeEngaged,
            0 => EnggmntCnsntTransInputShaftPto22566759678::CnsntNtGvnPtoDrvShldNtBeEngaged,
            value => EnggmntCnsntTransInputShaftPto22566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntCnsntTransOutputShaftPto2566759678 {
    NotAvailable,
    Error,
    CnsentGivenPtoDriveMayBeEngaged,
    CnsntNtGvnPtoDrvShldNtBeEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntCnsntTransOutputShaftPto2566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntCnsntTransOutputShaftPto2566759678::NotAvailable,
            2 => EnggmntCnsntTransOutputShaftPto2566759678::Error,
            1 => EnggmntCnsntTransOutputShaftPto2566759678::CnsentGivenPtoDriveMayBeEngaged,
            0 => EnggmntCnsntTransOutputShaftPto2566759678::CnsntNtGvnPtoDrvShldNtBeEngaged,
            value => EnggmntCnsntTransOutputShaftPto2566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnggmntCnsntTrnsfrCsOtptShftPto2566759678 {
    NotAvailable,
    Error,
    CnsentGivenPtoDriveMayBeEngaged,
    CnsntNtGvnPtoDrvShldNtBeEngaged,
    XValue(u64),
}

impl From<u64> for EnggmntCnsntTrnsfrCsOtptShftPto2566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnggmntCnsntTrnsfrCsOtptShftPto2566759678::NotAvailable,
            2 => EnggmntCnsntTrnsfrCsOtptShftPto2566759678::Error,
            1 => EnggmntCnsntTrnsfrCsOtptShftPto2566759678::CnsentGivenPtoDriveMayBeEngaged,
            0 => EnggmntCnsntTrnsfrCsOtptShftPto2566759678::CnsntNtGvnPtoDrvShldNtBeEngaged,
            value => EnggmntCnsntTrnsfrCsOtptShftPto2566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableSwitchTransInputShaftPto12566759678 {
    NotAvailable,
    Error,
    EnblSwtchOffPtoOperationDesired,
    EnblSwtchOffPtoOprtonNotDesired,
    XValue(u64),
}

impl From<u64> for EnableSwitchTransInputShaftPto12566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableSwitchTransInputShaftPto12566759678::NotAvailable,
            2 => EnableSwitchTransInputShaftPto12566759678::Error,
            1 => EnableSwitchTransInputShaftPto12566759678::EnblSwtchOffPtoOperationDesired,
            0 => EnableSwitchTransInputShaftPto12566759678::EnblSwtchOffPtoOprtonNotDesired,
            value => EnableSwitchTransInputShaftPto12566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableSwitchTransInputShaftPto22566759678 {
    NotAvailable,
    Error,
    EnblSwtchOffPtoOperationDesired,
    EnblSwtchOffPtoOprtonNotDesired,
    XValue(u64),
}

impl From<u64> for EnableSwitchTransInputShaftPto22566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableSwitchTransInputShaftPto22566759678::NotAvailable,
            2 => EnableSwitchTransInputShaftPto22566759678::Error,
            1 => EnableSwitchTransInputShaftPto22566759678::EnblSwtchOffPtoOperationDesired,
            0 => EnableSwitchTransInputShaftPto22566759678::EnblSwtchOffPtoOprtonNotDesired,
            value => EnableSwitchTransInputShaftPto22566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableSwitchTransOutputShaftPto2566759678 {
    NotAvailable,
    Error,
    EnblSwtchOffPtoOperationDesired,
    EnblSwtchOffPtoOprtonNotDesired,
    XValue(u64),
}

impl From<u64> for EnableSwitchTransOutputShaftPto2566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableSwitchTransOutputShaftPto2566759678::NotAvailable,
            2 => EnableSwitchTransOutputShaftPto2566759678::Error,
            1 => EnableSwitchTransOutputShaftPto2566759678::EnblSwtchOffPtoOperationDesired,
            0 => EnableSwitchTransOutputShaftPto2566759678::EnblSwtchOffPtoOprtonNotDesired,
            value => EnableSwitchTransOutputShaftPto2566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnblSwtchTrnsfrCsOutputShaftPto2566759678 {
    NotAvailable,
    Error,
    EnblSwtchOffPtoOperationDesired,
    EnblSwtchOffPtoOprtonNotDesired,
    XValue(u64),
}

impl From<u64> for EnblSwtchTrnsfrCsOutputShaftPto2566759678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnblSwtchTrnsfrCsOutputShaftPto2566759678::NotAvailable,
            2 => EnblSwtchTrnsfrCsOutputShaftPto2566759678::Error,
            1 => EnblSwtchTrnsfrCsOutputShaftPto2566759678::EnblSwtchOffPtoOperationDesired,
            0 => EnblSwtchTrnsfrCsOutputShaftPto2566759678::EnblSwtchOffPtoOprtonNotDesired,
            value => EnblSwtchTrnsfrCsOutputShaftPto2566759678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngTurboCompressorCtrl2432541694 {
    RprsntsFllyOpnTypcllyTrbCmprssr,
    XValue(u64),
}

impl From<u64> for EngTurboCompressorCtrl2432541694 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => EngTurboCompressorCtrl2432541694::RprsntsFllyOpnTypcllyTrbCmprssr,
            value => EngTurboCompressorCtrl2432541694::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor102566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor102566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor102566759934::NotAvailable,
            2 => EnableStatusOfDoor102566759934::Error,
            1 => EnableStatusOfDoor102566759934::DoorEnabled,
            0 => EnableStatusOfDoor102566759934::DoorDisabled,
            value => EnableStatusOfDoor102566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor102566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor102566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor102566759934::NotAvailable,
            2 => OpenStatusOfDoor102566759934::Error,
            1 => OpenStatusOfDoor102566759934::DoorOpened,
            0 => OpenStatusOfDoor102566759934::DoorClosed,
            value => OpenStatusOfDoor102566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor102566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor102566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor102566759934::NotAvailable,
            2 => LockStatusOfDoor102566759934::Error,
            1 => LockStatusOfDoor102566759934::Locked,
            0 => LockStatusOfDoor102566759934::Unlocked,
            value => LockStatusOfDoor102566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor92566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor92566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor92566759934::NotAvailable,
            2 => EnableStatusOfDoor92566759934::Error,
            1 => EnableStatusOfDoor92566759934::DoorEnabled,
            0 => EnableStatusOfDoor92566759934::DoorDisabled,
            value => EnableStatusOfDoor92566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor92566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor92566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor92566759934::NotAvailable,
            2 => OpenStatusOfDoor92566759934::Error,
            1 => OpenStatusOfDoor92566759934::DoorOpened,
            0 => OpenStatusOfDoor92566759934::DoorClosed,
            value => OpenStatusOfDoor92566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor92566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor92566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor92566759934::NotAvailable,
            2 => LockStatusOfDoor92566759934::Error,
            1 => LockStatusOfDoor92566759934::Locked,
            0 => LockStatusOfDoor92566759934::Unlocked,
            value => LockStatusOfDoor92566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor82566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor82566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor82566759934::NotAvailable,
            2 => EnableStatusOfDoor82566759934::Error,
            1 => EnableStatusOfDoor82566759934::DoorEnabled,
            0 => EnableStatusOfDoor82566759934::DoorDisabled,
            value => EnableStatusOfDoor82566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor82566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor82566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor82566759934::NotAvailable,
            2 => OpenStatusOfDoor82566759934::Error,
            1 => OpenStatusOfDoor82566759934::DoorOpened,
            0 => OpenStatusOfDoor82566759934::DoorClosed,
            value => OpenStatusOfDoor82566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor82566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor82566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor82566759934::NotAvailable,
            2 => LockStatusOfDoor82566759934::Error,
            1 => LockStatusOfDoor82566759934::Locked,
            0 => LockStatusOfDoor82566759934::Unlocked,
            value => LockStatusOfDoor82566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor72566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor72566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor72566759934::NotAvailable,
            2 => EnableStatusOfDoor72566759934::Error,
            1 => EnableStatusOfDoor72566759934::DoorEnabled,
            0 => EnableStatusOfDoor72566759934::DoorDisabled,
            value => EnableStatusOfDoor72566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor72566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor72566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor72566759934::NotAvailable,
            2 => OpenStatusOfDoor72566759934::Error,
            1 => OpenStatusOfDoor72566759934::DoorOpened,
            0 => OpenStatusOfDoor72566759934::DoorClosed,
            value => OpenStatusOfDoor72566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor72566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor72566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor72566759934::NotAvailable,
            2 => LockStatusOfDoor72566759934::Error,
            1 => LockStatusOfDoor72566759934::Locked,
            0 => LockStatusOfDoor72566759934::Unlocked,
            value => LockStatusOfDoor72566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor62566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor62566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor62566759934::NotAvailable,
            2 => EnableStatusOfDoor62566759934::Error,
            1 => EnableStatusOfDoor62566759934::DoorEnabled,
            0 => EnableStatusOfDoor62566759934::DoorDisabled,
            value => EnableStatusOfDoor62566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor62566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor62566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor62566759934::NotAvailable,
            2 => OpenStatusOfDoor62566759934::Error,
            1 => OpenStatusOfDoor62566759934::DoorOpened,
            0 => OpenStatusOfDoor62566759934::DoorClosed,
            value => OpenStatusOfDoor62566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor62566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor62566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor62566759934::NotAvailable,
            2 => LockStatusOfDoor62566759934::Error,
            1 => LockStatusOfDoor62566759934::Locked,
            0 => LockStatusOfDoor62566759934::Unlocked,
            value => LockStatusOfDoor62566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor52566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor52566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor52566759934::NotAvailable,
            2 => EnableStatusOfDoor52566759934::Error,
            1 => EnableStatusOfDoor52566759934::DoorEnabled,
            0 => EnableStatusOfDoor52566759934::DoorDisabled,
            value => EnableStatusOfDoor52566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor52566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor52566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor52566759934::NotAvailable,
            2 => OpenStatusOfDoor52566759934::Error,
            1 => OpenStatusOfDoor52566759934::DoorOpened,
            0 => OpenStatusOfDoor52566759934::DoorClosed,
            value => OpenStatusOfDoor52566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor52566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor52566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor52566759934::NotAvailable,
            2 => LockStatusOfDoor52566759934::Error,
            1 => LockStatusOfDoor52566759934::Locked,
            0 => LockStatusOfDoor52566759934::Unlocked,
            value => LockStatusOfDoor52566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor42566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor42566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor42566759934::NotAvailable,
            2 => EnableStatusOfDoor42566759934::Error,
            1 => EnableStatusOfDoor42566759934::DoorEnabled,
            0 => EnableStatusOfDoor42566759934::DoorDisabled,
            value => EnableStatusOfDoor42566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor42566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor42566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor42566759934::NotAvailable,
            2 => OpenStatusOfDoor42566759934::Error,
            1 => OpenStatusOfDoor42566759934::DoorOpened,
            0 => OpenStatusOfDoor42566759934::DoorClosed,
            value => OpenStatusOfDoor42566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor42566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor42566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor42566759934::NotAvailable,
            2 => LockStatusOfDoor42566759934::Error,
            1 => LockStatusOfDoor42566759934::Locked,
            0 => LockStatusOfDoor42566759934::Unlocked,
            value => LockStatusOfDoor42566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor32566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor32566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor32566759934::NotAvailable,
            2 => EnableStatusOfDoor32566759934::Error,
            1 => EnableStatusOfDoor32566759934::DoorEnabled,
            0 => EnableStatusOfDoor32566759934::DoorDisabled,
            value => EnableStatusOfDoor32566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor32566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor32566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor32566759934::NotAvailable,
            2 => OpenStatusOfDoor32566759934::Error,
            1 => OpenStatusOfDoor32566759934::DoorOpened,
            0 => OpenStatusOfDoor32566759934::DoorClosed,
            value => OpenStatusOfDoor32566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor32566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor32566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor32566759934::NotAvailable,
            2 => LockStatusOfDoor32566759934::Error,
            1 => LockStatusOfDoor32566759934::Locked,
            0 => LockStatusOfDoor32566759934::Unlocked,
            value => LockStatusOfDoor32566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor22566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor22566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor22566759934::NotAvailable,
            2 => EnableStatusOfDoor22566759934::Error,
            1 => EnableStatusOfDoor22566759934::DoorEnabled,
            0 => EnableStatusOfDoor22566759934::DoorDisabled,
            value => EnableStatusOfDoor22566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor22566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor22566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor22566759934::NotAvailable,
            2 => OpenStatusOfDoor22566759934::Error,
            1 => OpenStatusOfDoor22566759934::DoorOpened,
            0 => OpenStatusOfDoor22566759934::DoorClosed,
            value => OpenStatusOfDoor22566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor22566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor22566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor22566759934::NotAvailable,
            2 => LockStatusOfDoor22566759934::Error,
            1 => LockStatusOfDoor22566759934::Locked,
            0 => LockStatusOfDoor22566759934::Unlocked,
            value => LockStatusOfDoor22566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EnableStatusOfDoor12566759934 {
    NotAvailable,
    Error,
    DoorEnabled,
    DoorDisabled,
    XValue(u64),
}

impl From<u64> for EnableStatusOfDoor12566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EnableStatusOfDoor12566759934::NotAvailable,
            2 => EnableStatusOfDoor12566759934::Error,
            1 => EnableStatusOfDoor12566759934::DoorEnabled,
            0 => EnableStatusOfDoor12566759934::DoorDisabled,
            value => EnableStatusOfDoor12566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OpenStatusOfDoor12566759934 {
    NotAvailable,
    Error,
    DoorOpened,
    DoorClosed,
    XValue(u64),
}

impl From<u64> for OpenStatusOfDoor12566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OpenStatusOfDoor12566759934::NotAvailable,
            2 => OpenStatusOfDoor12566759934::Error,
            1 => OpenStatusOfDoor12566759934::DoorOpened,
            0 => OpenStatusOfDoor12566759934::DoorClosed,
            value => OpenStatusOfDoor12566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LockStatusOfDoor12566759934 {
    NotAvailable,
    Error,
    Locked,
    Unlocked,
    XValue(u64),
}

impl From<u64> for LockStatusOfDoor12566759934 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LockStatusOfDoor12566759934::NotAvailable,
            2 => LockStatusOfDoor12566759934::Error,
            1 => LockStatusOfDoor12566759934::Locked,
            0 => LockStatusOfDoor12566759934::Unlocked,
            value => LockStatusOfDoor12566759934::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CatalystReagentType2566757374 {
    NotAvailable,
    ErrrDtctdWthUrRgntTypeDetection,
    NtAblTDtrmneCatalystReagentType,
    To1100ReservedForSaeAssignment,
    CatalystReagentIsProper,
    CatalystReagentIsDiesel,
    CatalystReagentIsWater,
    CatalystReagentIsUrea,
    XValue(u64),
}

impl From<u64> for CatalystReagentType2566757374 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => CatalystReagentType2566757374::NotAvailable,
            14 => CatalystReagentType2566757374::ErrrDtctdWthUrRgntTypeDetection,
            13 => CatalystReagentType2566757374::NtAblTDtrmneCatalystReagentType,
            4 => CatalystReagentType2566757374::To1100ReservedForSaeAssignment,
            3 => CatalystReagentType2566757374::CatalystReagentIsProper,
            2 => CatalystReagentType2566757374::CatalystReagentIsDiesel,
            1 => CatalystReagentType2566757374::CatalystReagentIsWater,
            0 => CatalystReagentType2566757374::CatalystReagentIsUrea,
            value => CatalystReagentType2566757374::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtratment2FuelEnableActuator2566758654 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtratment2FuelEnableActuator2566758654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtratment2FuelEnableActuator2566758654::NotAvailable,
            2 => Aftrtratment2FuelEnableActuator2566758654::ReservedForSaeAssignment,
            1 => Aftrtratment2FuelEnableActuator2566758654::Active,
            0 => Aftrtratment2FuelEnableActuator2566758654::NotActive,
            value => Aftrtratment2FuelEnableActuator2566758654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtratment2RegenerationStatus2566758654 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtratment2RegenerationStatus2566758654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtratment2RegenerationStatus2566758654::NotAvailable,
            2 => Aftrtratment2RegenerationStatus2566758654::ReservedForSaeAssignment,
            1 => Aftrtratment2RegenerationStatus2566758654::Active,
            0 => Aftrtratment2RegenerationStatus2566758654::NotActive,
            value => Aftrtratment2RegenerationStatus2566758654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftertreatment2Ignt2566758654 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftertreatment2Ignt2566758654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftertreatment2Ignt2566758654::NotAvailable,
            2 => Aftertreatment2Ignt2566758654::ReservedForSaeAssignment,
            1 => Aftertreatment2Ignt2566758654::Active,
            0 => Aftertreatment2Ignt2566758654::NotActive,
            value => Aftertreatment2Ignt2566758654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtratment1FuelEnableActuator2566758910 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtratment1FuelEnableActuator2566758910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtratment1FuelEnableActuator2566758910::NotAvailable,
            2 => Aftrtratment1FuelEnableActuator2566758910::ReservedForSaeAssignment,
            1 => Aftrtratment1FuelEnableActuator2566758910::Active,
            0 => Aftrtratment1FuelEnableActuator2566758910::NotActive,
            value => Aftrtratment1FuelEnableActuator2566758910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtratment1RegenerationStatus2566758910 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtratment1RegenerationStatus2566758910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtratment1RegenerationStatus2566758910::NotAvailable,
            2 => Aftrtratment1RegenerationStatus2566758910::ReservedForSaeAssignment,
            1 => Aftrtratment1RegenerationStatus2566758910::Active,
            0 => Aftrtratment1RegenerationStatus2566758910::NotActive,
            value => Aftrtratment1RegenerationStatus2566758910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftertreatment1Ignt2566758910 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftertreatment1Ignt2566758910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftertreatment1Ignt2566758910::NotAvailable,
            2 => Aftertreatment1Ignt2566758910::ReservedForSaeAssignment,
            1 => Aftertreatment1Ignt2566758910::Active,
            0 => Aftertreatment1Ignt2566758910::NotActive,
            value => Aftertreatment1Ignt2566758910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtreatment2AirEnableActuator2566758142 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtreatment2AirEnableActuator2566758142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtreatment2AirEnableActuator2566758142::NotAvailable,
            2 => Aftrtreatment2AirEnableActuator2566758142::ReservedForSaeAssignment,
            1 => Aftrtreatment2AirEnableActuator2566758142::Active,
            0 => Aftrtreatment2AirEnableActuator2566758142::NotActive,
            value => Aftrtreatment2AirEnableActuator2566758142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftertreatment2PurgeAirActuator2566758142 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftertreatment2PurgeAirActuator2566758142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftertreatment2PurgeAirActuator2566758142::NotAvailable,
            2 => Aftertreatment2PurgeAirActuator2566758142::ReservedForSaeAssignment,
            1 => Aftertreatment2PurgeAirActuator2566758142::Active,
            0 => Aftertreatment2PurgeAirActuator2566758142::NotActive,
            value => Aftertreatment2PurgeAirActuator2566758142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2AtmzationAirActuator2566758142 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2AtmzationAirActuator2566758142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2AtmzationAirActuator2566758142::NotAvailable,
            2 => Aftrtrtmnt2AtmzationAirActuator2566758142::ReservedForSaeAssignment,
            1 => Aftrtrtmnt2AtmzationAirActuator2566758142::Active,
            0 => Aftrtrtmnt2AtmzationAirActuator2566758142::NotActive,
            value => Aftrtrtmnt2AtmzationAirActuator2566758142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftertreatment2AirSystemRelay2566758142 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftertreatment2AirSystemRelay2566758142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftertreatment2AirSystemRelay2566758142::NotAvailable,
            2 => Aftertreatment2AirSystemRelay2566758142::ReservedForSaeAssignment,
            1 => Aftertreatment2AirSystemRelay2566758142::Active,
            0 => Aftertreatment2AirSystemRelay2566758142::NotActive,
            value => Aftertreatment2AirSystemRelay2566758142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtreatment1AirEnableActuator2566758398 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtreatment1AirEnableActuator2566758398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtreatment1AirEnableActuator2566758398::NotAvailable,
            2 => Aftrtreatment1AirEnableActuator2566758398::ReservedForSaeAssignment,
            1 => Aftrtreatment1AirEnableActuator2566758398::Active,
            0 => Aftrtreatment1AirEnableActuator2566758398::NotActive,
            value => Aftrtreatment1AirEnableActuator2566758398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftertreatment1PurgeAirActuator2566758398 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftertreatment1PurgeAirActuator2566758398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftertreatment1PurgeAirActuator2566758398::NotAvailable,
            2 => Aftertreatment1PurgeAirActuator2566758398::ReservedForSaeAssignment,
            1 => Aftertreatment1PurgeAirActuator2566758398::Active,
            0 => Aftertreatment1PurgeAirActuator2566758398::NotActive,
            value => Aftertreatment1PurgeAirActuator2566758398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1AtmzationAirActuator2566758398 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1AtmzationAirActuator2566758398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1AtmzationAirActuator2566758398::NotAvailable,
            2 => Aftrtrtmnt1AtmzationAirActuator2566758398::ReservedForSaeAssignment,
            1 => Aftrtrtmnt1AtmzationAirActuator2566758398::Active,
            0 => Aftrtrtmnt1AtmzationAirActuator2566758398::NotActive,
            value => Aftrtrtmnt1AtmzationAirActuator2566758398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftertreatment1AirSystemRelay2566758398 {
    NotAvailable,
    ReservedForSaeAssignment,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for Aftertreatment1AirSystemRelay2566758398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftertreatment1AirSystemRelay2566758398::NotAvailable,
            2 => Aftertreatment1AirSystemRelay2566758398::ReservedForSaeAssignment,
            1 => Aftertreatment1AirSystemRelay2566758398::Active,
            0 => Aftertreatment1AirSystemRelay2566758398::NotActive,
            value => Aftertreatment1AirSystemRelay2566758398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl9CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl9CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl9CombustionStatus2364544766::NotAvailable,
            2 => EngCyl9CombustionStatus2364544766::Error,
            1 => EngCyl9CombustionStatus2364544766::CombustionExists,
            0 => EngCyl9CombustionStatus2364544766::NoCombustion,
            value => EngCyl9CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl8CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl8CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl8CombustionStatus2364544766::NotAvailable,
            2 => EngCyl8CombustionStatus2364544766::Error,
            1 => EngCyl8CombustionStatus2364544766::CombustionExists,
            0 => EngCyl8CombustionStatus2364544766::NoCombustion,
            value => EngCyl8CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl7CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl7CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl7CombustionStatus2364544766::NotAvailable,
            2 => EngCyl7CombustionStatus2364544766::Error,
            1 => EngCyl7CombustionStatus2364544766::CombustionExists,
            0 => EngCyl7CombustionStatus2364544766::NoCombustion,
            value => EngCyl7CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl6CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl6CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl6CombustionStatus2364544766::NotAvailable,
            2 => EngCyl6CombustionStatus2364544766::Error,
            1 => EngCyl6CombustionStatus2364544766::CombustionExists,
            0 => EngCyl6CombustionStatus2364544766::NoCombustion,
            value => EngCyl6CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl5CombustionStatus2364544766 {
    CombustionExists,
    NoCombustion,
    NotAvailable,
    Error,
    XValue(u64),
}

impl From<u64> for EngCyl5CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngCyl5CombustionStatus2364544766::CombustionExists,
            0 => EngCyl5CombustionStatus2364544766::NoCombustion,
            3 => EngCyl5CombustionStatus2364544766::NotAvailable,
            2 => EngCyl5CombustionStatus2364544766::Error,
            value => EngCyl5CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl4CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl4CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl4CombustionStatus2364544766::NotAvailable,
            2 => EngCyl4CombustionStatus2364544766::Error,
            1 => EngCyl4CombustionStatus2364544766::CombustionExists,
            0 => EngCyl4CombustionStatus2364544766::NoCombustion,
            value => EngCyl4CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl3CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl3CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl3CombustionStatus2364544766::NotAvailable,
            2 => EngCyl3CombustionStatus2364544766::Error,
            1 => EngCyl3CombustionStatus2364544766::CombustionExists,
            0 => EngCyl3CombustionStatus2364544766::NoCombustion,
            value => EngCyl3CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl2CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl2CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl2CombustionStatus2364544766::NotAvailable,
            2 => EngCyl2CombustionStatus2364544766::Error,
            1 => EngCyl2CombustionStatus2364544766::CombustionExists,
            0 => EngCyl2CombustionStatus2364544766::NoCombustion,
            value => EngCyl2CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl24CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl24CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl24CombustionStatus2364544766::NotAvailable,
            2 => EngCyl24CombustionStatus2364544766::Error,
            1 => EngCyl24CombustionStatus2364544766::CombustionExists,
            0 => EngCyl24CombustionStatus2364544766::NoCombustion,
            value => EngCyl24CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl23CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl23CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl23CombustionStatus2364544766::NotAvailable,
            2 => EngCyl23CombustionStatus2364544766::Error,
            1 => EngCyl23CombustionStatus2364544766::CombustionExists,
            0 => EngCyl23CombustionStatus2364544766::NoCombustion,
            value => EngCyl23CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl22CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl22CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl22CombustionStatus2364544766::NotAvailable,
            2 => EngCyl22CombustionStatus2364544766::Error,
            1 => EngCyl22CombustionStatus2364544766::CombustionExists,
            0 => EngCyl22CombustionStatus2364544766::NoCombustion,
            value => EngCyl22CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl21CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl21CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl21CombustionStatus2364544766::NotAvailable,
            2 => EngCyl21CombustionStatus2364544766::Error,
            1 => EngCyl21CombustionStatus2364544766::CombustionExists,
            0 => EngCyl21CombustionStatus2364544766::NoCombustion,
            value => EngCyl21CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl20CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl20CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl20CombustionStatus2364544766::NotAvailable,
            2 => EngCyl20CombustionStatus2364544766::Error,
            1 => EngCyl20CombustionStatus2364544766::CombustionExists,
            0 => EngCyl20CombustionStatus2364544766::NoCombustion,
            value => EngCyl20CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl1CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl1CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl1CombustionStatus2364544766::NotAvailable,
            2 => EngCyl1CombustionStatus2364544766::Error,
            1 => EngCyl1CombustionStatus2364544766::CombustionExists,
            0 => EngCyl1CombustionStatus2364544766::NoCombustion,
            value => EngCyl1CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl19CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl19CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl19CombustionStatus2364544766::NotAvailable,
            2 => EngCyl19CombustionStatus2364544766::Error,
            1 => EngCyl19CombustionStatus2364544766::CombustionExists,
            0 => EngCyl19CombustionStatus2364544766::NoCombustion,
            value => EngCyl19CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl18CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl18CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl18CombustionStatus2364544766::NotAvailable,
            2 => EngCyl18CombustionStatus2364544766::Error,
            1 => EngCyl18CombustionStatus2364544766::CombustionExists,
            0 => EngCyl18CombustionStatus2364544766::NoCombustion,
            value => EngCyl18CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl17CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl17CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl17CombustionStatus2364544766::NotAvailable,
            2 => EngCyl17CombustionStatus2364544766::Error,
            1 => EngCyl17CombustionStatus2364544766::CombustionExists,
            0 => EngCyl17CombustionStatus2364544766::NoCombustion,
            value => EngCyl17CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl16CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl16CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl16CombustionStatus2364544766::NotAvailable,
            2 => EngCyl16CombustionStatus2364544766::Error,
            1 => EngCyl16CombustionStatus2364544766::CombustionExists,
            0 => EngCyl16CombustionStatus2364544766::NoCombustion,
            value => EngCyl16CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl15CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl15CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl15CombustionStatus2364544766::NotAvailable,
            2 => EngCyl15CombustionStatus2364544766::Error,
            1 => EngCyl15CombustionStatus2364544766::CombustionExists,
            0 => EngCyl15CombustionStatus2364544766::NoCombustion,
            value => EngCyl15CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl14CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl14CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl14CombustionStatus2364544766::NotAvailable,
            2 => EngCyl14CombustionStatus2364544766::Error,
            1 => EngCyl14CombustionStatus2364544766::CombustionExists,
            0 => EngCyl14CombustionStatus2364544766::NoCombustion,
            value => EngCyl14CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl13CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl13CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl13CombustionStatus2364544766::NotAvailable,
            2 => EngCyl13CombustionStatus2364544766::Error,
            1 => EngCyl13CombustionStatus2364544766::CombustionExists,
            0 => EngCyl13CombustionStatus2364544766::NoCombustion,
            value => EngCyl13CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl12CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl12CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl12CombustionStatus2364544766::NotAvailable,
            2 => EngCyl12CombustionStatus2364544766::Error,
            1 => EngCyl12CombustionStatus2364544766::CombustionExists,
            0 => EngCyl12CombustionStatus2364544766::NoCombustion,
            value => EngCyl12CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl11CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl11CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl11CombustionStatus2364544766::NotAvailable,
            2 => EngCyl11CombustionStatus2364544766::Error,
            1 => EngCyl11CombustionStatus2364544766::CombustionExists,
            0 => EngCyl11CombustionStatus2364544766::NoCombustion,
            value => EngCyl11CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCyl10CombustionStatus2364544766 {
    NotAvailable,
    Error,
    CombustionExists,
    NoCombustion,
    XValue(u64),
}

impl From<u64> for EngCyl10CombustionStatus2364544766 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCyl10CombustionStatus2364544766::NotAvailable,
            2 => EngCyl10CombustionStatus2364544766::Error,
            1 => EngCyl10CombustionStatus2364544766::CombustionExists,
            0 => EngCyl10CombustionStatus2364544766::NoCombustion,
            value => EngCyl10CombustionStatus2364544766::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RqGenOverallPowerFactorLagging2364544510 {
    NotAvailable,
    Error,
    Lagging,
    Leading,
    XValue(u64),
}

impl From<u64> for RqGenOverallPowerFactorLagging2364544510 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RqGenOverallPowerFactorLagging2364544510::NotAvailable,
            2 => RqGenOverallPowerFactorLagging2364544510::Error,
            1 => RqGenOverallPowerFactorLagging2364544510::Lagging,
            0 => RqGenOverallPowerFactorLagging2364544510::Leading,
            value => RqGenOverallPowerFactorLagging2364544510::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BladeRotationAngleFigureOfMerit2364544254 {
    AngleNotAvailable,
    AngleFailed,
    AngleDegraded,
    AngleFullyFunctional,
    XValue(u64),
}

impl From<u64> for BladeRotationAngleFigureOfMerit2364544254 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BladeRotationAngleFigureOfMerit2364544254::AngleNotAvailable,
            2 => BladeRotationAngleFigureOfMerit2364544254::AngleFailed,
            1 => BladeRotationAngleFigureOfMerit2364544254::AngleDegraded,
            0 => BladeRotationAngleFigureOfMerit2364544254::AngleFullyFunctional,
            value => BladeRotationAngleFigureOfMerit2364544254::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RelBladeHeightFigureOfMerit2364544254 {
    HeightNotAvailable,
    HeightFailed,
    HeightDegraded,
    HeightFullyFunctional,
    XValue(u64),
}

impl From<u64> for RelBladeHeightFigureOfMerit2364544254 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RelBladeHeightFigureOfMerit2364544254::HeightNotAvailable,
            2 => RelBladeHeightFigureOfMerit2364544254::HeightFailed,
            1 => RelBladeHeightFigureOfMerit2364544254::HeightDegraded,
            0 => RelBladeHeightFigureOfMerit2364544254::HeightFullyFunctional,
            value => RelBladeHeightFigureOfMerit2364544254::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleType2349006590 {
    DollyAxle,
    TowingOrTowedVehicle,
    XValue(u64),
}

impl From<u64> for VehicleType2349006590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleType2349006590::DollyAxle,
            0 => VehicleType2349006590::TowingOrTowedVehicle,
            value => VehicleType2349006590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BrakeLightSwitch2349006590 {
    SwitchOn,
    SwitchOff,
    XValue(u64),
}

impl From<u64> for BrakeLightSwitch2349006590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => BrakeLightSwitch2349006590::SwitchOn,
            0 => BrakeLightSwitch2349006590::SwitchOff,
            value => BrakeLightSwitch2349006590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AsrEngineControlActive2349006590 {
    NotAvailable,
    Reserved,
    AsrEngineControlActive,
    AsrEngnCntrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for AsrEngineControlActive2349006590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AsrEngineControlActive2349006590::NotAvailable,
            2 => AsrEngineControlActive2349006590::Reserved,
            1 => AsrEngineControlActive2349006590::AsrEngineControlActive,
            0 => AsrEngineControlActive2349006590::AsrEngnCntrlPassiveButInstalled,
            value => AsrEngineControlActive2349006590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AsrBreakControlActive2349006590 {
    Active,
    PassiveButInstalled,
    XValue(u64),
}

impl From<u64> for AsrBreakControlActive2349006590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AsrBreakControlActive2349006590::Active,
            0 => AsrBreakControlActive2349006590::PassiveButInstalled,
            value => AsrBreakControlActive2349006590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleRetarderCtrlActive2349006590 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for VehicleRetarderCtrlActive2349006590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleRetarderCtrlActive2349006590::Active,
            0 => VehicleRetarderCtrlActive2349006590::Passive,
            value => VehicleRetarderCtrlActive2349006590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleAbsActive2349006590 {
    Active,
    PassivButInstalled,
    XValue(u64),
}

impl From<u64> for VehicleAbsActive2349006590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleAbsActive2349006590::Active,
            0 => VehicleAbsActive2349006590::PassivButInstalled,
            value => VehicleAbsActive2349006590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PneumaticControlLine2566834686 {
    TowingVehWithPnCtrlLine,
    TowingVehWithoutPnCtrlLine,
    XValue(u64),
}

impl From<u64> for PneumaticControlLine2566834686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => PneumaticControlLine2566834686::TowingVehWithPnCtrlLine,
            0 => PneumaticControlLine2566834686::TowingVehWithoutPnCtrlLine,
            value => PneumaticControlLine2566834686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AbsOffroadRequest2566834686 {
    AbsOffRoadSwitchOn,
    AbsOffRoadSwitchOff,
    XValue(u64),
}

impl From<u64> for AbsOffroadRequest2566834686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AbsOffroadRequest2566834686::AbsOffRoadSwitchOn,
            0 => AbsOffroadRequest2566834686::AbsOffRoadSwitchOff,
            value => AbsOffroadRequest2566834686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TwoElCircuitsBrakeDemand2566834686 {
    TwoElCircuitBrakeAvailable,
    OneElCircuitBrakeAvailable,
    XValue(u64),
}

impl From<u64> for TwoElCircuitsBrakeDemand2566834686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TwoElCircuitsBrakeDemand2566834686::TwoElCircuitBrakeAvailable,
            0 => TwoElCircuitsBrakeDemand2566834686::OneElCircuitBrakeAvailable,
            value => TwoElCircuitsBrakeDemand2566834686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleRetarderCtrlActive2566834686 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for VehicleRetarderCtrlActive2566834686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleRetarderCtrlActive2566834686::Active,
            0 => VehicleRetarderCtrlActive2566834686::Passive,
            value => VehicleRetarderCtrlActive2566834686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupplyLineBrakingRequest2550398718 {
    SupplyLineBrakingRequest,
    NoSupplyLineBrakingRequest,
    XValue(u64),
}

impl From<u64> for SupplyLineBrakingRequest2550398718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupplyLineBrakingRequest2550398718::SupplyLineBrakingRequest,
            0 => SupplyLineBrakingRequest2550398718::NoSupplyLineBrakingRequest,
            value => SupplyLineBrakingRequest2550398718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VdcActive2550398718 {
    Active,
    PassiveButInstalled,
    XValue(u64),
}

impl From<u64> for VdcActive2550398718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VdcActive2550398718::Active,
            0 => VdcActive2550398718::PassiveButInstalled,
            value => VdcActive2550398718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AutomTowedVehBreakActive2550398718 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for AutomTowedVehBreakActive2550398718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AutomTowedVehBreakActive2550398718::Active,
            0 => AutomTowedVehBreakActive2550398718::Passive,
            value => AutomTowedVehBreakActive2550398718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleServiceBrakeActive2550398718 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for VehicleServiceBrakeActive2550398718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleServiceBrakeActive2550398718::Active,
            0 => VehicleServiceBrakeActive2550398718::Passive,
            value => VehicleServiceBrakeActive2550398718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleRetarderCtrlActive2550398718 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for VehicleRetarderCtrlActive2550398718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleRetarderCtrlActive2550398718::Active,
            0 => VehicleRetarderCtrlActive2550398718::Passive,
            value => VehicleRetarderCtrlActive2550398718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleAbsActive2550398718 {
    Active,
    PassivButInstalled,
    XValue(u64),
}

impl From<u64> for VehicleAbsActive2550398718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleAbsActive2550398718::Active,
            0 => VehicleAbsActive2550398718::PassivButInstalled,
            value => VehicleAbsActive2550398718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupplyLineBrakingRequest2566833406 {
    SupplyLineBrakingRequest,
    NoSupplyLineBrakingRequest,
    XValue(u64),
}

impl From<u64> for SupplyLineBrakingRequest2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupplyLineBrakingRequest2566833406::SupplyLineBrakingRequest,
            0 => SupplyLineBrakingRequest2566833406::NoSupplyLineBrakingRequest,
            value => SupplyLineBrakingRequest2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LoadingRampApproachAssist2566833406 {
    AssistanceActive,
    AssistanceNotActive,
    XValue(u64),
}

impl From<u64> for LoadingRampApproachAssist2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => LoadingRampApproachAssist2566833406::AssistanceActive,
            0 => LoadingRampApproachAssist2566833406::AssistanceNotActive,
            value => LoadingRampApproachAssist2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpringBrakeEngaged2566833406 {
    VehicleSpringBrakeIsEngaged,
    VehicleSpringBrakeIsReleased,
    XValue(u64),
}

impl From<u64> for SpringBrakeEngaged2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpringBrakeEngaged2566833406::VehicleSpringBrakeIsEngaged,
            0 => SpringBrakeEngaged2566833406::VehicleSpringBrakeIsReleased,
            value => SpringBrakeEngaged2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ElectrLoadPropFunc2566833406 {
    VehicleWithElLoadProportion,
    VehicleWithoutElLoadProport,
    XValue(u64),
}

impl From<u64> for ElectrLoadPropFunc2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ElectrLoadPropFunc2566833406::VehicleWithElLoadProportion,
            0 => ElectrLoadPropFunc2566833406::VehicleWithoutElLoadProport,
            value => ElectrLoadPropFunc2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpringBrakeInstalled2566833406 {
    VehicleWithSpringBrakes,
    VehicleWithoutSpringBrakes,
    XValue(u64),
}

impl From<u64> for SpringBrakeInstalled2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpringBrakeInstalled2566833406::VehicleWithSpringBrakes,
            0 => SpringBrakeInstalled2566833406::VehicleWithoutSpringBrakes,
            value => SpringBrakeInstalled2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleType2566833406 {
    DollyAxle,
    TowingOrTowedVehicle,
    XValue(u64),
}

impl From<u64> for VehicleType2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleType2566833406::DollyAxle,
            0 => VehicleType2566833406::TowingOrTowedVehicle,
            value => VehicleType2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ElecSupplyOfNonBrakingSys2566833406 {
    SupplySwitchedOn,
    SupplySwitchedOff,
    XValue(u64),
}

impl From<u64> for ElecSupplyOfNonBrakingSys2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ElecSupplyOfNonBrakingSys2566833406::SupplySwitchedOn,
            0 => ElecSupplyOfNonBrakingSys2566833406::SupplySwitchedOff,
            value => ElecSupplyOfNonBrakingSys2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningSignalReq2566833406 {
    TowedVehicleFailureIndicated,
    NoTowedVehicleFailureIndicat,
    XValue(u64),
}

impl From<u64> for AmberWarningSignalReq2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AmberWarningSignalReq2566833406::TowedVehicleFailureIndicated,
            0 => AmberWarningSignalReq2566833406::NoTowedVehicleFailureIndicat,
            value => AmberWarningSignalReq2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedWarningSignalRequest2566833406 {
    TowedVehicleFailureIndicated,
    NoTowedVehicleFailureIndicat,
    XValue(u64),
}

impl From<u64> for RedWarningSignalRequest2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => RedWarningSignalRequest2566833406::TowedVehicleFailureIndicated,
            0 => RedWarningSignalRequest2566833406::NoTowedVehicleFailureIndicat,
            value => RedWarningSignalRequest2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleElectrSupplySuff2566833406 {
    VehicleElSupplySufficient,
    VehicleElSupplyInsufficient,
    XValue(u64),
}

impl From<u64> for VehicleElectrSupplySuff2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleElectrSupplySuff2566833406::VehicleElSupplySufficient,
            0 => VehicleElectrSupplySuff2566833406::VehicleElSupplyInsufficient,
            value => VehicleElectrSupplySuff2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AutomTowedVehBreakActive2566833406 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for AutomTowedVehBreakActive2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AutomTowedVehBreakActive2566833406::Active,
            0 => AutomTowedVehBreakActive2566833406::Passive,
            value => AutomTowedVehBreakActive2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleServiceBrakeActive2566833406 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for VehicleServiceBrakeActive2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleServiceBrakeActive2566833406::Active,
            0 => VehicleServiceBrakeActive2566833406::Passive,
            value => VehicleServiceBrakeActive2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleRetarderCtrlActive2566833406 {
    Active,
    Passive,
    XValue(u64),
}

impl From<u64> for VehicleRetarderCtrlActive2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleRetarderCtrlActive2566833406::Active,
            0 => VehicleRetarderCtrlActive2566833406::Passive,
            value => VehicleRetarderCtrlActive2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleAbsActive2566833406 {
    Active,
    PassivButInstalled,
    XValue(u64),
}

impl From<u64> for VehicleAbsActive2566833406 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleAbsActive2566833406::Active,
            0 => VehicleAbsActive2566833406::PassivButInstalled,
            value => VehicleAbsActive2566833406::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentTemp22365507326 {
    AxlePosition15,
    AxlePosition14,
    AxlePosition13,
    AxlePosition12,
    AxlePosition11,
    AxlePosition10,
    AxlePosition9,
    AxlePosition8,
    AxlePosition7,
    AxlePosition6,
    AxlePosition5,
    AxlePosition4,
    AxlePosition3,
    AxlePosition2,
    AxlePosition1,
    AxlePositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentTemp22365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentTemp22365507326::AxlePosition15,
            14 => TyreWheelIdentTemp22365507326::AxlePosition14,
            13 => TyreWheelIdentTemp22365507326::AxlePosition13,
            12 => TyreWheelIdentTemp22365507326::AxlePosition12,
            11 => TyreWheelIdentTemp22365507326::AxlePosition11,
            10 => TyreWheelIdentTemp22365507326::AxlePosition10,
            9 => TyreWheelIdentTemp22365507326::AxlePosition9,
            8 => TyreWheelIdentTemp22365507326::AxlePosition8,
            7 => TyreWheelIdentTemp22365507326::AxlePosition7,
            6 => TyreWheelIdentTemp22365507326::AxlePosition6,
            5 => TyreWheelIdentTemp22365507326::AxlePosition5,
            4 => TyreWheelIdentTemp22365507326::AxlePosition4,
            3 => TyreWheelIdentTemp22365507326::AxlePosition3,
            2 => TyreWheelIdentTemp22365507326::AxlePosition2,
            1 => TyreWheelIdentTemp22365507326::AxlePosition1,
            0 => TyreWheelIdentTemp22365507326::AxlePositionNotIdentified,
            value => TyreWheelIdentTemp22365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentTemp12365507326 {
    WheelPosition15,
    WheelPosition14,
    WheelPosition13,
    WheelPosition12,
    WheelPosition11,
    WheelPosition10,
    WheelPosition9,
    WheelPosition8,
    WheelPosition7,
    WheelPosition6,
    WheelPosition5,
    WheelPosition4,
    WheelPosition3,
    WheelPosition2,
    WheelPosition1,
    WheelPositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentTemp12365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentTemp12365507326::WheelPosition15,
            14 => TyreWheelIdentTemp12365507326::WheelPosition14,
            13 => TyreWheelIdentTemp12365507326::WheelPosition13,
            12 => TyreWheelIdentTemp12365507326::WheelPosition12,
            11 => TyreWheelIdentTemp12365507326::WheelPosition11,
            10 => TyreWheelIdentTemp12365507326::WheelPosition10,
            9 => TyreWheelIdentTemp12365507326::WheelPosition9,
            8 => TyreWheelIdentTemp12365507326::WheelPosition8,
            7 => TyreWheelIdentTemp12365507326::WheelPosition7,
            6 => TyreWheelIdentTemp12365507326::WheelPosition6,
            5 => TyreWheelIdentTemp12365507326::WheelPosition5,
            4 => TyreWheelIdentTemp12365507326::WheelPosition4,
            3 => TyreWheelIdentTemp12365507326::WheelPosition3,
            2 => TyreWheelIdentTemp12365507326::WheelPosition2,
            1 => TyreWheelIdentTemp12365507326::WheelPosition1,
            0 => TyreWheelIdentTemp12365507326::WheelPositionNotIdentified,
            value => TyreWheelIdentTemp12365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentPressure22365507326 {
    AxlePosition15,
    AxlePosition14,
    AxlePosition13,
    AxlePosition12,
    AxlePosition11,
    AxlePosition10,
    AxlePosition9,
    AxlePosition8,
    AxlePosition7,
    AxlePosition6,
    AxlePosition5,
    AxlePosition4,
    AxlePosition3,
    AxlePosition2,
    AxlePosition1,
    AxlePositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentPressure22365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentPressure22365507326::AxlePosition15,
            14 => TyreWheelIdentPressure22365507326::AxlePosition14,
            13 => TyreWheelIdentPressure22365507326::AxlePosition13,
            12 => TyreWheelIdentPressure22365507326::AxlePosition12,
            11 => TyreWheelIdentPressure22365507326::AxlePosition11,
            10 => TyreWheelIdentPressure22365507326::AxlePosition10,
            9 => TyreWheelIdentPressure22365507326::AxlePosition9,
            8 => TyreWheelIdentPressure22365507326::AxlePosition8,
            7 => TyreWheelIdentPressure22365507326::AxlePosition7,
            6 => TyreWheelIdentPressure22365507326::AxlePosition6,
            5 => TyreWheelIdentPressure22365507326::AxlePosition5,
            4 => TyreWheelIdentPressure22365507326::AxlePosition4,
            3 => TyreWheelIdentPressure22365507326::AxlePosition3,
            2 => TyreWheelIdentPressure22365507326::AxlePosition2,
            1 => TyreWheelIdentPressure22365507326::AxlePosition1,
            0 => TyreWheelIdentPressure22365507326::AxlePositionNotIdentified,
            value => TyreWheelIdentPressure22365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentPressure12365507326 {
    WheelPosition15,
    WheelPosition14,
    WheelPosition13,
    WheelPosition12,
    WheelPosition11,
    WheelPosition10,
    WheelPosition9,
    WheelPosition8,
    WheelPosition7,
    WheelPosition6,
    WheelPosition5,
    WheelPosition4,
    WheelPosition3,
    WheelPosition2,
    WheelPosition1,
    WheelPositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentPressure12365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentPressure12365507326::WheelPosition15,
            14 => TyreWheelIdentPressure12365507326::WheelPosition14,
            13 => TyreWheelIdentPressure12365507326::WheelPosition13,
            12 => TyreWheelIdentPressure12365507326::WheelPosition12,
            11 => TyreWheelIdentPressure12365507326::WheelPosition11,
            10 => TyreWheelIdentPressure12365507326::WheelPosition10,
            9 => TyreWheelIdentPressure12365507326::WheelPosition9,
            8 => TyreWheelIdentPressure12365507326::WheelPosition8,
            7 => TyreWheelIdentPressure12365507326::WheelPosition7,
            6 => TyreWheelIdentPressure12365507326::WheelPosition6,
            5 => TyreWheelIdentPressure12365507326::WheelPosition5,
            4 => TyreWheelIdentPressure12365507326::WheelPosition4,
            3 => TyreWheelIdentPressure12365507326::WheelPosition3,
            2 => TyreWheelIdentPressure12365507326::WheelPosition2,
            1 => TyreWheelIdentPressure12365507326::WheelPosition1,
            0 => TyreWheelIdentPressure12365507326::WheelPositionNotIdentified,
            value => TyreWheelIdentPressure12365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentLining22365507326 {
    AxlePosition15,
    AxlePosition14,
    AxlePosition13,
    AxlePosition12,
    AxlePosition11,
    AxlePosition10,
    AxlePosition9,
    AxlePosition8,
    AxlePosition7,
    AxlePosition6,
    AxlePosition5,
    AxlePosition4,
    AxlePosition3,
    AxlePosition2,
    AxlePosition1,
    AxlePositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentLining22365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentLining22365507326::AxlePosition15,
            14 => TyreWheelIdentLining22365507326::AxlePosition14,
            13 => TyreWheelIdentLining22365507326::AxlePosition13,
            12 => TyreWheelIdentLining22365507326::AxlePosition12,
            11 => TyreWheelIdentLining22365507326::AxlePosition11,
            10 => TyreWheelIdentLining22365507326::AxlePosition10,
            9 => TyreWheelIdentLining22365507326::AxlePosition9,
            8 => TyreWheelIdentLining22365507326::AxlePosition8,
            7 => TyreWheelIdentLining22365507326::AxlePosition7,
            6 => TyreWheelIdentLining22365507326::AxlePosition6,
            5 => TyreWheelIdentLining22365507326::AxlePosition5,
            4 => TyreWheelIdentLining22365507326::AxlePosition4,
            3 => TyreWheelIdentLining22365507326::AxlePosition3,
            2 => TyreWheelIdentLining22365507326::AxlePosition2,
            1 => TyreWheelIdentLining22365507326::AxlePosition1,
            0 => TyreWheelIdentLining22365507326::AxlePositionNotIdentified,
            value => TyreWheelIdentLining22365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentLining12365507326 {
    WheelPosition15,
    WheelPosition14,
    WheelPosition13,
    WheelPosition12,
    WheelPosition11,
    WheelPosition10,
    WheelPosition9,
    WheelPosition8,
    WheelPosition7,
    WheelPosition6,
    WheelPosition5,
    WheelPosition4,
    WheelPosition3,
    WheelPosition2,
    WheelPosition1,
    WheelPositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentLining12365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentLining12365507326::WheelPosition15,
            14 => TyreWheelIdentLining12365507326::WheelPosition14,
            13 => TyreWheelIdentLining12365507326::WheelPosition13,
            12 => TyreWheelIdentLining12365507326::WheelPosition12,
            11 => TyreWheelIdentLining12365507326::WheelPosition11,
            10 => TyreWheelIdentLining12365507326::WheelPosition10,
            9 => TyreWheelIdentLining12365507326::WheelPosition9,
            8 => TyreWheelIdentLining12365507326::WheelPosition8,
            7 => TyreWheelIdentLining12365507326::WheelPosition7,
            6 => TyreWheelIdentLining12365507326::WheelPosition6,
            5 => TyreWheelIdentLining12365507326::WheelPosition5,
            4 => TyreWheelIdentLining12365507326::WheelPosition4,
            3 => TyreWheelIdentLining12365507326::WheelPosition3,
            2 => TyreWheelIdentLining12365507326::WheelPosition2,
            1 => TyreWheelIdentLining12365507326::WheelPosition1,
            0 => TyreWheelIdentLining12365507326::WheelPositionNotIdentified,
            value => TyreWheelIdentLining12365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehiclePneumSupplySuff2365507326 {
    PneumaticSupplySufficient,
    PneumaticSupplyInsufficient,
    XValue(u64),
}

impl From<u64> for VehiclePneumSupplySuff2365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehiclePneumSupplySuff2365507326::PneumaticSupplySufficient,
            0 => VehiclePneumSupplySuff2365507326::PneumaticSupplyInsufficient,
            value => VehiclePneumSupplySuff2365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BrakeTemperatureStatus2365507326 {
    BrakeTemperatureNormal,
    BrakeTemperatureOutOfRange,
    XValue(u64),
}

impl From<u64> for BrakeTemperatureStatus2365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => BrakeTemperatureStatus2365507326::BrakeTemperatureNormal,
            0 => BrakeTemperatureStatus2365507326::BrakeTemperatureOutOfRange,
            value => BrakeTemperatureStatus2365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BrakeLiningSufficient2365507326 {
    BrakeLiningsSufficient,
    BrakeLiningsInsufficient,
    XValue(u64),
}

impl From<u64> for BrakeLiningSufficient2365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => BrakeLiningSufficient2365507326::BrakeLiningsSufficient,
            0 => BrakeLiningSufficient2365507326::BrakeLiningsInsufficient,
            value => BrakeLiningSufficient2365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyrePressureSufficient2365507326 {
    TyrePressureSufficient,
    TyrePressureInsufficient,
    XValue(u64),
}

impl From<u64> for TyrePressureSufficient2365507326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TyrePressureSufficient2365507326::TyrePressureSufficient,
            0 => TyrePressureSufficient2365507326::TyrePressureInsufficient,
            value => TyrePressureSufficient2365507326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OddRequest2565013246 {
    TakeNoAction,
    OddOn,
    OddOff,
    XValue(u64),
}

impl From<u64> for OddRequest2565013246 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OddRequest2565013246::TakeNoAction,
            1 => OddRequest2565013246::OddOn,
            0 => OddRequest2565013246::OddOff,
            value => OddRequest2565013246::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntiTheftDeviceReq2565013246 {
    TakeNoAction,
    AntiTheftDeviceOn,
    AntiTheftDeviceOff,
    XValue(u64),
}

impl From<u64> for AntiTheftDeviceReq2565013246 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntiTheftDeviceReq2565013246::TakeNoAction,
            1 => AntiTheftDeviceReq2565013246::AntiTheftDeviceOn,
            0 => AntiTheftDeviceReq2565013246::AntiTheftDeviceOff,
            value => AntiTheftDeviceReq2565013246::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleType2565013246 {
    DollyAxle,
    TowingOrTowedVehicle,
    XValue(u64),
}

impl From<u64> for VehicleType2565013246 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleType2565013246::DollyAxle,
            0 => VehicleType2565013246::TowingOrTowedVehicle,
            value => VehicleType2565013246::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineTorqueMode2365480958 {
    NotAvailable,
    RemoteAccelerator,
    BrakingSystem,
    HighSpeedGovernor,
    TorqueLimiting,
    AbsControl,
    TransmissionControl,
    AsrControl,
    RoadSpeedGovernor,
    PtoGovernor,
    CruiseControl,
    AcceleratorPedalOperatorSelec,
    LowIdleGovernorNoRequestDe,
    XValue(u64),
}

impl From<u64> for EngineTorqueMode2365480958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngineTorqueMode2365480958::NotAvailable,
            11 => EngineTorqueMode2365480958::RemoteAccelerator,
            10 => EngineTorqueMode2365480958::BrakingSystem,
            9 => EngineTorqueMode2365480958::HighSpeedGovernor,
            8 => EngineTorqueMode2365480958::TorqueLimiting,
            7 => EngineTorqueMode2365480958::AbsControl,
            6 => EngineTorqueMode2365480958::TransmissionControl,
            5 => EngineTorqueMode2365480958::AsrControl,
            4 => EngineTorqueMode2365480958::RoadSpeedGovernor,
            3 => EngineTorqueMode2365480958::PtoGovernor,
            2 => EngineTorqueMode2365480958::CruiseControl,
            1 => EngineTorqueMode2365480958::AcceleratorPedalOperatorSelec,
            0 => EngineTorqueMode2365480958::LowIdleGovernorNoRequestDe,
            value => EngineTorqueMode2365480958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineRunning2365480958 {
    EngineRunning,
    EngineNotRunning,
    XValue(u64),
}

impl From<u64> for EngineRunning2365480958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngineRunning2365480958::EngineRunning,
            0 => EngineRunning2365480958::EngineNotRunning,
            value => EngineRunning2365480958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineControlAllowed2365480958 {
    EngineControlAllowed,
    EngineControlNotAllowed,
    XValue(u64),
}

impl From<u64> for EngineControlAllowed2365480958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngineControlAllowed2365480958::EngineControlAllowed,
            0 => EngineControlAllowed2365480958::EngineControlNotAllowed,
            value => EngineControlAllowed2365480958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ClutchIndptdPtoFeedback2566808062 {
    Engaged,
    NotEngaged,
    XValue(u64),
}

impl From<u64> for ClutchIndptdPtoFeedback2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ClutchIndptdPtoFeedback2566808062::Engaged,
            0 => ClutchIndptdPtoFeedback2566808062::NotEngaged,
            value => ClutchIndptdPtoFeedback2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccelPedalLowIdleSwitch2566808062 {
    InLowIdleCondition,
    NotInLowIdleCondition,
    XValue(u64),
}

impl From<u64> for AccelPedalLowIdleSwitch2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AccelPedalLowIdleSwitch2566808062::InLowIdleCondition,
            0 => AccelPedalLowIdleSwitch2566808062::NotInLowIdleCondition,
            value => AccelPedalLowIdleSwitch2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum StarterActive2566808062 {
    StarterActive,
    StarterNotActive,
    XValue(u64),
}

impl From<u64> for StarterActive2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => StarterActive2566808062::StarterActive,
            0 => StarterActive2566808062::StarterNotActive,
            value => StarterActive2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TorqueConvtOilTempWarning2566808062 {
    Warning,
    Prewarning,
    NoWarning,
    XValue(u64),
}

impl From<u64> for TorqueConvtOilTempWarning2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TorqueConvtOilTempWarning2566808062::Warning,
            1 => TorqueConvtOilTempWarning2566808062::Prewarning,
            0 => TorqueConvtOilTempWarning2566808062::NoWarning,
            value => TorqueConvtOilTempWarning2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PtoControlAllowed2566808062 {
    PtoControlAllowed,
    PtoControlNotAllowed,
    XValue(u64),
}

impl From<u64> for PtoControlAllowed2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => PtoControlAllowed2566808062::PtoControlAllowed,
            0 => PtoControlAllowed2566808062::PtoControlNotAllowed,
            value => PtoControlAllowed2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecEngineMtdPtoFeedback2566808062 {
    LimitsActivated,
    LimitsNotActivated,
    XValue(u64),
}

impl From<u64> for SecEngineMtdPtoFeedback2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecEngineMtdPtoFeedback2566808062::LimitsActivated,
            0 => SecEngineMtdPtoFeedback2566808062::LimitsNotActivated,
            value => SecEngineMtdPtoFeedback2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FirstEngineMtdPtoFeedback2566808062 {
    LimitsActivated,
    LimitsNotActivated,
    XValue(u64),
}

impl From<u64> for FirstEngineMtdPtoFeedback2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FirstEngineMtdPtoFeedback2566808062::LimitsActivated,
            0 => FirstEngineMtdPtoFeedback2566808062::LimitsNotActivated,
            value => FirstEngineMtdPtoFeedback2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecClutchDptdPtoFeedback2566808062 {
    Engaged,
    NotEngaged,
    XValue(u64),
}

impl From<u64> for SecClutchDptdPtoFeedback2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecClutchDptdPtoFeedback2566808062::Engaged,
            0 => SecClutchDptdPtoFeedback2566808062::NotEngaged,
            value => SecClutchDptdPtoFeedback2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FirstClutchDpdtPtoFeedback2566808062 {
    Engaged,
    NotEngaged,
    XValue(u64),
}

impl From<u64> for FirstClutchDpdtPtoFeedback2566808062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FirstClutchDpdtPtoFeedback2566808062::Engaged,
            0 => FirstClutchDpdtPtoFeedback2566808062::NotEngaged,
            value => FirstClutchDpdtPtoFeedback2566808062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FuelLevelWarning2566808574 {
    FuelLevelWarningOn,
    FuelLevelWarningOff,
    XValue(u64),
}

impl From<u64> for FuelLevelWarning2566808574 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FuelLevelWarning2566808574::FuelLevelWarningOn,
            0 => FuelLevelWarning2566808574::FuelLevelWarningOff,
            value => FuelLevelWarning2566808574::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineOilPressureWarning2566808574 {
    Warning,
    NoWarning,
    XValue(u64),
}

impl From<u64> for EngineOilPressureWarning2566808574 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngineOilPressureWarning2566808574::Warning,
            0 => EngineOilPressureWarning2566808574::NoWarning,
            value => EngineOilPressureWarning2566808574::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineCoolantTempWarning2566808574 {
    Warning,
    Prewarning,
    NoWarning,
    XValue(u64),
}

impl From<u64> for EngineCoolantTempWarning2566808574 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => EngineCoolantTempWarning2566808574::Warning,
            1 => EngineCoolantTempWarning2566808574::Prewarning,
            0 => EngineCoolantTempWarning2566808574::NoWarning,
            value => EngineCoolantTempWarning2566808574::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleType2564947710 {
    DollyAxle,
    TowingOrTowedVehicle,
    XValue(u64),
}

impl From<u64> for VehicleType2564947710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => VehicleType2564947710::DollyAxle,
            0 => VehicleType2564947710::TowingOrTowedVehicle,
            value => VehicleType2564947710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntiTheftDeviceStatus2566834430 {
    AntiTheftDeviceOn,
    AntiTheftDeviceOff,
    XValue(u64),
}

impl From<u64> for AntiTheftDeviceStatus2566834430 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AntiTheftDeviceStatus2566834430::AntiTheftDeviceOn,
            0 => AntiTheftDeviceStatus2566834430::AntiTheftDeviceOff,
            value => AntiTheftDeviceStatus2566834430::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OddStatus2566834430 {
    OddActive,
    OddInactive,
    XValue(u64),
}

impl From<u64> for OddStatus2566834430 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OddStatus2566834430::OddActive,
            0 => OddStatus2566834430::OddInactive,
            value => OddStatus2566834430::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecEngineMtdPtoSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for SecEngineMtdPtoSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecEngineMtdPtoSwitch2566808318::SwitchedOn,
            0 => SecEngineMtdPtoSwitch2566808318::SwitchedOff,
            value => SecEngineMtdPtoSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecClutchDpdtPtoSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for SecClutchDpdtPtoSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecClutchDpdtPtoSwitch2566808318::SwitchedOn,
            0 => SecClutchDpdtPtoSwitch2566808318::SwitchedOff,
            value => SecClutchDpdtPtoSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FirstClutchDpdtPtoSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for FirstClutchDpdtPtoSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FirstClutchDpdtPtoSwitch2566808318::SwitchedOn,
            0 => FirstClutchDpdtPtoSwitch2566808318::SwitchedOff,
            value => FirstClutchDpdtPtoSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OperatingPanelActive2566808318 {
    OperatingPanelActive,
    OperatingPanelNotActive,
    XValue(u64),
}

impl From<u64> for OperatingPanelActive2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OperatingPanelActive2566808318::OperatingPanelActive,
            0 => OperatingPanelActive2566808318::OperatingPanelNotActive,
            value => OperatingPanelActive2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RefusePackerStepSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for RefusePackerStepSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => RefusePackerStepSwitch2566808318::SwitchedOn,
            0 => RefusePackerStepSwitch2566808318::SwitchedOff,
            value => RefusePackerStepSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineStopSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for EngineStopSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngineStopSwitch2566808318::SwitchedOn,
            0 => EngineStopSwitch2566808318::SwitchedOff,
            value => EngineStopSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngineStartSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for EngineStartSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngineStartSwitch2566808318::SwitchedOn,
            0 => EngineStartSwitch2566808318::SwitchedOff,
            value => EngineStartSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum StarterLockoutSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for StarterLockoutSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => StarterLockoutSwitch2566808318::SwitchedOn,
            0 => StarterLockoutSwitch2566808318::SwitchedOff,
            value => StarterLockoutSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FirstEngineMtdPtoSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for FirstEngineMtdPtoSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FirstEngineMtdPtoSwitch2566808318::SwitchedOn,
            0 => FirstEngineMtdPtoSwitch2566808318::SwitchedOff,
            value => FirstEngineMtdPtoSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ClutchIndpdtPtoSwitch2566808318 {
    SwitchedOn,
    SwitchedOff,
    XValue(u64),
}

impl From<u64> for ClutchIndpdtPtoSwitch2566808318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ClutchIndpdtPtoSwitch2566808318::SwitchedOn,
            0 => ClutchIndpdtPtoSwitch2566808318::SwitchedOff,
            value => ClutchIndpdtPtoSwitch2566808318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftSideMarkerLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftSideMarkerLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftSideMarkerLight2566808830::LampSLit,
            0 => TrailerLeftSideMarkerLight2566808830::LampSNotLit,
            value => TrailerLeftSideMarkerLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftReversingLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftReversingLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftReversingLight2566808830::LampSLit,
            0 => TrailerLeftReversingLight2566808830::LampSNotLit,
            value => TrailerLeftReversingLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftRearWidIndLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftRearWidIndLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftRearWidIndLight2566808830::LampSLit,
            0 => TrailerLeftRearWidIndLight2566808830::LampSNotLit,
            value => TrailerLeftRearWidIndLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftRearRegPltLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftRearRegPltLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftRearRegPltLight2566808830::LampSLit,
            0 => TrailerLeftRearRegPltLight2566808830::LampSNotLit,
            value => TrailerLeftRearRegPltLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftRearLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftRearLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftRearLight2566808830::LampSLit,
            0 => TrailerLeftRearLight2566808830::LampSNotLit,
            value => TrailerLeftRearLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftRearFogLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftRearFogLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftRearFogLight2566808830::LampSLit,
            0 => TrailerLeftRearFogLight2566808830::LampSNotLit,
            value => TrailerLeftRearFogLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftDirIndLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftDirIndLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftDirIndLight2566808830::LampSLit,
            0 => TrailerLeftDirIndLight2566808830::LampSNotLit,
            value => TrailerLeftDirIndLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftCrnMarkerLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftCrnMarkerLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftCrnMarkerLight2566808830::LampSLit,
            0 => TrailerLeftCrnMarkerLight2566808830::LampSNotLit,
            value => TrailerLeftCrnMarkerLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerInteriorLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerInteriorLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerInteriorLight2566808830::LampSLit,
            0 => TrailerInteriorLight2566808830::LampSNotLit,
            value => TrailerInteriorLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerWorkLamp2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerWorkLamp2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerWorkLamp2566808830::LampSLit,
            0 => TrailerWorkLamp2566808830::LampSNotLit,
            value => TrailerWorkLamp2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRotatingIdentLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRotatingIdentLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRotatingIdentLight2566808830::LampSLit,
            0 => TrailerRotatingIdentLight2566808830::LampSNotLit,
            value => TrailerRotatingIdentLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightStopLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightStopLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightStopLight2566808830::LampSLit,
            0 => TrailerRightStopLight2566808830::LampSNotLit,
            value => TrailerRightStopLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightSideMrkLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightSideMrkLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightSideMrkLight2566808830::LampSLit,
            0 => TrailerRightSideMrkLight2566808830::LampSNotLit,
            value => TrailerRightSideMrkLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightReversingLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightReversingLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightReversingLight2566808830::LampSLit,
            0 => TrailerRightReversingLight2566808830::LampSNotLit,
            value => TrailerRightReversingLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailRightRearWidIndLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailRightRearWidIndLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailRightRearWidIndLight2566808830::LampSLit,
            0 => TrailRightRearWidIndLight2566808830::LampSNotLit,
            value => TrailRightRearWidIndLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightRearRegPltLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightRearRegPltLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightRearRegPltLight2566808830::LampSLit,
            0 => TrailerRightRearRegPltLight2566808830::LampSNotLit,
            value => TrailerRightRearRegPltLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightRearLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightRearLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightRearLight2566808830::LampSLit,
            0 => TrailerRightRearLight2566808830::LampSNotLit,
            value => TrailerRightRearLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightRearFogLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightRearFogLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightRearFogLight2566808830::LampSLit,
            0 => TrailerRightRearFogLight2566808830::LampSNotLit,
            value => TrailerRightRearFogLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightDirIndLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightDirIndLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightDirIndLight2566808830::LampSLit,
            0 => TrailerRightDirIndLight2566808830::LampSNotLit,
            value => TrailerRightDirIndLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRightCrnMarkerLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRightCrnMarkerLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRightCrnMarkerLight2566808830::LampSLit,
            0 => TrailerRightCrnMarkerLight2566808830::LampSNotLit,
            value => TrailerRightCrnMarkerLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerRearWarningLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerRearWarningLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerRearWarningLight2566808830::LampSLit,
            0 => TrailerRearWarningLight2566808830::LampSNotLit,
            value => TrailerRearWarningLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerLeftStopLight2566808830 {
    LampSLit,
    LampSNotLit,
    XValue(u64),
}

impl From<u64> for TrailerLeftStopLight2566808830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TrailerLeftStopLight2566808830::LampSLit,
            0 => TrailerLeftStopLight2566808830::LampSNotLit,
            value => TrailerLeftStopLight2566808830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlowStatus2564554494 {
    Overflow,
    Wait,
    ContinueToSend,
    XValue(u64),
}

impl From<u64> for FlowStatus2564554494 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => FlowStatus2564554494::Overflow,
            1 => FlowStatus2564554494::Wait,
            0 => FlowStatus2564554494::ContinueToSend,
            value => FlowStatus2564554494::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtocolCtrlInformation2564554494 {
    FlowControl,
    ConsecutiveFrame,
    FirstFrame,
    SingleFrame,
    XValue(u64),
}

impl From<u64> for ProtocolCtrlInformation2564554494 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtocolCtrlInformation2564554494::FlowControl,
            2 => ProtocolCtrlInformation2564554494::ConsecutiveFrame,
            1 => ProtocolCtrlInformation2564554494::FirstFrame,
            0 => ProtocolCtrlInformation2564554494::SingleFrame,
            value => ProtocolCtrlInformation2564554494::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlowStatus2564488958 {
    Overflow,
    Wait,
    ContinueToSend,
    XValue(u64),
}

impl From<u64> for FlowStatus2564488958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => FlowStatus2564488958::Overflow,
            1 => FlowStatus2564488958::Wait,
            0 => FlowStatus2564488958::ContinueToSend,
            value => FlowStatus2564488958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtocolCtrlInformation2564488958 {
    FlowControl,
    ConsecutiveFrame,
    FirstFrame,
    SingleFrame,
    XValue(u64),
}

impl From<u64> for ProtocolCtrlInformation2564488958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtocolCtrlInformation2564488958::FlowControl,
            2 => ProtocolCtrlInformation2564488958::ConsecutiveFrame,
            1 => ProtocolCtrlInformation2564488958::FirstFrame,
            0 => ProtocolCtrlInformation2564488958::SingleFrame,
            value => ProtocolCtrlInformation2564488958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ControlByte2565734142 {
    MfdbCreateEntry,
    MfdbSetMode,
    MfdbClear,
    MfdbDelete,
    MfdbAdd,
    MfdbResponse,
    MfdbRequest,
    XValue(u64),
}

impl From<u64> for ControlByte2565734142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => ControlByte2565734142::MfdbCreateEntry,
            5 => ControlByte2565734142::MfdbSetMode,
            4 => ControlByte2565734142::MfdbClear,
            3 => ControlByte2565734142::MfdbDelete,
            2 => ControlByte2565734142::MfdbAdd,
            1 => ControlByte2565734142::MfdbResponse,
            0 => ControlByte2565734142::MfdbRequest,
            value => ControlByte2565734142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FilterMode2565734142 {
    PassSpecificPgNs,
    BlockSpecificPgNs,
    XValue(u64),
}

impl From<u64> for FilterMode2565734142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FilterMode2565734142::PassSpecificPgNs,
            0 => FilterMode2565734142::BlockSpecificPgNs,
            value => FilterMode2565734142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum StopLevelChangeReq2565144318 {
    TakeNoAction,
    StopRequest,
    NoStopRequest,
    XValue(u64),
}

impl From<u64> for StopLevelChangeReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => StopLevelChangeReq2565144318::TakeNoAction,
            1 => StopLevelChangeReq2565144318::StopRequest,
            0 => StopLevelChangeReq2565144318::NoStopRequest,
            value => StopLevelChangeReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RampLevelStorageReq2565144318 {
    TakeNoAction,
    StoreRampLevel2,
    StoreRampLevel1,
    XValue(u64),
}

impl From<u64> for RampLevelStorageReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RampLevelStorageReq2565144318::TakeNoAction,
            1 => RampLevelStorageReq2565144318::StoreRampLevel2,
            0 => RampLevelStorageReq2565144318::StoreRampLevel1,
            value => RampLevelStorageReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelControlReq2565144318 {
    TakeNoAction,
    EnableLevelControl,
    DisableLevelControl,
    XValue(u64),
}

impl From<u64> for LevelControlReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LevelControlReq2565144318::TakeNoAction,
            1 => LevelControlReq2565144318::EnableLevelControl,
            0 => LevelControlReq2565144318::DisableLevelControl,
            value => LevelControlReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RampLevelReq2565144318 {
    TakeNoAction,
    RampLevel2,
    RampLevel1,
    XValue(u64),
}

impl From<u64> for RampLevelReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RampLevelReq2565144318::TakeNoAction,
            1 => RampLevelReq2565144318::RampLevel2,
            0 => RampLevelReq2565144318::RampLevel1,
            value => RampLevelReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteeringAxleLockingReq2565144318 {
    TakeNoAction,
    LockSteeringAxle,
    UnlockSteeringAxle,
    XValue(u64),
}

impl From<u64> for SteeringAxleLockingReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SteeringAxleLockingReq2565144318::TakeNoAction,
            1 => SteeringAxleLockingReq2565144318::LockSteeringAxle,
            0 => SteeringAxleLockingReq2565144318::UnlockSteeringAxle,
            value => SteeringAxleLockingReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle2PositionReq2565144318 {
    TakeNoAction,
    PositionUpTagAxleUnladen,
    PositionDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle2PositionReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle2PositionReq2565144318::TakeNoAction,
            1 => LiftAxle2PositionReq2565144318::PositionUpTagAxleUnladen,
            0 => LiftAxle2PositionReq2565144318::PositionDownTagAxleLaden,
            value => LiftAxle2PositionReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle1PositionReq2565144318 {
    DonXtCareTakeNoAction,
    Reserved,
    PositionUpTagAxleUnladen,
    PositionDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle1PositionReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle1PositionReq2565144318::DonXtCareTakeNoAction,
            2 => LiftAxle1PositionReq2565144318::Reserved,
            1 => LiftAxle1PositionReq2565144318::PositionUpTagAxleUnladen,
            0 => LiftAxle1PositionReq2565144318::PositionDownTagAxleLaden,
            value => LiftAxle1PositionReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractionHelpReq2565144318 {
    TakeNoAction,
    TractionHelpRequest,
    NoTractionHelpRequest,
    XValue(u64),
}

impl From<u64> for TractionHelpReq2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractionHelpReq2565144318::TakeNoAction,
            1 => TractionHelpReq2565144318::TractionHelpRequest,
            0 => TractionHelpReq2565144318::NoTractionHelpRequest,
            value => TractionHelpReq2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelChangeReqRearAxle2565144318 {
    TakeNoAction,
    VehicleBodyDownLowering,
    VehicleBodyUpLifting,
    XValue(u64),
}

impl From<u64> for LevelChangeReqRearAxle2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => LevelChangeReqRearAxle2565144318::TakeNoAction,
            1 => LevelChangeReqRearAxle2565144318::VehicleBodyDownLowering,
            0 => LevelChangeReqRearAxle2565144318::VehicleBodyUpLifting,
            value => LevelChangeReqRearAxle2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelChangeReqFrontAxle2565144318 {
    TakeNoAction,
    VehicleBodyDownLowering,
    VehicleBodyUpLifting,
    XValue(u64),
}

impl From<u64> for LevelChangeReqFrontAxle2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => LevelChangeReqFrontAxle2565144318::TakeNoAction,
            1 => LevelChangeReqFrontAxle2565144318::VehicleBodyDownLowering,
            0 => LevelChangeReqFrontAxle2565144318::VehicleBodyUpLifting,
            value => LevelChangeReqFrontAxle2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RideHeightRequest2565144318 {
    TakeNoAction,
    NormalLevel2,
    NormalLevel1,
    XValue(u64),
}

impl From<u64> for RideHeightRequest2565144318 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => RideHeightRequest2565144318::TakeNoAction,
            1 => RideHeightRequest2565144318::NormalLevel2,
            0 => RideHeightRequest2565144318::NormalLevel1,
            value => RideHeightRequest2565144318::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelControl2565209854 {
    LevelControlEnabled,
    LevelControlDisabled,
    XValue(u64),
}

impl From<u64> for LevelControl2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => LevelControl2565209854::LevelControlEnabled,
            0 => LevelControl2565209854::LevelControlDisabled,
            value => LevelControl2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RampLevel2565209854 {
    BodyAtRequestedRampLevel,
    BodyNotAtRequestedRampLevel,
    XValue(u64),
}

impl From<u64> for RampLevel2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => RampLevel2565209854::BodyAtRequestedRampLevel,
            0 => RampLevel2565209854::BodyNotAtRequestedRampLevel,
            value => RampLevel2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NormalLevel2565209854 {
    NotAvailable,
    NormalLevel2,
    NormalLevel1,
    XValue(u64),
}

impl From<u64> for NormalLevel2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => NormalLevel2565209854::NotAvailable,
            1 => NormalLevel2565209854::NormalLevel2,
            0 => NormalLevel2565209854::NormalLevel1,
            value => NormalLevel2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum StopLevelChangeAcknowledge2565209854 {
    LevelChangeStopped,
    NoStopRequest,
    XValue(u64),
}

impl From<u64> for StopLevelChangeAcknowledge2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => StopLevelChangeAcknowledge2565209854::LevelChangeStopped,
            0 => StopLevelChangeAcknowledge2565209854::NoStopRequest,
            value => StopLevelChangeAcknowledge2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelChangeRearAxle2565209854 {
    BodyLiftingLoweringActive,
    BodyLiftingLoweringNotActive,
    XValue(u64),
}

impl From<u64> for LevelChangeRearAxle2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => LevelChangeRearAxle2565209854::BodyLiftingLoweringActive,
            0 => LevelChangeRearAxle2565209854::BodyLiftingLoweringNotActive,
            value => LevelChangeRearAxle2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelChangeFrontAxle2565209854 {
    BodyLiftingLoweringActive,
    BodyLiftingLoweringNotActive,
    XValue(u64),
}

impl From<u64> for LevelChangeFrontAxle2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => LevelChangeFrontAxle2565209854::BodyLiftingLoweringActive,
            0 => LevelChangeFrontAxle2565209854::BodyLiftingLoweringNotActive,
            value => LevelChangeFrontAxle2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RampLevelStorage2565209854 {
    NewRampLevelStored,
    NoNewStorageRequest,
    XValue(u64),
}

impl From<u64> for RampLevelStorage2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => RampLevelStorage2565209854::NewRampLevelStored,
            0 => RampLevelStorage2565209854::NoNewStorageRequest,
            value => RampLevelStorage2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteeringAxleLocking2565209854 {
    SteeringAxleLocked,
    SteeringAxleUnlocked,
    XValue(u64),
}

impl From<u64> for SteeringAxleLocking2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SteeringAxleLocking2565209854::SteeringAxleLocked,
            0 => SteeringAxleLocking2565209854::SteeringAxleUnlocked,
            value => SteeringAxleLocking2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle2Pos2565209854 {
    NotAvailable,
    Error,
    LiftAxlePosUpTagAxleUnladen,
    LiftAxlePosDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle2Pos2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle2Pos2565209854::NotAvailable,
            2 => LiftAxle2Pos2565209854::Error,
            1 => LiftAxle2Pos2565209854::LiftAxlePosUpTagAxleUnladen,
            0 => LiftAxle2Pos2565209854::LiftAxlePosDownTagAxleLaden,
            value => LiftAxle2Pos2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle1Pos2565209854 {
    NotAvailable,
    Error,
    LiftAxlePosUpTagAxleUnladen,
    LiftAxlePosDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle1Pos2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle1Pos2565209854::NotAvailable,
            2 => LiftAxle1Pos2565209854::Error,
            1 => LiftAxle1Pos2565209854::LiftAxlePosUpTagAxleUnladen,
            0 => LiftAxle1Pos2565209854::LiftAxlePosDownTagAxleLaden,
            value => LiftAxle1Pos2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RampLevelPosition2565209854 {
    NotAvailable,
    RampLevel2,
    RampLevel1,
    XValue(u64),
}

impl From<u64> for RampLevelPosition2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RampLevelPosition2565209854::NotAvailable,
            1 => RampLevelPosition2565209854::RampLevel2,
            0 => RampLevelPosition2565209854::RampLevel1,
            value => RampLevelPosition2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractionHelp2565209854 {
    TractionHelpActive,
    TractionHelpInactive,
    XValue(u64),
}

impl From<u64> for TractionHelp2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TractionHelp2565209854::TractionHelpActive,
            0 => TractionHelp2565209854::TractionHelpInactive,
            value => TractionHelp2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelCtrlSysRideHeightLevel2565209854 {
    VehicleBodyAtRequestedLevel,
    VehicleBodyNotAtReqLevel,
    XValue(u64),
}

impl From<u64> for LevelCtrlSysRideHeightLevel2565209854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => LevelCtrlSysRideHeightLevel2565209854::VehicleBodyAtRequestedLevel,
            0 => LevelCtrlSysRideHeightLevel2565209854::VehicleBodyNotAtReqLevel,
            value => LevelCtrlSysRideHeightLevel2565209854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyrePressThresholdDetect2566807294 {
    NotAvailable,
    ErrorIndicator,
    NotDefined,
    ExtremeUnderPressure,
    UnderPressure,
    NoWarningPressure,
    OverPressure,
    ExtremeOverPressure,
    XValue(u64),
}

impl From<u64> for TyrePressThresholdDetect2566807294 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TyrePressThresholdDetect2566807294::NotAvailable,
            6 => TyrePressThresholdDetect2566807294::ErrorIndicator,
            5 => TyrePressThresholdDetect2566807294::NotDefined,
            4 => TyrePressThresholdDetect2566807294::ExtremeUnderPressure,
            3 => TyrePressThresholdDetect2566807294::UnderPressure,
            2 => TyrePressThresholdDetect2566807294::NoWarningPressure,
            1 => TyrePressThresholdDetect2566807294::OverPressure,
            0 => TyrePressThresholdDetect2566807294::ExtremeOverPressure,
            value => TyrePressThresholdDetect2566807294::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreModulePowerSupply2566807294 {
    SufficientPowerSupply,
    InsufficientPowerSupply,
    XValue(u64),
}

impl From<u64> for TyreModulePowerSupply2566807294 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TyreModulePowerSupply2566807294::SufficientPowerSupply,
            0 => TyreModulePowerSupply2566807294::InsufficientPowerSupply,
            value => TyreModulePowerSupply2566807294::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentification22566807294 {
    AxlePosition15,
    AxlePosition14,
    AxlePosition13,
    AxlePosition12,
    AxlePosition11,
    AxlePosition10,
    AxlePosition9,
    AxlePosition8,
    AxlePosition7,
    AxlePosition6,
    AxlePosition5,
    AxlePosition4,
    AxlePosition3,
    AxlePosition2,
    AxlePosition1,
    AxlePositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentification22566807294 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentification22566807294::AxlePosition15,
            14 => TyreWheelIdentification22566807294::AxlePosition14,
            13 => TyreWheelIdentification22566807294::AxlePosition13,
            12 => TyreWheelIdentification22566807294::AxlePosition12,
            11 => TyreWheelIdentification22566807294::AxlePosition11,
            10 => TyreWheelIdentification22566807294::AxlePosition10,
            9 => TyreWheelIdentification22566807294::AxlePosition9,
            8 => TyreWheelIdentification22566807294::AxlePosition8,
            7 => TyreWheelIdentification22566807294::AxlePosition7,
            6 => TyreWheelIdentification22566807294::AxlePosition6,
            5 => TyreWheelIdentification22566807294::AxlePosition5,
            4 => TyreWheelIdentification22566807294::AxlePosition4,
            3 => TyreWheelIdentification22566807294::AxlePosition3,
            2 => TyreWheelIdentification22566807294::AxlePosition2,
            1 => TyreWheelIdentification22566807294::AxlePosition1,
            0 => TyreWheelIdentification22566807294::AxlePositionNotIdentified,
            value => TyreWheelIdentification22566807294::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TyreWheelIdentification12566807294 {
    WheelPosition15,
    WheelPosition14,
    WheelPosition13,
    WheelPosition12,
    WheelPosition11,
    WheelPosition10,
    WheelPosition9,
    WheelPosition8,
    WheelPosition7,
    WheelPosition6,
    WheelPosition5,
    WheelPosition4,
    WheelPosition3,
    WheelPosition2,
    WheelPosition1,
    WheelPositionNotIdentified,
    XValue(u64),
}

impl From<u64> for TyreWheelIdentification12566807294 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TyreWheelIdentification12566807294::WheelPosition15,
            14 => TyreWheelIdentification12566807294::WheelPosition14,
            13 => TyreWheelIdentification12566807294::WheelPosition13,
            12 => TyreWheelIdentification12566807294::WheelPosition12,
            11 => TyreWheelIdentification12566807294::WheelPosition11,
            10 => TyreWheelIdentification12566807294::WheelPosition10,
            9 => TyreWheelIdentification12566807294::WheelPosition9,
            8 => TyreWheelIdentification12566807294::WheelPosition8,
            7 => TyreWheelIdentification12566807294::WheelPosition7,
            6 => TyreWheelIdentification12566807294::WheelPosition6,
            5 => TyreWheelIdentification12566807294::WheelPosition5,
            4 => TyreWheelIdentification12566807294::WheelPosition4,
            3 => TyreWheelIdentification12566807294::WheelPosition3,
            2 => TyreWheelIdentification12566807294::WheelPosition2,
            1 => TyreWheelIdentification12566807294::WheelPosition1,
            0 => TyreWheelIdentification12566807294::WheelPositionNotIdentified,
            value => TyreWheelIdentification12566807294::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MisfireMonitoringComplete2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for MisfireMonitoringComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => MisfireMonitoringComplete2566764798::EnabledForCycle,
            0 => MisfireMonitoringComplete2566764798::DisabledForRestOfCycle,
            value => MisfireMonitoringComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MisfireMonitoringEnabled2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for MisfireMonitoringEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => MisfireMonitoringEnabled2566764798::EnabledForCycle,
            0 => MisfireMonitoringEnabled2566764798::DisabledForRestOfCycle,
            value => MisfireMonitoringEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FuelSystemMonitoringEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for FuelSystemMonitoringEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FuelSystemMonitoringEnabled2566764798::NotCompleteCycle,
            0 => FuelSystemMonitoringEnabled2566764798::CompleteCycleOrNotSupported,
            value => FuelSystemMonitoringEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ComprehensiveComptMonComplete2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for ComprehensiveComptMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ComprehensiveComptMonComplete2566764798::NotCompleteCycle,
            0 => ComprehensiveComptMonComplete2566764798::CompleteCycleOrNotSupported,
            value => ComprehensiveComptMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ComprehensiveCompMonEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for ComprehensiveCompMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ComprehensiveCompMonEnabled2566764798::NotCompleteCycle,
            0 => ComprehensiveCompMonEnabled2566764798::CompleteCycleOrNotSupported,
            value => ComprehensiveCompMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecondAirSystemMonComplete2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for SecondAirSystemMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecondAirSystemMonComplete2566764798::EnabledForCycle,
            0 => SecondAirSystemMonComplete2566764798::DisabledForRestOfCycle,
            value => SecondAirSystemMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecondAirSystemMonEnabled2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for SecondAirSystemMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecondAirSystemMonEnabled2566764798::EnabledForCycle,
            0 => SecondAirSystemMonEnabled2566764798::DisabledForRestOfCycle,
            value => SecondAirSystemMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorMonComplete2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for OxygenSensorMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorMonComplete2566764798::EnabledForCycle,
            0 => OxygenSensorMonComplete2566764798::DisabledForRestOfCycle,
            value => OxygenSensorMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorMonEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for OxygenSensorMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorMonEnabled2566764798::NotCompleteCycle,
            0 => OxygenSensorMonEnabled2566764798::CompleteCycleOrNotSupported,
            value => OxygenSensorMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorHeaterMonComplete2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for OxygenSensorHeaterMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorHeaterMonComplete2566764798::EnabledForCycle,
            0 => OxygenSensorHeaterMonComplete2566764798::DisabledForRestOfCycle,
            value => OxygenSensorHeaterMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorHeaterMonEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for OxygenSensorHeaterMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorHeaterMonEnabled2566764798::NotCompleteCycle,
            0 => OxygenSensorHeaterMonEnabled2566764798::CompleteCycleOrNotSupported,
            value => OxygenSensorHeaterMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HeatedCatalystMonComplete2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for HeatedCatalystMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => HeatedCatalystMonComplete2566764798::EnabledForCycle,
            0 => HeatedCatalystMonComplete2566764798::DisabledForRestOfCycle,
            value => HeatedCatalystMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HeatedCatalystMonEnabled2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for HeatedCatalystMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => HeatedCatalystMonEnabled2566764798::EnabledForCycle,
            0 => HeatedCatalystMonEnabled2566764798::DisabledForRestOfCycle,
            value => HeatedCatalystMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EvaporativeSystemMonComplete2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for EvaporativeSystemMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EvaporativeSystemMonComplete2566764798::NotCompleteCycle,
            0 => EvaporativeSystemMonComplete2566764798::CompleteCycleOrNotSupported,
            value => EvaporativeSystemMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EvaporativeSystemMonEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for EvaporativeSystemMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EvaporativeSystemMonEnabled2566764798::NotCompleteCycle,
            0 => EvaporativeSystemMonEnabled2566764798::CompleteCycleOrNotSupported,
            value => EvaporativeSystemMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EgrSystemMonitoringComplete2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for EgrSystemMonitoringComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EgrSystemMonitoringComplete2566764798::NotCompleteCycle,
            0 => EgrSystemMonitoringComplete2566764798::CompleteCycleOrNotSupported,
            value => EgrSystemMonitoringComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EgrSystemMonitoringEnabled2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for EgrSystemMonitoringEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EgrSystemMonitoringEnabled2566764798::EnabledForCycle,
            0 => EgrSystemMonitoringEnabled2566764798::DisabledForRestOfCycle,
            value => EgrSystemMonitoringEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ColdStartAidSystemMonComplete2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for ColdStartAidSystemMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ColdStartAidSystemMonComplete2566764798::EnabledForCycle,
            0 => ColdStartAidSystemMonComplete2566764798::DisabledForRestOfCycle,
            value => ColdStartAidSystemMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ColdStartAidSystemMonEnabled2566764798 {
    EnabledForCycle,
    DisabledForRestOfCycle,
    XValue(u64),
}

impl From<u64> for ColdStartAidSystemMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ColdStartAidSystemMonEnabled2566764798::EnabledForCycle,
            0 => ColdStartAidSystemMonEnabled2566764798::DisabledForRestOfCycle,
            value => ColdStartAidSystemMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CatalystMonComplete2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for CatalystMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => CatalystMonComplete2566764798::NotCompleteCycle,
            0 => CatalystMonComplete2566764798::CompleteCycleOrNotSupported,
            value => CatalystMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CatalystMonEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for CatalystMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => CatalystMonEnabled2566764798::NotCompleteCycle,
            0 => CatalystMonEnabled2566764798::CompleteCycleOrNotSupported,
            value => CatalystMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AcSystemRefrigerantMonComplete2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for AcSystemRefrigerantMonComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AcSystemRefrigerantMonComplete2566764798::NotCompleteCycle,
            0 => AcSystemRefrigerantMonComplete2566764798::CompleteCycleOrNotSupported,
            value => AcSystemRefrigerantMonComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AcSystemRefrigerantMonEnabled2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for AcSystemRefrigerantMonEnabled2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AcSystemRefrigerantMonEnabled2566764798::NotCompleteCycle,
            0 => AcSystemRefrigerantMonEnabled2566764798::CompleteCycleOrNotSupported,
            value => AcSystemRefrigerantMonEnabled2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FuelSystemMonitoringComplete2566764798 {
    NotCompleteCycle,
    CompleteCycleOrNotSupported,
    XValue(u64),
}

impl From<u64> for FuelSystemMonitoringComplete2566764798 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FuelSystemMonitoringComplete2566764798::NotCompleteCycle,
            0 => FuelSystemMonitoringComplete2566764798::CompleteCycleOrNotSupported,
            value => FuelSystemMonitoringComplete2566764798::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecurityEntityType2564095742 {
    DataIsCertificate,
    DataIsSessionKey,
    DataIsLongKey,
    DataIsLongSeed,
    XValue(u64),
}

impl From<u64> for SecurityEntityType2564095742 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SecurityEntityType2564095742::DataIsCertificate,
            2 => SecurityEntityType2564095742::DataIsSessionKey,
            1 => SecurityEntityType2564095742::DataIsLongKey,
            0 => SecurityEntityType2564095742::DataIsLongSeed,
            value => SecurityEntityType2564095742::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum XbrCtrlMode2349137662 {
    NotDefined,
    AcclrtnCtrlWthMxMdExctXbrAcclrt,
    AcclrtnCtrlWthAddtnMdAddXbrAccl,
    OvrrdDsbldDsblAnyExstngCtrlCmdd,
    XValue(u64),
}

impl From<u64> for XbrCtrlMode2349137662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => XbrCtrlMode2349137662::NotDefined,
            2 => XbrCtrlMode2349137662::AcclrtnCtrlWthMxMdExctXbrAcclrt,
            1 => XbrCtrlMode2349137662::AcclrtnCtrlWthAddtnMdAddXbrAccl,
            0 => XbrCtrlMode2349137662::OvrrdDsbldDsblAnyExstngCtrlCmdd,
            value => XbrCtrlMode2349137662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum XbrPriority2349137662 {
    LwPrrtyUsdInOvrrdDsbldXbrCtrlMd,
    MdmPrrtyUsdFrAccSystmsThsMdDsNt,
    HighPriorityNotDefined,
    HghstPrrtyUsdFrEmrgncySttnsEgFr,
    XValue(u64),
}

impl From<u64> for XbrPriority2349137662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => XbrPriority2349137662::LwPrrtyUsdInOvrrdDsbldXbrCtrlMd,
            2 => XbrPriority2349137662::MdmPrrtyUsdFrAccSystmsThsMdDsNt,
            1 => XbrPriority2349137662::HighPriorityNotDefined,
            0 => XbrPriority2349137662::HghstPrrtyUsdFrEmrgncySttnsEgFr,
            value => XbrPriority2349137662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum XbrebiMode2349137662 {
    NotDefined,
    EndranceBrakeIntegrationAllowed,
    OnlyEnduranceBrakesAllowed,
    NEndrnceBrakeIntegrationAllowed,
    XValue(u64),
}

impl From<u64> for XbrebiMode2349137662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => XbrebiMode2349137662::NotDefined,
            2 => XbrebiMode2349137662::EndranceBrakeIntegrationAllowed,
            1 => XbrebiMode2349137662::OnlyEnduranceBrakesAllowed,
            0 => XbrebiMode2349137662::NEndrnceBrakeIntegrationAllowed,
            value => XbrebiMode2349137662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum WaterInFuelIndicator2566848510 {
    NotAvailable,
    Error,
    Yes,
    No,
    XValue(u64),
}

impl From<u64> for WaterInFuelIndicator2566848510 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => WaterInFuelIndicator2566848510::NotAvailable,
            2 => WaterInFuelIndicator2566848510::Error,
            1 => WaterInFuelIndicator2566848510::Yes,
            0 => WaterInFuelIndicator2566848510::No,
            value => WaterInFuelIndicator2566848510::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum WinchOilPressSwitch2566809854 {
    NotAvailable,
    ErrrSwtchStteCannotBeDetermined,
    OkOilPressIsAboveMin,
    NotokOilPressIsTooLow,
    XValue(u64),
}

impl From<u64> for WinchOilPressSwitch2566809854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => WinchOilPressSwitch2566809854::NotAvailable,
            2 => WinchOilPressSwitch2566809854::ErrrSwtchStteCannotBeDetermined,
            1 => WinchOilPressSwitch2566809854::OkOilPressIsAboveMin,
            0 => WinchOilPressSwitch2566809854::NotokOilPressIsTooLow,
            value => WinchOilPressSwitch2566809854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HydOilFilterRestrictionSwitch2566809854 {
    NotAvailable,
    Error,
    RestrictionExistsOnOilFilter,
    NoRestriction,
    XValue(u64),
}

impl From<u64> for HydOilFilterRestrictionSwitch2566809854 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HydOilFilterRestrictionSwitch2566809854::NotAvailable,
            2 => HydOilFilterRestrictionSwitch2566809854::Error,
            1 => HydOilFilterRestrictionSwitch2566809854::RestrictionExistsOnOilFilter,
            0 => HydOilFilterRestrictionSwitch2566809854::NoRestriction,
            value => HydOilFilterRestrictionSwitch2566809854::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteerWheelAngleSensorType2565868030 {
    NotAvailable,
    Reserved,
    AbsMeasuringPrinciple,
    RelativeMeasuringPrinciple,
    XValue(u64),
}

impl From<u64> for SteerWheelAngleSensorType2565868030 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SteerWheelAngleSensorType2565868030::NotAvailable,
            2 => SteerWheelAngleSensorType2565868030::Reserved,
            1 => SteerWheelAngleSensorType2565868030::AbsMeasuringPrinciple,
            0 => SteerWheelAngleSensorType2565868030::RelativeMeasuringPrinciple,
            value => SteerWheelAngleSensorType2565868030::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum YcBrakeCtrlActive2566803454 {
    DontCareTakeNoAction,
    Reserved,
    YcBrakeCtrlActive,
    YcBrakeCtrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for YcBrakeCtrlActive2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => YcBrakeCtrlActive2566803454::DontCareTakeNoAction,
            2 => YcBrakeCtrlActive2566803454::Reserved,
            1 => YcBrakeCtrlActive2566803454::YcBrakeCtrlActive,
            0 => YcBrakeCtrlActive2566803454::YcBrakeCtrlPassiveButInstalled,
            value => YcBrakeCtrlActive2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum YcEngCtrlActive2566803454 {
    DontCareTakeNoAction,
    Reserved,
    YcEngCtrlActive,
    YcEngCtrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for YcEngCtrlActive2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => YcEngCtrlActive2566803454::DontCareTakeNoAction,
            2 => YcEngCtrlActive2566803454::Reserved,
            1 => YcEngCtrlActive2566803454::YcEngCtrlActive,
            0 => YcEngCtrlActive2566803454::YcEngCtrlPassiveButInstalled,
            value => YcEngCtrlActive2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RopBrakeCtrlActive2566803454 {
    DontCareTakeNoAction,
    Reserved,
    RopBrakeCtrlActive,
    RopBrakeCtrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for RopBrakeCtrlActive2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RopBrakeCtrlActive2566803454::DontCareTakeNoAction,
            2 => RopBrakeCtrlActive2566803454::Reserved,
            1 => RopBrakeCtrlActive2566803454::RopBrakeCtrlActive,
            0 => RopBrakeCtrlActive2566803454::RopBrakeCtrlPassiveButInstalled,
            value => RopBrakeCtrlActive2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RopEngCtrlActive2566803454 {
    DontCareTakeNoAction,
    Reserved,
    RopEngCtrlActive,
    RopEngCtrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for RopEngCtrlActive2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RopEngCtrlActive2566803454::DontCareTakeNoAction,
            2 => RopEngCtrlActive2566803454::Reserved,
            1 => RopEngCtrlActive2566803454::RopEngCtrlActive,
            0 => RopEngCtrlActive2566803454::RopEngCtrlPassiveButInstalled,
            value => RopEngCtrlActive2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VdcBrakeLightRq2566803454 {
    DontCareTakeNoAction,
    Reserved,
    TurnBrakeLightOn,
    TurnBrakeLightNotOn,
    XValue(u64),
}

impl From<u64> for VdcBrakeLightRq2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VdcBrakeLightRq2566803454::DontCareTakeNoAction,
            2 => VdcBrakeLightRq2566803454::Reserved,
            1 => VdcBrakeLightRq2566803454::TurnBrakeLightOn,
            0 => VdcBrakeLightRq2566803454::TurnBrakeLightNotOn,
            value => VdcBrakeLightRq2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VdcFullyOperational2566803454 {
    DontCareTakeNoAction,
    Reserved,
    FullyOperational,
    NotFullyOperational,
    XValue(u64),
}

impl From<u64> for VdcFullyOperational2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VdcFullyOperational2566803454::DontCareTakeNoAction,
            2 => VdcFullyOperational2566803454::Reserved,
            1 => VdcFullyOperational2566803454::FullyOperational,
            0 => VdcFullyOperational2566803454::NotFullyOperational,
            value => VdcFullyOperational2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VdcInformationSignal2566803454 {
    DontCareTakeNoAction,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for VdcInformationSignal2566803454 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VdcInformationSignal2566803454::DontCareTakeNoAction,
            2 => VdcInformationSignal2566803454::Reserved,
            1 => VdcInformationSignal2566803454::On,
            0 => VdcInformationSignal2566803454::Off,
            value => VdcInformationSignal2566803454::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ControlPurpose2348875518 {
    TemporaryPowerTrainControl,
    EngineProtection,
    RoadSpeedGovernor,
    PtoGovernor,
    CruiseControl,
    AcceleratorPedal,
    XValue(u64),
}

impl From<u64> for ControlPurpose2348875518 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            5 => ControlPurpose2348875518::TemporaryPowerTrainControl,
            4 => ControlPurpose2348875518::EngineProtection,
            3 => ControlPurpose2348875518::RoadSpeedGovernor,
            2 => ControlPurpose2348875518::PtoGovernor,
            1 => ControlPurpose2348875518::CruiseControl,
            0 => ControlPurpose2348875518::AcceleratorPedal,
            value => ControlPurpose2348875518::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransmissionRate2348875518 {
    UseStandardRate,
    X25ms,
    X50ms,
    X100ms,
    X250ms,
    X500ms,
    X750ms,
    X1000ms,
    XValue(u64),
}

impl From<u64> for TransmissionRate2348875518 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TransmissionRate2348875518::UseStandardRate,
            6 => TransmissionRate2348875518::X25ms,
            5 => TransmissionRate2348875518::X50ms,
            4 => TransmissionRate2348875518::X100ms,
            3 => TransmissionRate2348875518::X250ms,
            2 => TransmissionRate2348875518::X500ms,
            1 => TransmissionRate2348875518::X750ms,
            0 => TransmissionRate2348875518::X1000ms,
            value => TransmissionRate2348875518::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OverrideCtrlModePriority2348875518 {
    LowPriority,
    MdmPrrtyUsdFrPwrtrnCtrlOprtnsWh,
    HighPriority,
    HghstPrrtyUsdFrSttnsThtRqrImmdt,
    XValue(u64),
}

impl From<u64> for OverrideCtrlModePriority2348875518 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OverrideCtrlModePriority2348875518::LowPriority,
            2 => OverrideCtrlModePriority2348875518::MdmPrrtyUsdFrPwrtrnCtrlOprtnsWh,
            1 => OverrideCtrlModePriority2348875518::HighPriority,
            0 => OverrideCtrlModePriority2348875518::HghstPrrtyUsdFrSttnsThtRqrImmdt,
            value => OverrideCtrlModePriority2348875518::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngRqedSpeedCtrlConditions2348875518 {
    ThsCtrlCndtnHsBnOptmzdTMnmzRpmO,
    StbltyOptmzdFrDrvlnEnggdAndOrI,
    StbltyOptmzdFrDrvlnDsnggdAndNnl,
    ThsSpdGvrnrGnSlctnIsAdjstdTPrvd,
    XValue(u64),
}

impl From<u64> for EngRqedSpeedCtrlConditions2348875518 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => EngRqedSpeedCtrlConditions2348875518::ThsCtrlCndtnHsBnOptmzdTMnmzRpmO,
            3 => EngRqedSpeedCtrlConditions2348875518::StbltyOptmzdFrDrvlnEnggdAndOrI,
            1 => EngRqedSpeedCtrlConditions2348875518::StbltyOptmzdFrDrvlnDsnggdAndNnl,
            0 => EngRqedSpeedCtrlConditions2348875518::ThsSpdGvrnrGnSlctnIsAdjstdTPrvd,
            value => EngRqedSpeedCtrlConditions2348875518::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOverrideCtrlMode2348875518 {
    SpdTrqLmtCtrlLmtSpdAndOrTrqBs,
    TrqCtrlCntrlTrqTInclddDsrdTrqVl,
    SpdCtrlGvrnSpdTInclddDsrdSpdVle,
    OvrrdDsbldDsblAnyExstngCtrlCmdd,
    XValue(u64),
}

impl From<u64> for EngOverrideCtrlMode2348875518 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngOverrideCtrlMode2348875518::SpdTrqLmtCtrlLmtSpdAndOrTrqBs,
            2 => EngOverrideCtrlMode2348875518::TrqCtrlCntrlTrqTInclddDsrdTrqVl,
            1 => EngOverrideCtrlMode2348875518::SpdCtrlGvrnSpdTInclddDsrdSpdVle,
            0 => EngOverrideCtrlMode2348875518::OvrrdDsbldDsblAnyExstngCtrlCmdd,
            value => EngOverrideCtrlMode2348875518::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransitRunStatus2566766846 {
    NotAvailable,
    ErrorCondition,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransitRunStatus2566766846 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransitRunStatus2566766846::NotAvailable,
            2 => TransitRunStatus2566766846::ErrorCondition,
            1 => TransitRunStatus2566766846::On,
            0 => TransitRunStatus2566766846::Off,
            value => TransitRunStatus2566766846::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleUseStatus2566766846 {
    NotAvailable,
    ErrorCondition,
    UnauthorizedUse,
    NormalUse,
    XValue(u64),
}

impl From<u64> for VehicleUseStatus2566766846 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VehicleUseStatus2566766846::NotAvailable,
            2 => VehicleUseStatus2566766846::ErrorCondition,
            1 => VehicleUseStatus2566766846::UnauthorizedUse,
            0 => VehicleUseStatus2566766846::NormalUse,
            value => VehicleUseStatus2566766846::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SilentAlarmStatus2566766846 {
    NotAvailable,
    ErrorCondition,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for SilentAlarmStatus2566766846 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SilentAlarmStatus2566766846::NotAvailable,
            2 => SilentAlarmStatus2566766846::ErrorCondition,
            1 => SilentAlarmStatus2566766846::On,
            0 => SilentAlarmStatus2566766846::Off,
            value => SilentAlarmStatus2566766846::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TypeOfPassengerCount2566766846 {
    BoardingPassenger,
    AbsPassengerCount,
    ExitingPassengerSecondPassengerStream,
    BoardingPassengerSecondPassengerStream,
    ExitingPassenger,
    XValue(u64),
}

impl From<u64> for TypeOfPassengerCount2566766846 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TypeOfPassengerCount2566766846::BoardingPassenger,
            0 => TypeOfPassengerCount2566766846::AbsPassengerCount,
            4 => TypeOfPassengerCount2566766846::ExitingPassengerSecondPassengerStream,
            3 => TypeOfPassengerCount2566766846::BoardingPassengerSecondPassengerStream,
            2 => TypeOfPassengerCount2566766846::ExitingPassenger,
            value => TypeOfPassengerCount2566766846::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FareboxAlarmIdentifier2566765310 {
    X1111111agencyDefined,
    X1100000reservedToBeAssigned,
    MaintenanceAccessOutOfService,
    MntnncAccssInSrvcCnsdrdAnAlrmCn,
    PaperCurrencyJamCleared,
    PaperCurrencyJam,
    PassTransferJamCleared,
    PassTransferJam,
    FareboxResetToAutomaticMode,
    FareboxSetInManualBypass,
    CoinDejamOperated,
    CardPassBoxFull,
    CardPassBoxLessThan75Full,
    CardPassBox75Full,
    CurrencyBoxFull,
    CurrencyBoxLessThan75Full,
    CurrencyBox75Full,
    CoinboxFull,
    Coinbox75Full,
    InsufficientFareAccepted,
    CshbxOpndInSrvcCnsdrdAnAlrmCndt,
    CashboxDoorTimeout,
    CashboxRestored,
    CashboxRemoved,
    ProbeCompleted,
    ProbeStarted,
    VoltageRestored,
    VoltageDropout,
    XValue(u64),
}

impl From<u64> for FareboxAlarmIdentifier2566765310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            97 => FareboxAlarmIdentifier2566765310::X1111111agencyDefined,
            26 => FareboxAlarmIdentifier2566765310::X1100000reservedToBeAssigned,
            25 => FareboxAlarmIdentifier2566765310::MaintenanceAccessOutOfService,
            24 => FareboxAlarmIdentifier2566765310::MntnncAccssInSrvcCnsdrdAnAlrmCn,
            23 => FareboxAlarmIdentifier2566765310::PaperCurrencyJamCleared,
            22 => FareboxAlarmIdentifier2566765310::PaperCurrencyJam,
            21 => FareboxAlarmIdentifier2566765310::PassTransferJamCleared,
            20 => FareboxAlarmIdentifier2566765310::PassTransferJam,
            19 => FareboxAlarmIdentifier2566765310::FareboxResetToAutomaticMode,
            18 => FareboxAlarmIdentifier2566765310::FareboxSetInManualBypass,
            17 => FareboxAlarmIdentifier2566765310::CoinDejamOperated,
            16 => FareboxAlarmIdentifier2566765310::CardPassBoxFull,
            15 => FareboxAlarmIdentifier2566765310::CardPassBoxLessThan75Full,
            14 => FareboxAlarmIdentifier2566765310::CardPassBox75Full,
            13 => FareboxAlarmIdentifier2566765310::CurrencyBoxFull,
            12 => FareboxAlarmIdentifier2566765310::CurrencyBoxLessThan75Full,
            11 => FareboxAlarmIdentifier2566765310::CurrencyBox75Full,
            10 => FareboxAlarmIdentifier2566765310::CoinboxFull,
            9 => FareboxAlarmIdentifier2566765310::Coinbox75Full,
            8 => FareboxAlarmIdentifier2566765310::InsufficientFareAccepted,
            7 => FareboxAlarmIdentifier2566765310::CshbxOpndInSrvcCnsdrdAnAlrmCndt,
            6 => FareboxAlarmIdentifier2566765310::CashboxDoorTimeout,
            5 => FareboxAlarmIdentifier2566765310::CashboxRestored,
            4 => FareboxAlarmIdentifier2566765310::CashboxRemoved,
            3 => FareboxAlarmIdentifier2566765310::ProbeCompleted,
            2 => FareboxAlarmIdentifier2566765310::ProbeStarted,
            1 => FareboxAlarmIdentifier2566765310::VoltageRestored,
            0 => FareboxAlarmIdentifier2566765310::VoltageDropout,
            value => FareboxAlarmIdentifier2566765310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FareboxEmergencyStatus2566765310 {
    NotAvailable,
    ErrorCondition,
    EmergencyCondition,
    NonemergencyCondition,
    XValue(u64),
}

impl From<u64> for FareboxEmergencyStatus2566765310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FareboxEmergencyStatus2566765310::NotAvailable,
            2 => FareboxEmergencyStatus2566765310::ErrorCondition,
            1 => FareboxEmergencyStatus2566765310::EmergencyCondition,
            0 => FareboxEmergencyStatus2566765310::NonemergencyCondition,
            value => FareboxEmergencyStatus2566765310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransferType2566765566 {
    X11111agencyDefined,
    Out,
    In,
    West,
    East,
    South,
    North,
    XValue(u64),
}

impl From<u64> for TransferType2566765566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => TransferType2566765566::X11111agencyDefined,
            5 => TransferType2566765566::Out,
            4 => TransferType2566765566::In,
            3 => TransferType2566765566::West,
            2 => TransferType2566765566::East,
            1 => TransferType2566765566::South,
            0 => TransferType2566765566::North,
            value => TransferType2566765566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TypeOfService2566765566 {
    X111agencyDefined,
    ExpressService,
    LocalService,
    XValue(u64),
}

impl From<u64> for TypeOfService2566765566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TypeOfService2566765566::X111agencyDefined,
            1 => TypeOfService2566765566::ExpressService,
            0 => TypeOfService2566765566::LocalService,
            value => TypeOfService2566765566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PaymentDetails2566765566 {
    X1111agencyDefined,
    X1010reservedForAssignment,
    Card,
    Pass,
    Ticket,
    Token,
    Cash,
    NotAnUpgrade,
    XValue(u64),
}

impl From<u64> for PaymentDetails2566765566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            11 => PaymentDetails2566765566::X1111agencyDefined,
            6 => PaymentDetails2566765566::X1010reservedForAssignment,
            5 => PaymentDetails2566765566::Card,
            4 => PaymentDetails2566765566::Pass,
            3 => PaymentDetails2566765566::Ticket,
            2 => PaymentDetails2566765566::Token,
            1 => PaymentDetails2566765566::Cash,
            0 => PaymentDetails2566765566::NotAnUpgrade,
            value => PaymentDetails2566765566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TypeOfFare2566765566 {
    X1111agencyDefined,
    X1010reservedForAssignment,
    PassB,
    PassA,
    TicketB,
    TicketA,
    TokenB,
    TokenA,
    CashNoDetail,
    XValue(u64),
}

impl From<u64> for TypeOfFare2566765566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            11 => TypeOfFare2566765566::X1111agencyDefined,
            7 => TypeOfFare2566765566::X1010reservedForAssignment,
            6 => TypeOfFare2566765566::PassB,
            5 => TypeOfFare2566765566::PassA,
            4 => TypeOfFare2566765566::TicketB,
            3 => TypeOfFare2566765566::TicketA,
            2 => TypeOfFare2566765566::TokenB,
            1 => TypeOfFare2566765566::TokenA,
            0 => TypeOfFare2566765566::CashNoDetail,
            value => TypeOfFare2566765566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransactionType2566765566 {
    X1111agencyDefined,
    X1011reservedForAssignment,
    Free,
    Transfer,
    Permit,
    Card,
    Pass,
    Ticket,
    Token,
    Cash,
    XValue(u64),
}

impl From<u64> for TransactionType2566765566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            12 => TransactionType2566765566::X1111agencyDefined,
            8 => TransactionType2566765566::X1011reservedForAssignment,
            7 => TransactionType2566765566::Free,
            6 => TransactionType2566765566::Transfer,
            5 => TransactionType2566765566::Permit,
            4 => TransactionType2566765566::Card,
            3 => TransactionType2566765566::Pass,
            2 => TransactionType2566765566::Ticket,
            1 => TransactionType2566765566::Token,
            0 => TransactionType2566765566::Cash,
            value => TransactionType2566765566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DriversFareboxSecurityCode2566765822 {
    X65535securityCode,
    FareboxIsInReportingStatus,
    XValue(u64),
}

impl From<u64> for DriversFareboxSecurityCode2566765822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => DriversFareboxSecurityCode2566765822::X65535securityCode,
            0 => DriversFareboxSecurityCode2566765822::FareboxIsInReportingStatus,
            value => DriversFareboxSecurityCode2566765822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TripDirection2566765822 {
    X1111agencyDefined,
    Out,
    In,
    West,
    East,
    South,
    North,
    XValue(u64),
}

impl From<u64> for TripDirection2566765822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => TripDirection2566765822::X1111agencyDefined,
            5 => TripDirection2566765822::Out,
            4 => TripDirection2566765822::In,
            3 => TripDirection2566765822::West,
            2 => TripDirection2566765822::East,
            1 => TripDirection2566765822::South,
            0 => TripDirection2566765822::North,
            value => TripDirection2566765822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TripStatus2566765822 {
    LayoverEnd,
    LayoverStart,
    TripEnd,
    TripStart,
    Undefined,
    XValue(u64),
}

impl From<u64> for TripStatus2566765822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => TripStatus2566765822::LayoverEnd,
            5 => TripStatus2566765822::LayoverStart,
            2 => TripStatus2566765822::TripEnd,
            1 => TripStatus2566765822::TripStart,
            7 => TripStatus2566765822::Undefined,
            value => TripStatus2566765822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FareboxServiceStatus2566765822 {
    NotAvailable,
    ErrorCondition,
    FareboxInService,
    FareboxOutOfService,
    XValue(u64),
}

impl From<u64> for FareboxServiceStatus2566765822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FareboxServiceStatus2566765822::NotAvailable,
            2 => FareboxServiceStatus2566765822::ErrorCondition,
            1 => FareboxServiceStatus2566765822::FareboxInService,
            0 => FareboxServiceStatus2566765822::FareboxOutOfService,
            value => FareboxServiceStatus2566765822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum StrobeActivationCtrlStatus2566766078 {
    NotAvailable,
    ErrorCondition,
    ActivateStrobe,
    DeactivateStrobe,
    XValue(u64),
}

impl From<u64> for StrobeActivationCtrlStatus2566766078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => StrobeActivationCtrlStatus2566766078::NotAvailable,
            2 => StrobeActivationCtrlStatus2566766078::ErrorCondition,
            1 => StrobeActivationCtrlStatus2566766078::ActivateStrobe,
            0 => StrobeActivationCtrlStatus2566766078::DeactivateStrobe,
            value => StrobeActivationCtrlStatus2566766078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransitDoorEnable2566766078 {
    NotAvailable,
    ErrorCondition,
    TrnstDrSttsWllOvrrdStrbActvtion,
    IgnoreTransitDoorStatus,
    XValue(u64),
}

impl From<u64> for TransitDoorEnable2566766078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransitDoorEnable2566766078::NotAvailable,
            2 => TransitDoorEnable2566766078::ErrorCondition,
            1 => TransitDoorEnable2566766078::TrnstDrSttsWllOvrrdStrbActvtion,
            0 => TransitDoorEnable2566766078::IgnoreTransitDoorStatus,
            value => TransitDoorEnable2566766078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PriorityOfRespSentByEmitter2566766078 {
    NotAvailable,
    ErrorCondition,
    To1101Reserved,
    PrrtyStByHardwareToHighPriority,
    PrrtyStByHrdwareToProbePriority,
    PrrtySetByHardwareToLowPriority,
    To1000Reserved,
    HighPriority,
    ProbePriority,
    LowPriority,
    Reserved,
    XValue(u64),
}

impl From<u64> for PriorityOfRespSentByEmitter2566766078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => PriorityOfRespSentByEmitter2566766078::NotAvailable,
            14 => PriorityOfRespSentByEmitter2566766078::ErrorCondition,
            12 => PriorityOfRespSentByEmitter2566766078::To1101Reserved,
            11 => PriorityOfRespSentByEmitter2566766078::PrrtyStByHardwareToHighPriority,
            10 => PriorityOfRespSentByEmitter2566766078::PrrtyStByHrdwareToProbePriority,
            9 => PriorityOfRespSentByEmitter2566766078::PrrtySetByHardwareToLowPriority,
            4 => PriorityOfRespSentByEmitter2566766078::To1000Reserved,
            3 => PriorityOfRespSentByEmitter2566766078::HighPriority,
            2 => PriorityOfRespSentByEmitter2566766078::ProbePriority,
            1 => PriorityOfRespSentByEmitter2566766078::LowPriority,
            0 => PriorityOfRespSentByEmitter2566766078::Reserved,
            value => PriorityOfRespSentByEmitter2566766078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum IntersectionPreemptionRqResp2566766078 {
    NotAvailable,
    ErrorCondition,
    MessageIsARespFromEmitter,
    MessageIsARqDirectedToEmitter,
    XValue(u64),
}

impl From<u64> for IntersectionPreemptionRqResp2566766078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => IntersectionPreemptionRqResp2566766078::NotAvailable,
            2 => IntersectionPreemptionRqResp2566766078::ErrorCondition,
            1 => IntersectionPreemptionRqResp2566766078::MessageIsARespFromEmitter,
            0 => IntersectionPreemptionRqResp2566766078::MessageIsARqDirectedToEmitter,
            value => IntersectionPreemptionRqResp2566766078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransitRouteIdUsage2566766078 {
    NotAvailable,
    ErrorCondition,
    TrnstRtIdUsedForInterleavedData,
    TrnstRtIdNtUsdFrInterleavedData,
    XValue(u64),
}

impl From<u64> for TransitRouteIdUsage2566766078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransitRouteIdUsage2566766078::NotAvailable,
            2 => TransitRouteIdUsage2566766078::ErrorCondition,
            1 => TransitRouteIdUsage2566766078::TrnstRtIdUsedForInterleavedData,
            0 => TransitRouteIdUsage2566766078::TrnstRtIdNtUsdFrInterleavedData,
            value => TransitRouteIdUsage2566766078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RangeCodeEnable2566766078 {
    NotAvailable,
    ErrorCondition,
    RangeCodeUsedForInterleavedData,
    RngCdeNotUsedForInterleavedData,
    XValue(u64),
}

impl From<u64> for RangeCodeEnable2566766078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RangeCodeEnable2566766078::NotAvailable,
            2 => RangeCodeEnable2566766078::ErrorCondition,
            1 => RangeCodeEnable2566766078::RangeCodeUsedForInterleavedData,
            0 => RangeCodeEnable2566766078::RngCdeNotUsedForInterleavedData,
            value => RangeCodeEnable2566766078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PcuSupplySolenoidStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for PcuSupplySolenoidStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PcuSupplySolenoidStatus2633922814::NotAvailable,
            2 => PcuSupplySolenoidStatus2633922814::Error,
            1 => PcuSupplySolenoidStatus2633922814::On,
            0 => PcuSupplySolenoidStatus2633922814::Off,
            value => PcuSupplySolenoidStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PcuCtrlSolenoidStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for PcuCtrlSolenoidStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PcuCtrlSolenoidStatus2633922814::NotAvailable,
            2 => PcuCtrlSolenoidStatus2633922814::Error,
            1 => PcuCtrlSolenoidStatus2633922814::On,
            0 => PcuCtrlSolenoidStatus2633922814::Off,
            value => PcuCtrlSolenoidStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PcuDeflateSolenoidStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for PcuDeflateSolenoidStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PcuDeflateSolenoidStatus2633922814::NotAvailable,
            2 => PcuDeflateSolenoidStatus2633922814::Error,
            1 => PcuDeflateSolenoidStatus2633922814::On,
            0 => PcuDeflateSolenoidStatus2633922814::Off,
            value => PcuDeflateSolenoidStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TirePressSupplySwitchStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TirePressSupplySwitchStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TirePressSupplySwitchStatus2633922814::NotAvailable,
            2 => TirePressSupplySwitchStatus2633922814::Error,
            1 => TirePressSupplySwitchStatus2633922814::On,
            0 => TirePressSupplySwitchStatus2633922814::Off,
            value => TirePressSupplySwitchStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PcuSteerSolenoidStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for PcuSteerSolenoidStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PcuSteerSolenoidStatus2633922814::NotAvailable,
            2 => PcuSteerSolenoidStatus2633922814::Error,
            1 => PcuSteerSolenoidStatus2633922814::On,
            0 => PcuSteerSolenoidStatus2633922814::Off,
            value => PcuSteerSolenoidStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PcuDriveSolenoidStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for PcuDriveSolenoidStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PcuDriveSolenoidStatus2633922814::NotAvailable,
            2 => PcuDriveSolenoidStatus2633922814::Error,
            1 => PcuDriveSolenoidStatus2633922814::On,
            0 => PcuDriveSolenoidStatus2633922814::Off,
            value => PcuDriveSolenoidStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DriveChannelMode2633922814 {
    NotAvailable,
    ErrorCondition,
    X1101reserved,
    PressCheck,
    DfltWtSystmWllDfltWhnCndtnsAllw,
    InfltWtSystmWllInfltWhnCndtnsAl,
    Confirm,
    Deflate,
    Inflate,
    Maintain,
    XValue(u64),
}

impl From<u64> for DriveChannelMode2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => DriveChannelMode2633922814::NotAvailable,
            14 => DriveChannelMode2633922814::ErrorCondition,
            7 => DriveChannelMode2633922814::X1101reserved,
            6 => DriveChannelMode2633922814::PressCheck,
            5 => DriveChannelMode2633922814::DfltWtSystmWllDfltWhnCndtnsAllw,
            4 => DriveChannelMode2633922814::InfltWtSystmWllInfltWhnCndtnsAl,
            3 => DriveChannelMode2633922814::Confirm,
            2 => DriveChannelMode2633922814::Deflate,
            1 => DriveChannelMode2633922814::Inflate,
            0 => DriveChannelMode2633922814::Maintain,
            value => DriveChannelMode2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerTagChannelMode2633922814 {
    NotAvailable,
    ErrorCondition,
    X1101reserved,
    PressCheck,
    DfltWtSystmWllDfltWhnCndtnsAllw,
    InfltWtSystmWllInfltWhnCndtnsAl,
    Confirm,
    Deflate,
    Inflate,
    Maintain,
    XValue(u64),
}

impl From<u64> for TrailerTagChannelMode2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TrailerTagChannelMode2633922814::NotAvailable,
            14 => TrailerTagChannelMode2633922814::ErrorCondition,
            7 => TrailerTagChannelMode2633922814::X1101reserved,
            6 => TrailerTagChannelMode2633922814::PressCheck,
            5 => TrailerTagChannelMode2633922814::DfltWtSystmWllDfltWhnCndtnsAllw,
            4 => TrailerTagChannelMode2633922814::InfltWtSystmWllInfltWhnCndtnsAl,
            3 => TrailerTagChannelMode2633922814::Confirm,
            2 => TrailerTagChannelMode2633922814::Deflate,
            1 => TrailerTagChannelMode2633922814::Inflate,
            0 => TrailerTagChannelMode2633922814::Maintain,
            value => TrailerTagChannelMode2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteerChannelMode2633922814 {
    NotAvailable,
    ErrorCondition,
    X1101reserved,
    PressCheck,
    DfltWtSystmWllDfltWhnCndtnsAllw,
    InfltWtSystmWllInfltWhnCndtnsAl,
    Confirm,
    Deflate,
    Inflate,
    Maintain,
    XValue(u64),
}

impl From<u64> for SteerChannelMode2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => SteerChannelMode2633922814::NotAvailable,
            14 => SteerChannelMode2633922814::ErrorCondition,
            7 => SteerChannelMode2633922814::X1101reserved,
            6 => SteerChannelMode2633922814::PressCheck,
            5 => SteerChannelMode2633922814::DfltWtSystmWllDfltWhnCndtnsAllw,
            4 => SteerChannelMode2633922814::InfltWtSystmWllInfltWhnCndtnsAl,
            3 => SteerChannelMode2633922814::Confirm,
            2 => SteerChannelMode2633922814::Deflate,
            1 => SteerChannelMode2633922814::Inflate,
            0 => SteerChannelMode2633922814::Maintain,
            value => SteerChannelMode2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PcuTrailerTagPushSolenoidStatus2633922814 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for PcuTrailerTagPushSolenoidStatus2633922814 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => PcuTrailerTagPushSolenoidStatus2633922814::NotAvailable,
            2 => PcuTrailerTagPushSolenoidStatus2633922814::Error,
            1 => PcuTrailerTagPushSolenoidStatus2633922814::On,
            0 => PcuTrailerTagPushSolenoidStatus2633922814::Off,
            value => PcuTrailerTagPushSolenoidStatus2633922814::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TirePressThresholdDetection2566845694 {
    NotAvailable,
    ErrorIndicator,
    NotDefined,
    ExtrmUndrPrssTrPrssrIsAtALvlWhr,
    UndrPrssTrPrssrIsLwrThnThPrssrD,
    NWrnngPrssTrPrssrIsWthnThThrshl,
    OvrPrssTrPrssrIsHghrThnThPrssrD,
    ExtrmOvrPrssTrPrssrIsAtALvlWhrT,
    XValue(u64),
}

impl From<u64> for TirePressThresholdDetection2566845694 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TirePressThresholdDetection2566845694::NotAvailable,
            6 => TirePressThresholdDetection2566845694::ErrorIndicator,
            5 => TirePressThresholdDetection2566845694::NotDefined,
            4 => TirePressThresholdDetection2566845694::ExtrmUndrPrssTrPrssrIsAtALvlWhr,
            3 => TirePressThresholdDetection2566845694::UndrPrssTrPrssrIsLwrThnThPrssrD,
            2 => TirePressThresholdDetection2566845694::NWrnngPrssTrPrssrIsWthnThThrshl,
            1 => TirePressThresholdDetection2566845694::OvrPrssTrPrssrIsHghrThnThPrssrD,
            0 => TirePressThresholdDetection2566845694::ExtrmOvrPrssTrPrssrIsAtALvlWhrT,
            value => TirePressThresholdDetection2566845694::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CtiWheelEndElectricalFault2566845694 {
    NotSupported,
    Error,
    NotDefined,
    Ok,
    XValue(u64),
}

impl From<u64> for CtiWheelEndElectricalFault2566845694 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CtiWheelEndElectricalFault2566845694::NotSupported,
            2 => CtiWheelEndElectricalFault2566845694::Error,
            1 => CtiWheelEndElectricalFault2566845694::NotDefined,
            0 => CtiWheelEndElectricalFault2566845694::Ok,
            value => CtiWheelEndElectricalFault2566845694::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CtiTireStatus2566845694 {
    NotSupported,
    Error,
    TireLeakDetected,
    Ok,
    XValue(u64),
}

impl From<u64> for CtiTireStatus2566845694 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CtiTireStatus2566845694::NotSupported,
            2 => CtiTireStatus2566845694::Error,
            1 => CtiTireStatus2566845694::TireLeakDetected,
            0 => CtiTireStatus2566845694::Ok,
            value => CtiTireStatus2566845694::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CtiWheelSensorStatus2566845694 {
    NotSupported,
    NotDefined,
    On,
    OffIsolatedFromCtiPressCtrl,
    XValue(u64),
}

impl From<u64> for CtiWheelSensorStatus2566845694 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CtiWheelSensorStatus2566845694::NotSupported,
            2 => CtiWheelSensorStatus2566845694::NotDefined,
            1 => CtiWheelSensorStatus2566845694::On,
            0 => CtiWheelSensorStatus2566845694::OffIsolatedFromCtiPressCtrl,
            value => CtiWheelSensorStatus2566845694::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DirectionIndicator2365484286 {
    NotAvailable,
    Error,
    Reverse,
    Forward,
    XValue(u64),
}

impl From<u64> for DirectionIndicator2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DirectionIndicator2365484286::NotAvailable,
            2 => DirectionIndicator2365484286::Error,
            1 => DirectionIndicator2365484286::Reverse,
            0 => DirectionIndicator2365484286::Forward,
            value => DirectionIndicator2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TachographPerformance2365484286 {
    NotAvailable,
    Error,
    PerformanceAnalysis,
    NormalPerformance,
    XValue(u64),
}

impl From<u64> for TachographPerformance2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TachographPerformance2365484286::NotAvailable,
            2 => TachographPerformance2365484286::Error,
            1 => TachographPerformance2365484286::PerformanceAnalysis,
            0 => TachographPerformance2365484286::NormalPerformance,
            value => TachographPerformance2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HandlingInformation2365484286 {
    NotAvailable,
    Error,
    HandlingInformation,
    NoHandlingInformation,
    XValue(u64),
}

impl From<u64> for HandlingInformation2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HandlingInformation2365484286::NotAvailable,
            2 => HandlingInformation2365484286::Error,
            1 => HandlingInformation2365484286::HandlingInformation,
            0 => HandlingInformation2365484286::NoHandlingInformation,
            value => HandlingInformation2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SystemEvent2365484286 {
    NotAvailable,
    Error,
    TachographEvent,
    NoTachographEvent,
    XValue(u64),
}

impl From<u64> for SystemEvent2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SystemEvent2365484286::NotAvailable,
            2 => SystemEvent2365484286::Error,
            1 => SystemEvent2365484286::TachographEvent,
            0 => SystemEvent2365484286::NoTachographEvent,
            value => SystemEvent2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DriverCardDriver22365484286 {
    NotAvailable,
    Error,
    DriverCardPresent,
    DriverCardNotPresent,
    XValue(u64),
}

impl From<u64> for DriverCardDriver22365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DriverCardDriver22365484286::NotAvailable,
            2 => DriverCardDriver22365484286::Error,
            1 => DriverCardDriver22365484286::DriverCardPresent,
            0 => DriverCardDriver22365484286::DriverCardNotPresent,
            value => DriverCardDriver22365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Driver2TimeRelatedStates2365484286 {
    NotAvailable,
    Error,
    Other,
    X1100reserved,
    Limit616HReached,
    Limit515MinBefore16H,
    Limit49HReached,
    Limit315MinBefore9H,
    Limit24HReached,
    Limit115MinBefore4H,
    NormalNoLimitsReached,
    XValue(u64),
}

impl From<u64> for Driver2TimeRelatedStates2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => Driver2TimeRelatedStates2365484286::NotAvailable,
            14 => Driver2TimeRelatedStates2365484286::Error,
            13 => Driver2TimeRelatedStates2365484286::Other,
            7 => Driver2TimeRelatedStates2365484286::X1100reserved,
            6 => Driver2TimeRelatedStates2365484286::Limit616HReached,
            5 => Driver2TimeRelatedStates2365484286::Limit515MinBefore16H,
            4 => Driver2TimeRelatedStates2365484286::Limit49HReached,
            3 => Driver2TimeRelatedStates2365484286::Limit315MinBefore9H,
            2 => Driver2TimeRelatedStates2365484286::Limit24HReached,
            1 => Driver2TimeRelatedStates2365484286::Limit115MinBefore4H,
            0 => Driver2TimeRelatedStates2365484286::NormalNoLimitsReached,
            value => Driver2TimeRelatedStates2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Overspeed2365484286 {
    NotAvailable,
    Error,
    Overspeed,
    NoOverspeed,
    XValue(u64),
}

impl From<u64> for Overspeed2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Overspeed2365484286::NotAvailable,
            2 => Overspeed2365484286::Error,
            1 => Overspeed2365484286::Overspeed,
            0 => Overspeed2365484286::NoOverspeed,
            value => Overspeed2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DriverCardDriver12365484286 {
    NotAvailable,
    Error,
    DriverCardPresent,
    DriverCardNotPresent,
    XValue(u64),
}

impl From<u64> for DriverCardDriver12365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DriverCardDriver12365484286::NotAvailable,
            2 => DriverCardDriver12365484286::Error,
            1 => DriverCardDriver12365484286::DriverCardPresent,
            0 => DriverCardDriver12365484286::DriverCardNotPresent,
            value => DriverCardDriver12365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Driver1TimeRelatedStates2365484286 {
    NotAvailable,
    Error,
    Other,
    X1100reserved,
    Limit616HReached,
    Limit515MinBefore16H,
    Limit49HReached,
    Limit315MinBefore9H,
    Limit24HReached,
    Limit115MinBefore4H,
    NormalNoLimitsReached,
    XValue(u64),
}

impl From<u64> for Driver1TimeRelatedStates2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => Driver1TimeRelatedStates2365484286::NotAvailable,
            14 => Driver1TimeRelatedStates2365484286::Error,
            13 => Driver1TimeRelatedStates2365484286::Other,
            7 => Driver1TimeRelatedStates2365484286::X1100reserved,
            6 => Driver1TimeRelatedStates2365484286::Limit616HReached,
            5 => Driver1TimeRelatedStates2365484286::Limit515MinBefore16H,
            4 => Driver1TimeRelatedStates2365484286::Limit49HReached,
            3 => Driver1TimeRelatedStates2365484286::Limit315MinBefore9H,
            2 => Driver1TimeRelatedStates2365484286::Limit24HReached,
            1 => Driver1TimeRelatedStates2365484286::Limit115MinBefore4H,
            0 => Driver1TimeRelatedStates2365484286::NormalNoLimitsReached,
            value => Driver1TimeRelatedStates2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DriveRecognize2365484286 {
    NotAvailable,
    Error,
    VehicleMotionDetected,
    VehicleMotionNotDetected,
    XValue(u64),
}

impl From<u64> for DriveRecognize2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DriveRecognize2365484286::NotAvailable,
            2 => DriveRecognize2365484286::Error,
            1 => DriveRecognize2365484286::VehicleMotionDetected,
            0 => DriveRecognize2365484286::VehicleMotionNotDetected,
            value => DriveRecognize2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Driver2WorkingState2365484286 {
    NotAvailable,
    Error,
    X101reserved,
    DriveBehindWheel,
    WrkLdngUnldingWorkingInAnOffice,
    DriverAvailableShortBreak,
    RestSleeping,
    XValue(u64),
}

impl From<u64> for Driver2WorkingState2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => Driver2WorkingState2365484286::NotAvailable,
            6 => Driver2WorkingState2365484286::Error,
            4 => Driver2WorkingState2365484286::X101reserved,
            3 => Driver2WorkingState2365484286::DriveBehindWheel,
            2 => Driver2WorkingState2365484286::WrkLdngUnldingWorkingInAnOffice,
            1 => Driver2WorkingState2365484286::DriverAvailableShortBreak,
            0 => Driver2WorkingState2365484286::RestSleeping,
            value => Driver2WorkingState2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Driver1WorkingState2365484286 {
    NotAvailable,
    Error,
    X101reserved,
    DriveBehindWheel,
    WrkLdngUnldingWorkingInAnOffice,
    DriverAvailableShortBreak,
    RestSleeping,
    XValue(u64),
}

impl From<u64> for Driver1WorkingState2365484286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => Driver1WorkingState2365484286::NotAvailable,
            6 => Driver1WorkingState2365484286::Error,
            4 => Driver1WorkingState2365484286::X101reserved,
            3 => Driver1WorkingState2365484286::DriveBehindWheel,
            2 => Driver1WorkingState2365484286::WrkLdngUnldingWorkingInAnOffice,
            1 => Driver1WorkingState2365484286::DriverAvailableShortBreak,
            0 => Driver1WorkingState2365484286::RestSleeping,
            value => Driver1WorkingState2365484286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrnsShftSlctorDisplayModeSwitch2348941054 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TrnsShftSlctorDisplayModeSwitch2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrnsShftSlctorDisplayModeSwitch2348941054::NotAvailable,
            2 => TrnsShftSlctorDisplayModeSwitch2348941054::Error,
            1 => TrnsShftSlctorDisplayModeSwitch2348941054::On,
            0 => TrnsShftSlctorDisplayModeSwitch2348941054::Off,
            value => TrnsShftSlctorDisplayModeSwitch2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode42348941054 {
    TakeNoAction,
    Reserved,
    Enable,
    Disable,
    XValue(u64),
}

impl From<u64> for TransMode42348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode42348941054::TakeNoAction,
            2 => TransMode42348941054::Reserved,
            1 => TransMode42348941054::Enable,
            0 => TransMode42348941054::Disable,
            value => TransMode42348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode32348941054 {
    TakeNoAction,
    Reserved,
    Enable,
    Disable,
    XValue(u64),
}

impl From<u64> for TransMode32348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode32348941054::TakeNoAction,
            2 => TransMode32348941054::Reserved,
            1 => TransMode32348941054::Enable,
            0 => TransMode32348941054::Disable,
            value => TransMode32348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode22348941054 {
    TakeNoAction,
    Reserved,
    Enable,
    Disable,
    XValue(u64),
}

impl From<u64> for TransMode22348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode22348941054::TakeNoAction,
            2 => TransMode22348941054::Reserved,
            1 => TransMode22348941054::Enable,
            0 => TransMode22348941054::Disable,
            value => TransMode22348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode12348941054 {
    TakeNoAction,
    Reserved,
    Enable,
    Disable,
    XValue(u64),
}

impl From<u64> for TransMode12348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode12348941054::TakeNoAction,
            2 => TransMode12348941054::Reserved,
            1 => TransMode12348941054::Enable,
            0 => TransMode12348941054::Disable,
            value => TransMode12348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqCentralRear2348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqCentralRear2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqCentralRear2348941054::Reserved,
            3 => DisengageDiffLockRqCentralRear2348941054::TakeNoAction,
            1 => DisengageDiffLockRqCentralRear2348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqCentralRear2348941054::EngageDiffLock,
            value => DisengageDiffLockRqCentralRear2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqCentralFront2348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqCentralFront2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqCentralFront2348941054::Reserved,
            3 => DisengageDiffLockRqCentralFront2348941054::TakeNoAction,
            1 => DisengageDiffLockRqCentralFront2348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqCentralFront2348941054::EngageDiffLock,
            value => DisengageDiffLockRqCentralFront2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqCentral2348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqCentral2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqCentral2348941054::Reserved,
            3 => DisengageDiffLockRqCentral2348941054::TakeNoAction,
            1 => DisengageDiffLockRqCentral2348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqCentral2348941054::EngageDiffLock,
            value => DisengageDiffLockRqCentral2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqRearAxle22348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqRearAxle22348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqRearAxle22348941054::Reserved,
            3 => DisengageDiffLockRqRearAxle22348941054::TakeNoAction,
            1 => DisengageDiffLockRqRearAxle22348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqRearAxle22348941054::EngageDiffLock,
            value => DisengageDiffLockRqRearAxle22348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqRearAxle12348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqRearAxle12348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqRearAxle12348941054::Reserved,
            3 => DisengageDiffLockRqRearAxle12348941054::TakeNoAction,
            1 => DisengageDiffLockRqRearAxle12348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqRearAxle12348941054::EngageDiffLock,
            value => DisengageDiffLockRqRearAxle12348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqFrontAxle22348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqFrontAxle22348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqFrontAxle22348941054::Reserved,
            3 => DisengageDiffLockRqFrontAxle22348941054::TakeNoAction,
            1 => DisengageDiffLockRqFrontAxle22348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqFrontAxle22348941054::EngageDiffLock,
            value => DisengageDiffLockRqFrontAxle22348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDiffLockRqFrontAxle12348941054 {
    Reserved,
    TakeNoAction,
    DisengageDiffLock,
    EngageDiffLock,
    XValue(u64),
}

impl From<u64> for DisengageDiffLockRqFrontAxle12348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDiffLockRqFrontAxle12348941054::Reserved,
            3 => DisengageDiffLockRqFrontAxle12348941054::TakeNoAction,
            1 => DisengageDiffLockRqFrontAxle12348941054::DisengageDiffLock,
            0 => DisengageDiffLockRqFrontAxle12348941054::EngageDiffLock,
            value => DisengageDiffLockRqFrontAxle12348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransRqedGear2348941054 {
    Reserved,
    NeutralSelectorPos,
    ReverseSelectorPos,
    PsUnknownAndOrNoButtonsPressed,
    PrssOfMmntryBttnTRslctCrrentPos,
    BtwnRvrsAndPrkShiftSelectorPoss,
    BtwnNtrlAndRvrsShftSelectorPoss,
    BtwnDrvAndNtrlShiftSelectorPoss,
    BtwnD1AndDriveShiftSelectorPoss,
    BetweenD2AndD1ShiftSelectorPoss,
    BetweenD3AndD2ShiftSelectorPoss,
    BetweenD4AndD3ShiftSelectorPoss,
    BetweenD5AndD4ShiftSelectorPoss,
    BetweenD6AndD5ShiftSelectorPoss,
    BetweenD7AndD6ShiftSelectorPoss,
    BtwnTwoForwardShiftSelectorPoss,
    BtwnTwoReverseShiftSelectorPoss,
    BetweenTwoShiftSelectorPoss,
    D77thFrwrdSlctrPsRfrncdFrmDrive,
    D66thFrwrdSlctrPsRfrncdFrmDrive,
    D55thFrwrdSlctrPsRfrncdFrmDrive,
    D44thFrwrdSlctrPsRfrncdFrmDrive,
    D33rdFrwrdSlctrPsRfrncdFrmDrive,
    D22ndFrwrdSlctrPsRfrncdFrmDrive,
    D11stFrwrdSlctrPsRfrncdFrmDrive,
    Downshift2GearsFromCurrentPos,
    Downshift1GearFromCurrentPos,
    Upshift2GearsFromCurrentPos,
    Upshift1GearFromCurrentPos,
    ForwardLowPos,
    ParkPos,
    ForwardDrivePos,
    HoldCurrentGear,
    XValue(u64),
}

impl From<u64> for TransRqedGear2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            61 => TransRqedGear2348941054::Reserved,
            222 => TransRqedGear2348941054::NeutralSelectorPos,
            223 => TransRqedGear2348941054::ReverseSelectorPos,
            224 => TransRqedGear2348941054::PsUnknownAndOrNoButtonsPressed,
            225 => TransRqedGear2348941054::PrssOfMmntryBttnTRslctCrrentPos,
            226 => TransRqedGear2348941054::BtwnRvrsAndPrkShiftSelectorPoss,
            227 => TransRqedGear2348941054::BtwnNtrlAndRvrsShftSelectorPoss,
            228 => TransRqedGear2348941054::BtwnDrvAndNtrlShiftSelectorPoss,
            229 => TransRqedGear2348941054::BtwnD1AndDriveShiftSelectorPoss,
            230 => TransRqedGear2348941054::BetweenD2AndD1ShiftSelectorPoss,
            231 => TransRqedGear2348941054::BetweenD3AndD2ShiftSelectorPoss,
            232 => TransRqedGear2348941054::BetweenD4AndD3ShiftSelectorPoss,
            233 => TransRqedGear2348941054::BetweenD5AndD4ShiftSelectorPoss,
            234 => TransRqedGear2348941054::BetweenD6AndD5ShiftSelectorPoss,
            235 => TransRqedGear2348941054::BetweenD7AndD6ShiftSelectorPoss,
            236 => TransRqedGear2348941054::BtwnTwoForwardShiftSelectorPoss,
            237 => TransRqedGear2348941054::BtwnTwoReverseShiftSelectorPoss,
            238 => TransRqedGear2348941054::BetweenTwoShiftSelectorPoss,
            239 => TransRqedGear2348941054::D77thFrwrdSlctrPsRfrncdFrmDrive,
            240 => TransRqedGear2348941054::D66thFrwrdSlctrPsRfrncdFrmDrive,
            241 => TransRqedGear2348941054::D55thFrwrdSlctrPsRfrncdFrmDrive,
            242 => TransRqedGear2348941054::D44thFrwrdSlctrPsRfrncdFrmDrive,
            243 => TransRqedGear2348941054::D33rdFrwrdSlctrPsRfrncdFrmDrive,
            244 => TransRqedGear2348941054::D22ndFrwrdSlctrPsRfrncdFrmDrive,
            245 => TransRqedGear2348941054::D11stFrwrdSlctrPsRfrncdFrmDrive,
            246 => TransRqedGear2348941054::Downshift2GearsFromCurrentPos,
            247 => TransRqedGear2348941054::Downshift1GearFromCurrentPos,
            248 => TransRqedGear2348941054::Upshift2GearsFromCurrentPos,
            249 => TransRqedGear2348941054::Upshift1GearFromCurrentPos,
            250 => TransRqedGear2348941054::ForwardLowPos,
            251 => TransRqedGear2348941054::ParkPos,
            252 => TransRqedGear2348941054::ForwardDrivePos,
            253 => TransRqedGear2348941054::HoldCurrentGear,
            value => TransRqedGear2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisengageDrivelineRq2348941054 {
    Reserved,
    TakeNoAction,
    DisengageDriveline,
    AllowDrivelineEngagement,
    XValue(u64),
}

impl From<u64> for DisengageDrivelineRq2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => DisengageDrivelineRq2348941054::Reserved,
            3 => DisengageDrivelineRq2348941054::TakeNoAction,
            1 => DisengageDrivelineRq2348941054::DisengageDriveline,
            0 => DisengageDrivelineRq2348941054::AllowDrivelineEngagement,
            value => DisengageDrivelineRq2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TorqueConverterLockupDisableRq2348941054 {
    Reserved,
    TakeNoAction,
    DisableTorqueConvertorLockup,
    AllowTorqueConvertorLockup,
    XValue(u64),
}

impl From<u64> for TorqueConverterLockupDisableRq2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TorqueConverterLockupDisableRq2348941054::Reserved,
            3 => TorqueConverterLockupDisableRq2348941054::TakeNoAction,
            1 => TorqueConverterLockupDisableRq2348941054::DisableTorqueConvertorLockup,
            0 => TorqueConverterLockupDisableRq2348941054::AllowTorqueConvertorLockup,
            value => TorqueConverterLockupDisableRq2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransGearShiftInhibitRq2348941054 {
    Reserved,
    TakeNoAction,
    GearShiftsAreInhibited,
    GearShiftsAreAllowed,
    XValue(u64),
}

impl From<u64> for TransGearShiftInhibitRq2348941054 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TransGearShiftInhibitRq2348941054::Reserved,
            3 => TransGearShiftInhibitRq2348941054::TakeNoAction,
            1 => TransGearShiftInhibitRq2348941054::GearShiftsAreInhibited,
            0 => TransGearShiftInhibitRq2348941054::GearShiftsAreAllowed,
            value => TransGearShiftInhibitRq2348941054::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOverspeedTest2566841598 {
    NotAvailable,
    Reserved,
    EngOverspeedTestActive,
    EngOverspeedTestNotActive,
    XValue(u64),
}

impl From<u64> for EngOverspeedTest2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngOverspeedTest2566841598::NotAvailable,
            2 => EngOverspeedTest2566841598::Reserved,
            1 => EngOverspeedTest2566841598::EngOverspeedTestActive,
            0 => EngOverspeedTest2566841598::EngOverspeedTestNotActive,
            value => EngOverspeedTest2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAirShutoffCmdStatus2566841598 {
    ArShtffDsbldNtAttmptngTShtffEng,
    NotAvailable,
    Reserved,
    ArShtffEnbldAttmptngTShtffEngAr,
    XValue(u64),
}

impl From<u64> for EngAirShutoffCmdStatus2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            0 => EngAirShutoffCmdStatus2566841598::ArShtffDsbldNtAttmptngTShtffEng,
            3 => EngAirShutoffCmdStatus2566841598::NotAvailable,
            2 => EngAirShutoffCmdStatus2566841598::Reserved,
            1 => EngAirShutoffCmdStatus2566841598::ArShtffEnbldAttmptngTShtffEngAr,
            value => EngAirShutoffCmdStatus2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAlarmOutputCmdStatus2566841598 {
    NotAvailable,
    Reserved,
    EngAlarmOutputCmdActive,
    EngAlarmOutputCmdNotActive,
    XValue(u64),
}

impl From<u64> for EngAlarmOutputCmdStatus2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngAlarmOutputCmdStatus2566841598::NotAvailable,
            2 => EngAlarmOutputCmdStatus2566841598::Reserved,
            1 => EngAlarmOutputCmdStatus2566841598::EngAlarmOutputCmdActive,
            0 => EngAlarmOutputCmdStatus2566841598::EngAlarmOutputCmdNotActive,
            value => EngAlarmOutputCmdStatus2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAlarmAcknowledge2566841598 {
    NotAvailable,
    Error,
    EngAlarmAcknowledgeActive,
    EngAlarmAcknowledgeNotActive,
    XValue(u64),
}

impl From<u64> for EngAlarmAcknowledge2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngAlarmAcknowledge2566841598::NotAvailable,
            2 => EngAlarmAcknowledge2566841598::Error,
            1 => EngAlarmAcknowledge2566841598::EngAlarmAcknowledgeActive,
            0 => EngAlarmAcknowledge2566841598::EngAlarmAcknowledgeNotActive,
            value => EngAlarmAcknowledge2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngProtectionSystemConfig2566841598 {
    NotAvailable,
    Error,
    EnabledInCalib,
    DisabledInCalib,
    XValue(u64),
}

impl From<u64> for EngProtectionSystemConfig2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngProtectionSystemConfig2566841598::NotAvailable,
            2 => EngProtectionSystemConfig2566841598::Error,
            1 => EngProtectionSystemConfig2566841598::EnabledInCalib,
            0 => EngProtectionSystemConfig2566841598::DisabledInCalib,
            value => EngProtectionSystemConfig2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngProtectionSystemTimerState2566841598 {
    NotAvailable,
    Error,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for EngProtectionSystemTimerState2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngProtectionSystemTimerState2566841598::NotAvailable,
            2 => EngProtectionSystemTimerState2566841598::Error,
            1 => EngProtectionSystemTimerState2566841598::Active,
            0 => EngProtectionSystemTimerState2566841598::Inactive,
            value => EngProtectionSystemTimerState2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPrtectionSystemTimerOverride2566841598 {
    NotAvailable,
    Error,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for EngPrtectionSystemTimerOverride2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPrtectionSystemTimerOverride2566841598::NotAvailable,
            2 => EngPrtectionSystemTimerOverride2566841598::Error,
            1 => EngPrtectionSystemTimerOverride2566841598::Active,
            0 => EngPrtectionSystemTimerOverride2566841598::Inactive,
            value => EngPrtectionSystemTimerOverride2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPrtctnSystmApprchingShutdown2566841598 {
    NotAvailable,
    Error,
    Approaching,
    NotApproaching,
    XValue(u64),
}

impl From<u64> for EngPrtctnSystmApprchingShutdown2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPrtctnSystmApprchingShutdown2566841598::NotAvailable,
            2 => EngPrtctnSystmApprchingShutdown2566841598::Error,
            1 => EngPrtctnSystmApprchingShutdown2566841598::Approaching,
            0 => EngPrtctnSystmApprchingShutdown2566841598::NotApproaching,
            value => EngPrtctnSystmApprchingShutdown2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPrtctionSystemHasShutdownEng2566841598 {
    No,
    XValue(u64),
}

impl From<u64> for EngPrtctionSystemHasShutdownEng2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            0 => EngPrtctionSystemHasShutdownEng2566841598::No,
            value => EngPrtctionSystemHasShutdownEng2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngWaitToStartLamp2566841598 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngWaitToStartLamp2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngWaitToStartLamp2566841598::NotAvailable,
            2 => EngWaitToStartLamp2566841598::Error,
            1 => EngWaitToStartLamp2566841598::On,
            0 => EngWaitToStartLamp2566841598::Off,
            value => EngWaitToStartLamp2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RefrigerantHighPressSwitch2566841598 {
    NotAvailable,
    Error,
    PrssTHghCmprssrCltchMyBDsngaged,
    PressNormal,
    XValue(u64),
}

impl From<u64> for RefrigerantHighPressSwitch2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RefrigerantHighPressSwitch2566841598::NotAvailable,
            2 => RefrigerantHighPressSwitch2566841598::Error,
            1 => RefrigerantHighPressSwitch2566841598::PrssTHghCmprssrCltchMyBDsngaged,
            0 => RefrigerantHighPressSwitch2566841598::PressNormal,
            value => RefrigerantHighPressSwitch2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RefrigerantLowPressSwitch2566841598 {
    NotAvailable,
    Error,
    PrssTLwCmprssrCltchMyBDsengaged,
    PressNormal,
    XValue(u64),
}

impl From<u64> for RefrigerantLowPressSwitch2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RefrigerantLowPressSwitch2566841598::NotAvailable,
            2 => RefrigerantLowPressSwitch2566841598::Error,
            1 => RefrigerantLowPressSwitch2566841598::PrssTLwCmprssrCltchMyBDsengaged,
            0 => RefrigerantLowPressSwitch2566841598::PressNormal,
            value => RefrigerantLowPressSwitch2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ACHighPressFanSwitch2566841598 {
    NotAvailable,
    Error,
    PressHighFanMayBeEngaged,
    PressNormal,
    XValue(u64),
}

impl From<u64> for ACHighPressFanSwitch2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ACHighPressFanSwitch2566841598::NotAvailable,
            2 => ACHighPressFanSwitch2566841598::Error,
            1 => ACHighPressFanSwitch2566841598::PressHighFanMayBeEngaged,
            0 => ACHighPressFanSwitch2566841598::PressNormal,
            value => ACHighPressFanSwitch2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleShutdownTimerFunction2566841598 {
    NotAvailable,
    Error,
    EnabledInCalib,
    DisabledInCalib,
    XValue(u64),
}

impl From<u64> for EngIdleShutdownTimerFunction2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngIdleShutdownTimerFunction2566841598::NotAvailable,
            2 => EngIdleShutdownTimerFunction2566841598::Error,
            1 => EngIdleShutdownTimerFunction2566841598::EnabledInCalib,
            0 => EngIdleShutdownTimerFunction2566841598::DisabledInCalib,
            value => EngIdleShutdownTimerFunction2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleShutdownTimerState2566841598 {
    NotAvailable,
    Error,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for EngIdleShutdownTimerState2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngIdleShutdownTimerState2566841598::NotAvailable,
            2 => EngIdleShutdownTimerState2566841598::Error,
            1 => EngIdleShutdownTimerState2566841598::Active,
            0 => EngIdleShutdownTimerState2566841598::Inactive,
            value => EngIdleShutdownTimerState2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleShutdownTimerOverride2566841598 {
    NotAvailable,
    Error,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for EngIdleShutdownTimerOverride2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngIdleShutdownTimerOverride2566841598::NotAvailable,
            2 => EngIdleShutdownTimerOverride2566841598::Error,
            1 => EngIdleShutdownTimerOverride2566841598::Active,
            0 => EngIdleShutdownTimerOverride2566841598::Inactive,
            value => EngIdleShutdownTimerOverride2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleShutdownDriverAlertMode2566841598 {
    NotAvailable,
    Error,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for EngIdleShutdownDriverAlertMode2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngIdleShutdownDriverAlertMode2566841598::NotAvailable,
            2 => EngIdleShutdownDriverAlertMode2566841598::Error,
            1 => EngIdleShutdownDriverAlertMode2566841598::Active,
            0 => EngIdleShutdownDriverAlertMode2566841598::Inactive,
            value => EngIdleShutdownDriverAlertMode2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleShutdownHasShutdownEng2566841598 {
    Yes,
    No,
    XValue(u64),
}

impl From<u64> for EngIdleShutdownHasShutdownEng2566841598 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngIdleShutdownHasShutdownEng2566841598::Yes,
            0 => EngIdleShutdownHasShutdownEng2566841598::No,
            value => EngIdleShutdownHasShutdownEng2566841598::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngBuildHoursReset2631859966 {
    Reserved,
    TakeNoAction,
    Reset,
    DoNotReset,
    XValue(u64),
}

impl From<u64> for EngBuildHoursReset2631859966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => EngBuildHoursReset2631859966::Reserved,
            3 => EngBuildHoursReset2631859966::TakeNoAction,
            1 => EngBuildHoursReset2631859966::Reset,
            0 => EngBuildHoursReset2631859966::DoNotReset,
            value => EngBuildHoursReset2631859966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TripGroup2Proprietary2631859966 {
    Reserved,
    NotApplicable,
    Reset,
    TakeNoAction,
    XValue(u64),
}

impl From<u64> for TripGroup2Proprietary2631859966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TripGroup2Proprietary2631859966::Reserved,
            3 => TripGroup2Proprietary2631859966::NotApplicable,
            1 => TripGroup2Proprietary2631859966::Reset,
            0 => TripGroup2Proprietary2631859966::TakeNoAction,
            value => TripGroup2Proprietary2631859966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TripGroup12631859966 {
    Reserved,
    NotApplicable,
    Reset,
    TakeNoAction,
    XValue(u64),
}

impl From<u64> for TripGroup12631859966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TripGroup12631859966::Reserved,
            3 => TripGroup12631859966::NotApplicable,
            1 => TripGroup12631859966::Reset,
            0 => TripGroup12631859966::TakeNoAction,
            value => TripGroup12631859966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetarderLocation2566840830 {
    NotAvailable,
    Other,
    X1101notDefined,
    Trailer,
    Driveline,
    TransOutput,
    TransInput,
    EngExhaustBrake,
    EngCompressionReleaseBrake,
    XValue(u64),
}

impl From<u64> for RetarderLocation2566840830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => RetarderLocation2566840830::NotAvailable,
            14 => RetarderLocation2566840830::Other,
            6 => RetarderLocation2566840830::X1101notDefined,
            5 => RetarderLocation2566840830::Trailer,
            4 => RetarderLocation2566840830::Driveline,
            3 => RetarderLocation2566840830::TransOutput,
            2 => RetarderLocation2566840830::TransInput,
            1 => RetarderLocation2566840830::EngExhaustBrake,
            0 => RetarderLocation2566840830::EngCompressionReleaseBrake,
            value => RetarderLocation2566840830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetarderType2566840830 {
    NotAvailable,
    Other,
    X1101notDefined,
    Exhaust,
    CompressionRelease,
    CooledFriction,
    Hyd,
    ElectricMagnetic,
    XValue(u64),
}

impl From<u64> for RetarderType2566840830 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => RetarderType2566840830::NotAvailable,
            14 => RetarderType2566840830::Other,
            5 => RetarderType2566840830::X1101notDefined,
            4 => RetarderType2566840830::Exhaust,
            3 => RetarderType2566840830::CompressionRelease,
            2 => RetarderType2566840830::CooledFriction,
            1 => RetarderType2566840830::Hyd,
            0 => RetarderType2566840830::ElectricMagnetic,
            value => RetarderType2566840830::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OperatorPtoMemorySelectSwitch2566844670 {
    NotAvailable,
    Error,
    PtoSetSpeedMemory2Selected,
    PtoSetSpeedMemory1Selected,
    XValue(u64),
}

impl From<u64> for OperatorPtoMemorySelectSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OperatorPtoMemorySelectSwitch2566844670::NotAvailable,
            2 => OperatorPtoMemorySelectSwitch2566844670::Error,
            1 => OperatorPtoMemorySelectSwitch2566844670::PtoSetSpeedMemory2Selected,
            0 => OperatorPtoMemorySelectSwitch2566844670::PtoSetSpeedMemory1Selected,
            value => OperatorPtoMemorySelectSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPtoAccelerateSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngPtoAccelerateSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPtoAccelerateSwitch2566844670::NotAvailable,
            2 => EngPtoAccelerateSwitch2566844670::Error,
            1 => EngPtoAccelerateSwitch2566844670::On,
            0 => EngPtoAccelerateSwitch2566844670::Off,
            value => EngPtoAccelerateSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPtoResumeSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngPtoResumeSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPtoResumeSwitch2566844670::NotAvailable,
            2 => EngPtoResumeSwitch2566844670::Error,
            1 => EngPtoResumeSwitch2566844670::On,
            0 => EngPtoResumeSwitch2566844670::Off,
            value => EngPtoResumeSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPtoCoastDecelerateSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngPtoCoastDecelerateSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPtoCoastDecelerateSwitch2566844670::NotAvailable,
            2 => EngPtoCoastDecelerateSwitch2566844670::Error,
            1 => EngPtoCoastDecelerateSwitch2566844670::On,
            0 => EngPtoCoastDecelerateSwitch2566844670::Off,
            value => EngPtoCoastDecelerateSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPtoSetSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngPtoSetSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPtoSetSwitch2566844670::NotAvailable,
            2 => EngPtoSetSwitch2566844670::Error,
            1 => EngPtoSetSwitch2566844670::On,
            0 => EngPtoSetSwitch2566844670::Off,
            value => EngPtoSetSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngRmtPtoVriableSpeedCtrlSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngRmtPtoVriableSpeedCtrlSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngRmtPtoVriableSpeedCtrlSwitch2566844670::NotAvailable,
            2 => EngRmtPtoVriableSpeedCtrlSwitch2566844670::Error,
            1 => EngRmtPtoVriableSpeedCtrlSwitch2566844670::On,
            0 => EngRmtPtoVriableSpeedCtrlSwitch2566844670::Off,
            value => EngRmtPtoVriableSpeedCtrlSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670::NotAvailable,
            2 => EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670::Error,
            1 => EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670::On,
            0 => EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670::Off,
            value => EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngPtoEnableSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngPtoEnableSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngPtoEnableSwitch2566844670::NotAvailable,
            2 => EngPtoEnableSwitch2566844670::Error,
            1 => EngPtoEnableSwitch2566844670::On,
            0 => EngPtoEnableSwitch2566844670::Off,
            value => EngPtoEnableSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670::NotAvailable,
            2 => RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670::Error,
            1 => RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670::On,
            0 => RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670::Off,
            value => RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxInputIgnoreSwitch2566844670 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for AuxInputIgnoreSwitch2566844670 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxInputIgnoreSwitch2566844670::NotAvailable,
            2 => AuxInputIgnoreSwitch2566844670::Error,
            1 => AuxInputIgnoreSwitch2566844670::On,
            0 => AuxInputIgnoreSwitch2566844670::Off,
            value => AuxInputIgnoreSwitch2566844670::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearWasherFunction2566770174 {
    NotAvailable,
    X110reserved,
    High,
    Medium,
    Low,
    Off,
    XValue(u64),
}

impl From<u64> for RearWasherFunction2566770174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => RearWasherFunction2566770174::NotAvailable,
            4 => RearWasherFunction2566770174::X110reserved,
            3 => RearWasherFunction2566770174::High,
            2 => RearWasherFunction2566770174::Medium,
            1 => RearWasherFunction2566770174::Low,
            0 => RearWasherFunction2566770174::Off,
            value => RearWasherFunction2566770174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontOperatorWasherSwitch2566770174 {
    NotAvailable,
    X110reserved,
    High,
    Medium,
    Low,
    Off,
    XValue(u64),
}

impl From<u64> for FrontOperatorWasherSwitch2566770174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => FrontOperatorWasherSwitch2566770174::NotAvailable,
            4 => FrontOperatorWasherSwitch2566770174::X110reserved,
            3 => FrontOperatorWasherSwitch2566770174::High,
            2 => FrontOperatorWasherSwitch2566770174::Medium,
            1 => FrontOperatorWasherSwitch2566770174::Low,
            0 => FrontOperatorWasherSwitch2566770174::Off,
            value => FrontOperatorWasherSwitch2566770174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontNonoperatorWasherSwitch2566770174 {
    NotAvailable,
    X110reserved,
    High,
    Medium,
    Low,
    Off,
    XValue(u64),
}

impl From<u64> for FrontNonoperatorWasherSwitch2566770174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => FrontNonoperatorWasherSwitch2566770174::NotAvailable,
            4 => FrontNonoperatorWasherSwitch2566770174::X110reserved,
            3 => FrontNonoperatorWasherSwitch2566770174::High,
            2 => FrontNonoperatorWasherSwitch2566770174::Medium,
            1 => FrontNonoperatorWasherSwitch2566770174::Low,
            0 => FrontNonoperatorWasherSwitch2566770174::Off,
            value => FrontNonoperatorWasherSwitch2566770174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearWiperSwitch2566770174 {
    X1110reserved,
    Mist,
    Delayed2,
    Delayed1,
    Medium,
    NotAvailable,
    High,
    Low,
    Off,
    XValue(u64),
}

impl From<u64> for RearWiperSwitch2566770174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => RearWiperSwitch2566770174::X1110reserved,
            6 => RearWiperSwitch2566770174::Mist,
            5 => RearWiperSwitch2566770174::Delayed2,
            4 => RearWiperSwitch2566770174::Delayed1,
            2 => RearWiperSwitch2566770174::Medium,
            15 => RearWiperSwitch2566770174::NotAvailable,
            3 => RearWiperSwitch2566770174::High,
            1 => RearWiperSwitch2566770174::Low,
            0 => RearWiperSwitch2566770174::Off,
            value => RearWiperSwitch2566770174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontOperatorWiperSwitch2566770174 {
    X1110reserved,
    Mist,
    Delayed2,
    Delayed1,
    Medium,
    NotAvailable,
    High,
    Low,
    Off,
    XValue(u64),
}

impl From<u64> for FrontOperatorWiperSwitch2566770174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => FrontOperatorWiperSwitch2566770174::X1110reserved,
            6 => FrontOperatorWiperSwitch2566770174::Mist,
            5 => FrontOperatorWiperSwitch2566770174::Delayed2,
            4 => FrontOperatorWiperSwitch2566770174::Delayed1,
            2 => FrontOperatorWiperSwitch2566770174::Medium,
            15 => FrontOperatorWiperSwitch2566770174::NotAvailable,
            3 => FrontOperatorWiperSwitch2566770174::High,
            1 => FrontOperatorWiperSwitch2566770174::Low,
            0 => FrontOperatorWiperSwitch2566770174::Off,
            value => FrontOperatorWiperSwitch2566770174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontNonoperatorWiperSwitch2566770174 {
    X1110reserved,
    Mist,
    Delayed2,
    Delayed1,
    Medium,
    NotAvailable,
    High,
    Low,
    Off,
    XValue(u64),
}

impl From<u64> for FrontNonoperatorWiperSwitch2566770174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => FrontNonoperatorWiperSwitch2566770174::X1110reserved,
            6 => FrontNonoperatorWiperSwitch2566770174::Mist,
            5 => FrontNonoperatorWiperSwitch2566770174::Delayed2,
            4 => FrontNonoperatorWiperSwitch2566770174::Delayed1,
            2 => FrontNonoperatorWiperSwitch2566770174::Medium,
            15 => FrontNonoperatorWiperSwitch2566770174::NotAvailable,
            3 => FrontNonoperatorWiperSwitch2566770174::High,
            1 => FrontNonoperatorWiperSwitch2566770174::Low,
            0 => FrontNonoperatorWiperSwitch2566770174::Off,
            value => FrontNonoperatorWiperSwitch2566770174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopAuxInputSelect2566769662 {
    NotAvailable,
    ErrorCondition,
    Thr1101OnOfAltDrpSttng1Thrgh13I,
    NormalDroopSettingIsSelected,
    XValue(u64),
}

impl From<u64> for EngAltDroopAuxInputSelect2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDroopAuxInputSelect2566769662::NotAvailable,
            14 => EngAltDroopAuxInputSelect2566769662::ErrorCondition,
            1 => EngAltDroopAuxInputSelect2566769662::Thr1101OnOfAltDrpSttng1Thrgh13I,
            0 => EngAltDroopAuxInputSelect2566769662::NormalDroopSettingIsSelected,
            value => EngAltDroopAuxInputSelect2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopRemoteAccelSelect2566769662 {
    NotAvailable,
    ErrorCondition,
    Thr1101OnOfAltDrpSttng1Thrgh13I,
    NormalDroopSettingIsSelected,
    XValue(u64),
}

impl From<u64> for EngAltDroopRemoteAccelSelect2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDroopRemoteAccelSelect2566769662::NotAvailable,
            14 => EngAltDroopRemoteAccelSelect2566769662::ErrorCondition,
            1 => EngAltDroopRemoteAccelSelect2566769662::Thr1101OnOfAltDrpSttng1Thrgh13I,
            0 => EngAltDroopRemoteAccelSelect2566769662::NormalDroopSettingIsSelected,
            value => EngAltDroopRemoteAccelSelect2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopAccel2Select2566769662 {
    NotAvailable,
    ErrorCondition,
    Thr1101OnOfAltDrpSttng1Thrgh13I,
    NormalDroopSettingIsSelected,
    XValue(u64),
}

impl From<u64> for EngAltDroopAccel2Select2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDroopAccel2Select2566769662::NotAvailable,
            14 => EngAltDroopAccel2Select2566769662::ErrorCondition,
            1 => EngAltDroopAccel2Select2566769662::Thr1101OnOfAltDrpSttng1Thrgh13I,
            0 => EngAltDroopAccel2Select2566769662::NormalDroopSettingIsSelected,
            value => EngAltDroopAccel2Select2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopAccel1Select2566769662 {
    NotAvailable,
    ErrorCondition,
    Thr1101OnOfAltDrpSttng1Thrgh13I,
    NormalDroopSettingIsSelected,
    XValue(u64),
}

impl From<u64> for EngAltDroopAccel1Select2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDroopAccel1Select2566769662::NotAvailable,
            14 => EngAltDroopAccel1Select2566769662::ErrorCondition,
            1 => EngAltDroopAccel1Select2566769662::Thr1101OnOfAltDrpSttng1Thrgh13I,
            0 => EngAltDroopAccel1Select2566769662::NormalDroopSettingIsSelected,
            value => EngAltDroopAccel1Select2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltRatingSelect2566769662 {
    IndctsThtAltPwrFling1IsSelected,
    IndctsThtMxPwrFuelingIsSelected,
    XValue(u64),
}

impl From<u64> for EngAltRatingSelect2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngAltRatingSelect2566769662::IndctsThtAltPwrFling1IsSelected,
            0 => EngAltRatingSelect2566769662::IndctsThtMxPwrFuelingIsSelected,
            value => EngAltRatingSelect2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltLowIdleSwitch2566769662 {
    NotAvailableUnused,
    Error,
    AltLowIdlePointIsSelected,
    DefaultLowIdlePointIsSelected,
    XValue(u64),
}

impl From<u64> for EngAltLowIdleSwitch2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngAltLowIdleSwitch2566769662::NotAvailableUnused,
            2 => EngAltLowIdleSwitch2566769662::Error,
            1 => EngAltLowIdleSwitch2566769662::AltLowIdlePointIsSelected,
            0 => EngAltLowIdleSwitch2566769662::DefaultLowIdlePointIsSelected,
            value => EngAltLowIdleSwitch2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngSynchronizationSwitch2566769662 {
    NotAvailableUnused,
    Error,
    FunctionalityIsEnabled,
    FunctionalityIsDisabled,
    XValue(u64),
}

impl From<u64> for EngSynchronizationSwitch2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngSynchronizationSwitch2566769662::NotAvailableUnused,
            2 => EngSynchronizationSwitch2566769662::Error,
            1 => EngSynchronizationSwitch2566769662::FunctionalityIsEnabled,
            0 => EngSynchronizationSwitch2566769662::FunctionalityIsDisabled,
            value => EngSynchronizationSwitch2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAuxGovernorSwitch2566769662 {
    ErrorCondition,
    AuxGovernorIsEnabled,
    AuxGovernorIsDisabled,
    XValue(u64),
}

impl From<u64> for EngAuxGovernorSwitch2566769662 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => EngAuxGovernorSwitch2566769662::ErrorCondition,
            1 => EngAuxGovernorSwitch2566769662::AuxGovernorIsEnabled,
            0 => EngAuxGovernorSwitch2566769662::AuxGovernorIsDisabled,
            value => EngAuxGovernorSwitch2566769662::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopAuxInputSelectState2566768638 {
    SaeReserved,
    Thr1101CtrlSttIsOnOfAltDrpSttng,
    CtrlStateIsNormalDroopSetting,
    XValue(u64),
}

impl From<u64> for EngAltDroopAuxInputSelectState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            14 => EngAltDroopAuxInputSelectState2566768638::SaeReserved,
            1 => EngAltDroopAuxInputSelectState2566768638::Thr1101CtrlSttIsOnOfAltDrpSttng,
            0 => EngAltDroopAuxInputSelectState2566768638::CtrlStateIsNormalDroopSetting,
            value => EngAltDroopAuxInputSelectState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDrpRemoteAccelSelectState2566768638 {
    NotAvailable,
    SaeReserved,
    Thr1101CtrlSttIsOnOfAltDrpSttng,
    CtrlStateIsNormalDroopSetting,
    XValue(u64),
}

impl From<u64> for EngAltDrpRemoteAccelSelectState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDrpRemoteAccelSelectState2566768638::NotAvailable,
            14 => EngAltDrpRemoteAccelSelectState2566768638::SaeReserved,
            1 => EngAltDrpRemoteAccelSelectState2566768638::Thr1101CtrlSttIsOnOfAltDrpSttng,
            0 => EngAltDrpRemoteAccelSelectState2566768638::CtrlStateIsNormalDroopSetting,
            value => EngAltDrpRemoteAccelSelectState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopAccel2SelectState2566768638 {
    NotAvailable,
    SaeReserved,
    Thr1101CtrlsSttIsOnOfAltDrpSttn,
    CtrlsStateIsNormalDroopSetting,
    XValue(u64),
}

impl From<u64> for EngAltDroopAccel2SelectState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDroopAccel2SelectState2566768638::NotAvailable,
            14 => EngAltDroopAccel2SelectState2566768638::SaeReserved,
            1 => EngAltDroopAccel2SelectState2566768638::Thr1101CtrlsSttIsOnOfAltDrpSttn,
            0 => EngAltDroopAccel2SelectState2566768638::CtrlsStateIsNormalDroopSetting,
            value => EngAltDroopAccel2SelectState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltDroopAccel1SelectState2566768638 {
    NotAvailable,
    SaeReserved,
    Thr1101CtrlSttIsOnOfAltDrpSttng,
    CtrlStateIsNormalDroopSetting,
    XValue(u64),
}

impl From<u64> for EngAltDroopAccel1SelectState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngAltDroopAccel1SelectState2566768638::NotAvailable,
            14 => EngAltDroopAccel1SelectState2566768638::SaeReserved,
            1 => EngAltDroopAccel1SelectState2566768638::Thr1101CtrlSttIsOnOfAltDrpSttng,
            0 => EngAltDroopAccel1SelectState2566768638::CtrlStateIsNormalDroopSetting,
            value => EngAltDroopAccel1SelectState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltRatingSelectState2566768638 {
    CtrlStateIsAltPowerFueling1,
    CtrlStateIsMaxPowerFueling,
    XValue(u64),
}

impl From<u64> for EngAltRatingSelectState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EngAltRatingSelectState2566768638::CtrlStateIsAltPowerFueling1,
            0 => EngAltRatingSelectState2566768638::CtrlStateIsMaxPowerFueling,
            value => EngAltRatingSelectState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAltLowIdleSelectState2566768638 {
    NotAvailable,
    SaeReserved,
    AltIdleState,
    NormalIdleState,
    XValue(u64),
}

impl From<u64> for EngAltLowIdleSelectState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngAltLowIdleSelectState2566768638::NotAvailable,
            2 => EngAltLowIdleSelectState2566768638::SaeReserved,
            1 => EngAltLowIdleSelectState2566768638::AltIdleState,
            0 => EngAltLowIdleSelectState2566768638::NormalIdleState,
            value => EngAltLowIdleSelectState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngMultiUnitSyncState2566768638 {
    NotAvailable,
    SaeReserved,
    CtrlStateIsFunctionalityEnabled,
    CtrlStteIsFunctionalityDisabled,
    XValue(u64),
}

impl From<u64> for EngMultiUnitSyncState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngMultiUnitSyncState2566768638::NotAvailable,
            2 => EngMultiUnitSyncState2566768638::SaeReserved,
            1 => EngMultiUnitSyncState2566768638::CtrlStateIsFunctionalityEnabled,
            0 => EngMultiUnitSyncState2566768638::CtrlStteIsFunctionalityDisabled,
            value => EngMultiUnitSyncState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAuxGovernorState2566768638 {
    NotAvailable,
    SaeReserved,
    CtrlStateIsAuxGovernorEnabled,
    CtrlStateIsAuxGovernorDisabled,
    XValue(u64),
}

impl From<u64> for EngAuxGovernorState2566768638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngAuxGovernorState2566768638::NotAvailable,
            2 => EngAuxGovernorState2566768638::SaeReserved,
            1 => EngAuxGovernorState2566768638::CtrlStateIsAuxGovernorEnabled,
            0 => EngAuxGovernorState2566768638::CtrlStateIsAuxGovernorDisabled,
            value => EngAuxGovernorState2566768638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HighLowBeamSwitch2365443326 {
    NotAvailable,
    Error,
    HighBeamSelected,
    LowBeamSelected,
    XValue(u64),
}

impl From<u64> for HighLowBeamSwitch2365443326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HighLowBeamSwitch2365443326::NotAvailable,
            2 => HighLowBeamSwitch2365443326::Error,
            1 => HighLowBeamSwitch2365443326::HighBeamSelected,
            0 => HighLowBeamSwitch2365443326::LowBeamSelected,
            value => HighLowBeamSwitch2365443326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HazardLightSwitch2365443326 {
    NotAvailable,
    Error,
    HazardLampsToBeFlashing,
    HazardLampsToBeOff,
    XValue(u64),
}

impl From<u64> for HazardLightSwitch2365443326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HazardLightSwitch2365443326::NotAvailable,
            2 => HazardLightSwitch2365443326::Error,
            1 => HazardLightSwitch2365443326::HazardLampsToBeFlashing,
            0 => HazardLightSwitch2365443326::HazardLampsToBeOff,
            value => HazardLightSwitch2365443326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TurnSignalSwitch2365443326 {
    RightTurnToBeFlashing,
    NotAvailable,
    Error,
    X1101reserved,
    LeftTurnToBeFlashing,
    NoTurnBeingSignaled,
    XValue(u64),
}

impl From<u64> for TurnSignalSwitch2365443326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => TurnSignalSwitch2365443326::RightTurnToBeFlashing,
            15 => TurnSignalSwitch2365443326::NotAvailable,
            14 => TurnSignalSwitch2365443326::Error,
            3 => TurnSignalSwitch2365443326::X1101reserved,
            1 => TurnSignalSwitch2365443326::LeftTurnToBeFlashing,
            0 => TurnSignalSwitch2365443326::NoTurnBeingSignaled,
            value => TurnSignalSwitch2365443326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MainLightSwitch2365443326 {
    X1101reserved,
    DlydOffPsByWhchThOprtrSlctsThtA,
    X0111reserved,
    HdlghtOnPsByWhchThOprtrSlctsTht,
    NotAvailable,
    Error,
    HdlghtAndPrkOnPsByWhchThOprtrSl,
    PrkOnPsByWhchThOprtrSlctsThtThP,
    OffPsByWhchThOprtrSlctsThtNnOfT,
    XValue(u64),
}

impl From<u64> for MainLightSwitch2365443326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            9 => MainLightSwitch2365443326::X1101reserved,
            8 => MainLightSwitch2365443326::DlydOffPsByWhchThOprtrSlctsThtA,
            4 => MainLightSwitch2365443326::X0111reserved,
            2 => MainLightSwitch2365443326::HdlghtOnPsByWhchThOprtrSlctsTht,
            15 => MainLightSwitch2365443326::NotAvailable,
            14 => MainLightSwitch2365443326::Error,
            3 => MainLightSwitch2365443326::HdlghtAndPrkOnPsByWhchThOprtrSl,
            1 => MainLightSwitch2365443326::PrkOnPsByWhchThOprtrSlctsThtThP,
            0 => MainLightSwitch2365443326::OffPsByWhchThOprtrSlctsThtNnOfT,
            value => MainLightSwitch2365443326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum WorkLightSwitch2365443326 {
    X1101reserved,
    WrkLghtCmbntn4OnPsByWhchThOprtr,
    WrkLghtCmbntn2OnPsByWhchThOprtr,
    NotAvailable,
    Error,
    WrkLghtCmbntn3OnPsByWhchThOprtr,
    WrkLghtCmbntn1OnPsByWhchThOprtr,
    OffPsByWhchThOprtrSlctsThtNnOfT,
    XValue(u64),
}

impl From<u64> for WorkLightSwitch2365443326 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            5 => WorkLightSwitch2365443326::X1101reserved,
            4 => WorkLightSwitch2365443326::WrkLghtCmbntn4OnPsByWhchThOprtr,
            2 => WorkLightSwitch2365443326::WrkLghtCmbntn2OnPsByWhchThOprtr,
            15 => WorkLightSwitch2365443326::NotAvailable,
            14 => WorkLightSwitch2365443326::Error,
            3 => WorkLightSwitch2365443326::WrkLghtCmbntn3OnPsByWhchThOprtr,
            1 => WorkLightSwitch2365443326::WrkLghtCmbntn1OnPsByWhchThOprtr,
            0 => WorkLightSwitch2365443326::OffPsByWhchThOprtrSlctsThtNnOfT,
            value => WorkLightSwitch2365443326::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BlackOutWorkLampSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for BlackOutWorkLampSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BlackOutWorkLampSelect2566802686::NotSupported,
            2 => BlackOutWorkLampSelect2566802686::Reserved,
            1 => BlackOutWorkLampSelect2566802686::On,
            0 => BlackOutWorkLampSelect2566802686::Off,
            value => BlackOutWorkLampSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NightVisionIlluminatorSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for NightVisionIlluminatorSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => NightVisionIlluminatorSelect2566802686::NotSupported,
            2 => NightVisionIlluminatorSelect2566802686::Reserved,
            1 => NightVisionIlluminatorSelect2566802686::On,
            0 => NightVisionIlluminatorSelect2566802686::Off,
            value => NightVisionIlluminatorSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BlackOutBrakeStopLampSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for BlackOutBrakeStopLampSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BlackOutBrakeStopLampSelect2566802686::NotSupported,
            2 => BlackOutBrakeStopLampSelect2566802686::Reserved,
            1 => BlackOutBrakeStopLampSelect2566802686::On,
            0 => BlackOutBrakeStopLampSelect2566802686::Off,
            value => BlackOutBrakeStopLampSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ConvoyDrivingLampSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for ConvoyDrivingLampSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ConvoyDrivingLampSelect2566802686::NotSupported,
            2 => ConvoyDrivingLampSelect2566802686::Reserved,
            1 => ConvoyDrivingLampSelect2566802686::On,
            0 => ConvoyDrivingLampSelect2566802686::Off,
            value => ConvoyDrivingLampSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ConvoyLampSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for ConvoyLampSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ConvoyLampSelect2566802686::NotSupported,
            2 => ConvoyLampSelect2566802686::Reserved,
            1 => ConvoyLampSelect2566802686::On,
            0 => ConvoyLampSelect2566802686::Off,
            value => ConvoyLampSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontBlackOutMarkerLampSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for FrontBlackOutMarkerLampSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FrontBlackOutMarkerLampSelect2566802686::NotSupported,
            2 => FrontBlackOutMarkerLampSelect2566802686::Reserved,
            1 => FrontBlackOutMarkerLampSelect2566802686::On,
            0 => FrontBlackOutMarkerLampSelect2566802686::Off,
            value => FrontBlackOutMarkerLampSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearBlackOutMarkerSelect2566802686 {
    NotSupported,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for RearBlackOutMarkerSelect2566802686 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RearBlackOutMarkerSelect2566802686::NotSupported,
            2 => RearBlackOutMarkerSelect2566802686::Reserved,
            1 => RearBlackOutMarkerSelect2566802686::On,
            0 => RearBlackOutMarkerSelect2566802686::Off,
            value => RearBlackOutMarkerSelect2566802686::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SlowVesselModeStatus2566774014 {
    TakeNoAction,
    Reserved,
    SlowVesselModeIsActive,
    SlowVesselModeIsOff,
    XValue(u64),
}

impl From<u64> for SlowVesselModeStatus2566774014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SlowVesselModeStatus2566774014::TakeNoAction,
            2 => SlowVesselModeStatus2566774014::Reserved,
            1 => SlowVesselModeStatus2566774014::SlowVesselModeIsActive,
            0 => SlowVesselModeStatus2566774014::SlowVesselModeIsOff,
            value => SlowVesselModeStatus2566774014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrollingModeStatus2566774014 {
    TakeNoAction,
    Reserved,
    TrollingModeIsActive,
    TrollingModeIsOff,
    XValue(u64),
}

impl From<u64> for TrollingModeStatus2566774014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrollingModeStatus2566774014::TakeNoAction,
            2 => TrollingModeStatus2566774014::Reserved,
            1 => TrollingModeStatus2566774014::TrollingModeIsActive,
            0 => TrollingModeStatus2566774014::TrollingModeIsOff,
            value => TrollingModeStatus2566774014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngThrttlSynchrnztionModeStatus2566774014 {
    TakeNoAction,
    X1110reserved,
    SynchronizedMaster,
    SynchronizedStarboard,
    SynchronizedPort,
    SynchronizedCenter,
    NotSynchronized,
    XValue(u64),
}

impl From<u64> for EngThrttlSynchrnztionModeStatus2566774014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngThrttlSynchrnztionModeStatus2566774014::TakeNoAction,
            5 => EngThrttlSynchrnztionModeStatus2566774014::X1110reserved,
            4 => EngThrttlSynchrnztionModeStatus2566774014::SynchronizedMaster,
            3 => EngThrttlSynchrnztionModeStatus2566774014::SynchronizedStarboard,
            2 => EngThrttlSynchrnztionModeStatus2566774014::SynchronizedPort,
            1 => EngThrttlSynchrnztionModeStatus2566774014::SynchronizedCenter,
            0 => EngThrttlSynchrnztionModeStatus2566774014::NotSynchronized,
            value => EngThrttlSynchrnztionModeStatus2566774014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DisplayDeadbands2432595710 {
    NotAvailable,
    X1110reserved,
    Wide24mm,
    Standard12mm,
    Narrow45mm,
    XValue(u64),
}

impl From<u64> for DisplayDeadbands2432595710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => DisplayDeadbands2432595710::NotAvailable,
            3 => DisplayDeadbands2432595710::X1110reserved,
            2 => DisplayDeadbands2432595710::Wide24mm,
            1 => DisplayDeadbands2432595710::Standard12mm,
            0 => DisplayDeadbands2432595710::Narrow45mm,
            value => DisplayDeadbands2432595710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LedPatternCtrl2432595710 {
    NotAvailable,
    X1110reserved,
    X7channel,
    Offset,
    X5channel,
    XValue(u64),
}

impl From<u64> for LedPatternCtrl2432595710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LedPatternCtrl2432595710::NotAvailable,
            3 => LedPatternCtrl2432595710::X1110reserved,
            2 => LedPatternCtrl2432595710::X7channel,
            1 => LedPatternCtrl2432595710::Offset,
            0 => LedPatternCtrl2432595710::X5channel,
            value => LedPatternCtrl2432595710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LedDisplayDeadbandCtrl2432595710 {
    NotAvailableNotApplicable,
    X1110reserved,
    X1mm,
    X5mm,
    X24mm,
    X12mm,
    X45mm,
    XValue(u64),
}

impl From<u64> for LedDisplayDeadbandCtrl2432595710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LedDisplayDeadbandCtrl2432595710::NotAvailableNotApplicable,
            5 => LedDisplayDeadbandCtrl2432595710::X1110reserved,
            4 => LedDisplayDeadbandCtrl2432595710::X1mm,
            3 => LedDisplayDeadbandCtrl2432595710::X5mm,
            2 => LedDisplayDeadbandCtrl2432595710::X24mm,
            1 => LedDisplayDeadbandCtrl2432595710::X12mm,
            0 => LedDisplayDeadbandCtrl2432595710::X45mm,
            value => LedDisplayDeadbandCtrl2432595710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LedDisplayModeCtrl2432595710 {
    NotAvailableNotApplicable,
    X1110reserved,
    CenterOnGradeDisplayMode2,
    OffsetOnGradeDisplayMode,
    CenterOnGradeDisplayMode1,
    XValue(u64),
}

impl From<u64> for LedDisplayModeCtrl2432595710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LedDisplayModeCtrl2432595710::NotAvailableNotApplicable,
            3 => LedDisplayModeCtrl2432595710::X1110reserved,
            2 => LedDisplayModeCtrl2432595710::CenterOnGradeDisplayMode2,
            1 => LedDisplayModeCtrl2432595710::OffsetOnGradeDisplayMode,
            0 => LedDisplayModeCtrl2432595710::CenterOnGradeDisplayMode1,
            value => LedDisplayModeCtrl2432595710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LedDisplayData12432595710 {
    LowCoarseLedOn,
    LowFineLedOn,
    OngradeLedOn,
    HighFineLedOn,
    HighCoarseLedOn,
    XValue(u64),
}

impl From<u64> for LedDisplayData12432595710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            32 => LedDisplayData12432595710::LowCoarseLedOn,
            16 => LedDisplayData12432595710::LowFineLedOn,
            8 => LedDisplayData12432595710::OngradeLedOn,
            4 => LedDisplayData12432595710::HighFineLedOn,
            2 => LedDisplayData12432595710::HighCoarseLedOn,
            value => LedDisplayData12432595710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaserReceiverType2365486590 {
    LinearLaserReceiver,
    Reserved,
    XValue(u64),
}

impl From<u64> for LaserReceiverType2365486590 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => LaserReceiverType2365486590::LinearLaserReceiver,
            0 => LaserReceiverType2365486590::Reserved,
            value => LaserReceiverType2365486590::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaserTracerInformation2365485566 {
    Curb,
    Stringline,
    PreviousPass,
    ValidTarget,
    LaserIsReady,
    LaserPowerIsOn,
    XValue(u64),
}

impl From<u64> for LaserTracerInformation2365485566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            32 => LaserTracerInformation2365485566::Curb,
            16 => LaserTracerInformation2365485566::Stringline,
            8 => LaserTracerInformation2365485566::PreviousPass,
            4 => LaserTracerInformation2365485566::ValidTarget,
            2 => LaserTracerInformation2365485566::LaserIsReady,
            1 => LaserTracerInformation2365485566::LaserPowerIsOn,
            value => LaserTracerInformation2365485566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LedDisplayData22365485566 {
    RightLedOn,
    LeftLedOn,
    DownLedOn,
    UpLedOn,
    OngradeCledOn,
    OngradeBledOn,
    OngradeAledOn,
    XValue(u64),
}

impl From<u64> for LedDisplayData22365485566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            64 => LedDisplayData22365485566::RightLedOn,
            32 => LedDisplayData22365485566::LeftLedOn,
            16 => LedDisplayData22365485566::DownLedOn,
            8 => LedDisplayData22365485566::UpLedOn,
            4 => LedDisplayData22365485566::OngradeCledOn,
            2 => LedDisplayData22365485566::OngradeBledOn,
            1 => LedDisplayData22365485566::OngradeAledOn,
            value => LedDisplayData22365485566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SdshftDsrdBldOffsetOperatorCtrl2364542462 {
    NotInstalled,
    ErrorIndicator,
    X1101reserved,
    AutomaticOperatorCtrlRq,
    ManualOperatorCtrlRq,
    NoOperatorCtrlRq,
    MomentaryOperatorCtrlRq,
    XValue(u64),
}

impl From<u64> for SdshftDsrdBldOffsetOperatorCtrl2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => SdshftDsrdBldOffsetOperatorCtrl2364542462::NotInstalled,
            14 => SdshftDsrdBldOffsetOperatorCtrl2364542462::ErrorIndicator,
            4 => SdshftDsrdBldOffsetOperatorCtrl2364542462::X1101reserved,
            3 => SdshftDsrdBldOffsetOperatorCtrl2364542462::AutomaticOperatorCtrlRq,
            2 => SdshftDsrdBldOffsetOperatorCtrl2364542462::ManualOperatorCtrlRq,
            0 => SdshftDsrdBldOffsetOperatorCtrl2364542462::NoOperatorCtrlRq,
            1 => SdshftDsrdBldOffsetOperatorCtrl2364542462::MomentaryOperatorCtrlRq,
            value => SdshftDsrdBldOffsetOperatorCtrl2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SdshftBldCtrlMdeOperatorControl2364542462 {
    NotInstalled,
    ErrorIndicator,
    X1101reserved,
    AutomaticOperatorCtrlRq,
    ManualOperatorCtrlRq,
    NoOperatorCtrlRq,
    OprtrCtrlSttCnBRdInTwWysOnMthdU,
    XValue(u64),
}

impl From<u64> for SdshftBldCtrlMdeOperatorControl2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => SdshftBldCtrlMdeOperatorControl2364542462::NotInstalled,
            14 => SdshftBldCtrlMdeOperatorControl2364542462::ErrorIndicator,
            4 => SdshftBldCtrlMdeOperatorControl2364542462::X1101reserved,
            3 => SdshftBldCtrlMdeOperatorControl2364542462::AutomaticOperatorCtrlRq,
            2 => SdshftBldCtrlMdeOperatorControl2364542462::ManualOperatorCtrlRq,
            0 => SdshftBldCtrlMdeOperatorControl2364542462::NoOperatorCtrlRq,
            1 => SdshftBldCtrlMdeOperatorControl2364542462::OprtrCtrlSttCnBRdInTwWysOnMthdU,
            value => SdshftBldCtrlMdeOperatorControl2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RghtDsrdBladeOffsetOperatorCtrl2364542462 {
    NotInstalled,
    ErrorIndicator,
    X1101reserved,
    DecrementOperatorCtrlRq,
    NoOperatorCtrlRq,
    OprtrCtrlSttCnBRdInTwWysOnMthdU,
    XValue(u64),
}

impl From<u64> for RghtDsrdBladeOffsetOperatorCtrl2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => RghtDsrdBladeOffsetOperatorCtrl2364542462::NotInstalled,
            14 => RghtDsrdBladeOffsetOperatorCtrl2364542462::ErrorIndicator,
            3 => RghtDsrdBladeOffsetOperatorCtrl2364542462::X1101reserved,
            2 => RghtDsrdBladeOffsetOperatorCtrl2364542462::DecrementOperatorCtrlRq,
            0 => RghtDsrdBladeOffsetOperatorCtrl2364542462::NoOperatorCtrlRq,
            1 => RghtDsrdBladeOffsetOperatorCtrl2364542462::OprtrCtrlSttCnBRdInTwWysOnMthdU,
            value => RghtDsrdBladeOffsetOperatorCtrl2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RghtBldeCtrlModeOperatorControl2364542462 {
    NotInstalled,
    ErrorIndicator,
    AutomaticOperatorCtrlRq,
    ManualOperatorCtrlRq,
    NoChange,
    MomentaryOperatorCtrlRq,
    XValue(u64),
}

impl From<u64> for RghtBldeCtrlModeOperatorControl2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => RghtBldeCtrlModeOperatorControl2364542462::NotInstalled,
            14 => RghtBldeCtrlModeOperatorControl2364542462::ErrorIndicator,
            3 => RghtBldeCtrlModeOperatorControl2364542462::AutomaticOperatorCtrlRq,
            2 => RghtBldeCtrlModeOperatorControl2364542462::ManualOperatorCtrlRq,
            0 => RghtBldeCtrlModeOperatorControl2364542462::NoChange,
            1 => RghtBldeCtrlModeOperatorControl2364542462::MomentaryOperatorCtrlRq,
            value => RghtBldeCtrlModeOperatorControl2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LftDsredBladeOffsetOperatorCtrl2364542462 {
    NotInstalled,
    ErrorIndicator,
    X1101reserved,
    DecrementOperatorCtrlRq,
    NoOperatorCtrlRq,
    OprtrCtrlSttCnBRdInTwWysOnMthdU,
    XValue(u64),
}

impl From<u64> for LftDsredBladeOffsetOperatorCtrl2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LftDsredBladeOffsetOperatorCtrl2364542462::NotInstalled,
            14 => LftDsredBladeOffsetOperatorCtrl2364542462::ErrorIndicator,
            3 => LftDsredBladeOffsetOperatorCtrl2364542462::X1101reserved,
            2 => LftDsredBladeOffsetOperatorCtrl2364542462::DecrementOperatorCtrlRq,
            0 => LftDsredBladeOffsetOperatorCtrl2364542462::NoOperatorCtrlRq,
            1 => LftDsredBladeOffsetOperatorCtrl2364542462::OprtrCtrlSttCnBRdInTwWysOnMthdU,
            value => LftDsredBladeOffsetOperatorCtrl2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LftBladeCtrlModeOperatorControl2364542462 {
    NotInstalled,
    ErrorIndicator,
    X1101reserved,
    AutomaticOperatorCtrlRq,
    ManualOperatorCtrlRq,
    NoChange,
    OprtrCtrlSttCnBRdInTwWysOnMthdU,
    XValue(u64),
}

impl From<u64> for LftBladeCtrlModeOperatorControl2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LftBladeCtrlModeOperatorControl2364542462::NotInstalled,
            14 => LftBladeCtrlModeOperatorControl2364542462::ErrorIndicator,
            12 => LftBladeCtrlModeOperatorControl2364542462::X1101reserved,
            3 => LftBladeCtrlModeOperatorControl2364542462::AutomaticOperatorCtrlRq,
            2 => LftBladeCtrlModeOperatorControl2364542462::ManualOperatorCtrlRq,
            0 => LftBladeCtrlModeOperatorControl2364542462::NoChange,
            1 => LftBladeCtrlModeOperatorControl2364542462::OprtrCtrlSttCnBRdInTwWysOnMthdU,
            value => LftBladeCtrlModeOperatorControl2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BladeAutoModeCmd2364542462 {
    NotSupported,
    ErrorIndicator,
    AutoNotAllowed,
    SrvcMdAtAllwdOnlyDrngSrvceModes,
    SspndAtTmprarilySuspendAutoMode,
    ActvtyAllwsAtMstDtctOprtrBfrAtA,
    AutoAllowed,
    XValue(u64),
}

impl From<u64> for BladeAutoModeCmd2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => BladeAutoModeCmd2364542462::NotSupported,
            14 => BladeAutoModeCmd2364542462::ErrorIndicator,
            4 => BladeAutoModeCmd2364542462::AutoNotAllowed,
            3 => BladeAutoModeCmd2364542462::SrvcMdAtAllwdOnlyDrngSrvceModes,
            2 => BladeAutoModeCmd2364542462::SspndAtTmprarilySuspendAutoMode,
            1 => BladeAutoModeCmd2364542462::ActvtyAllwsAtMstDtctOprtrBfrAtA,
            0 => BladeAutoModeCmd2364542462::AutoAllowed,
            value => BladeAutoModeCmd2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DesiredGradeOffsetSwitch2364542462 {
    NotInstalled,
    ErrorIndicator,
    DecrementButtonPressed,
    NoButtonPressed,
    SwtchSttCnBRdInTwWysOnMthdUssTh,
    XValue(u64),
}

impl From<u64> for DesiredGradeOffsetSwitch2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => DesiredGradeOffsetSwitch2364542462::NotInstalled,
            14 => DesiredGradeOffsetSwitch2364542462::ErrorIndicator,
            2 => DesiredGradeOffsetSwitch2364542462::DecrementButtonPressed,
            0 => DesiredGradeOffsetSwitch2364542462::NoButtonPressed,
            1 => DesiredGradeOffsetSwitch2364542462::SwtchSttCnBRdInTwWysOnMthdUssTh,
            value => DesiredGradeOffsetSwitch2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BladeCtrlModeSwitch2364542462 {
    NotInstalled,
    ErrorIndicator,
    AutomaticButtonPressed,
    ManualButtonPressed,
    NoButtonPressed,
    SwtchSttCnBRdInTwWysOnMthdUssTh,
    XValue(u64),
}

impl From<u64> for BladeCtrlModeSwitch2364542462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => BladeCtrlModeSwitch2364542462::NotInstalled,
            14 => BladeCtrlModeSwitch2364542462::ErrorIndicator,
            3 => BladeCtrlModeSwitch2364542462::AutomaticButtonPressed,
            2 => BladeCtrlModeSwitch2364542462::ManualButtonPressed,
            0 => BladeCtrlModeSwitch2364542462::NoButtonPressed,
            1 => BladeCtrlModeSwitch2364542462::SwtchSttCnBRdInTwWysOnMthdUssTh,
            value => BladeCtrlModeSwitch2364542462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontWheelDriveActuatorStatus2633883646 {
    NotAvailable,
    Error,
    FrontWheelDriveActuatorEngaged,
    FrntWhelDriveActuatorNotEngaged,
    XValue(u64),
}

impl From<u64> for FrontWheelDriveActuatorStatus2633883646 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FrontWheelDriveActuatorStatus2633883646::NotAvailable,
            2 => FrontWheelDriveActuatorStatus2633883646::Error,
            1 => FrontWheelDriveActuatorStatus2633883646::FrontWheelDriveActuatorEngaged,
            0 => FrontWheelDriveActuatorStatus2633883646::FrntWhelDriveActuatorNotEngaged,
            value => FrontWheelDriveActuatorStatus2633883646::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FmSstandardRqsSupported2633880062 {
    DontCare,
    Reserved,
    OnRqModeIsSupported,
    OnRqModeIsNotSupported,
    XValue(u64),
}

impl From<u64> for FmSstandardRqsSupported2633880062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FmSstandardRqsSupported2633880062::DontCare,
            2 => FmSstandardRqsSupported2633880062::Reserved,
            1 => FmSstandardRqsSupported2633880062::OnRqModeIsSupported,
            0 => FmSstandardRqsSupported2633880062::OnRqModeIsNotSupported,
            value => FmSstandardRqsSupported2633880062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FmSstandardDiagnosticsSupported2633880062 {
    DontCare,
    Reserved,
    DiagnosticsIsSupported,
    DiagnosticsIsNotSupported,
    XValue(u64),
}

impl From<u64> for FmSstandardDiagnosticsSupported2633880062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FmSstandardDiagnosticsSupported2633880062::DontCare,
            2 => FmSstandardDiagnosticsSupported2633880062::Reserved,
            1 => FmSstandardDiagnosticsSupported2633880062::DiagnosticsIsSupported,
            0 => FmSstandardDiagnosticsSupported2633880062::DiagnosticsIsNotSupported,
            value => FmSstandardDiagnosticsSupported2633880062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LnDprtureIndicationEnableStatus2566806526 {
    NotUsed,
    Reserved,
    LaneDepartureIndicationEnabled,
    LaneDepartureIndicationDisabled,
    XValue(u64),
}

impl From<u64> for LnDprtureIndicationEnableStatus2566806526 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LnDprtureIndicationEnableStatus2566806526::NotUsed,
            2 => LnDprtureIndicationEnableStatus2566806526::Reserved,
            1 => LnDprtureIndicationEnableStatus2566806526::LaneDepartureIndicationEnabled,
            0 => LnDprtureIndicationEnableStatus2566806526::LaneDepartureIndicationDisabled,
            value => LnDprtureIndicationEnableStatus2566806526::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaneTrackingStatusLeftSide2566806526 {
    DontCareTakeNoAction,
    Reserved,
    TrackingLeftSide,
    NotTrackingLeftSide,
    XValue(u64),
}

impl From<u64> for LaneTrackingStatusLeftSide2566806526 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LaneTrackingStatusLeftSide2566806526::DontCareTakeNoAction,
            2 => LaneTrackingStatusLeftSide2566806526::Reserved,
            1 => LaneTrackingStatusLeftSide2566806526::TrackingLeftSide,
            0 => LaneTrackingStatusLeftSide2566806526::NotTrackingLeftSide,
            value => LaneTrackingStatusLeftSide2566806526::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaneTrackingStatusRightSide2566806526 {
    DontCareTakeNoAction,
    Reserved,
    TrackingRightSide,
    NotTrackingRightSide,
    XValue(u64),
}

impl From<u64> for LaneTrackingStatusRightSide2566806526 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LaneTrackingStatusRightSide2566806526::DontCareTakeNoAction,
            2 => LaneTrackingStatusRightSide2566806526::Reserved,
            1 => LaneTrackingStatusRightSide2566806526::TrackingRightSide,
            0 => LaneTrackingStatusRightSide2566806526::NotTrackingRightSide,
            value => LaneTrackingStatusRightSide2566806526::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaneDepartureImminentLeftSide2431649790 {
    NotUsed,
    Reserved,
    Imminent,
    NotImminent,
    XValue(u64),
}

impl From<u64> for LaneDepartureImminentLeftSide2431649790 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LaneDepartureImminentLeftSide2431649790::NotUsed,
            2 => LaneDepartureImminentLeftSide2431649790::Reserved,
            1 => LaneDepartureImminentLeftSide2431649790::Imminent,
            0 => LaneDepartureImminentLeftSide2431649790::NotImminent,
            value => LaneDepartureImminentLeftSide2431649790::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LaneDepartureImminentRightSide2431649790 {
    NotUsed,
    Reserved,
    Imminent,
    NotImminent,
    XValue(u64),
}

impl From<u64> for LaneDepartureImminentRightSide2431649790 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LaneDepartureImminentRightSide2431649790::NotUsed,
            2 => LaneDepartureImminentRightSide2431649790::Reserved,
            1 => LaneDepartureImminentRightSide2431649790::Imminent,
            0 => LaneDepartureImminentRightSide2431649790::NotImminent,
            value => LaneDepartureImminentRightSide2431649790::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngFuelLeakage22633929214 {
    NotAvailable,
    Error,
    LeakageDetected,
    NoLeakageDetected,
    XValue(u64),
}

impl From<u64> for EngFuelLeakage22633929214 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngFuelLeakage22633929214::NotAvailable,
            2 => EngFuelLeakage22633929214::Error,
            1 => EngFuelLeakage22633929214::LeakageDetected,
            0 => EngFuelLeakage22633929214::NoLeakageDetected,
            value => EngFuelLeakage22633929214::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngFuelLeakage12633929214 {
    NotAvailable,
    Error,
    LeakageDetected,
    NoLeakageDetected,
    XValue(u64),
}

impl From<u64> for EngFuelLeakage12633929214 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngFuelLeakage12633929214::NotAvailable,
            2 => EngFuelLeakage12633929214::Error,
            1 => EngFuelLeakage12633929214::LeakageDetected,
            0 => EngFuelLeakage12633929214::NoLeakageDetected,
            value => EngFuelLeakage12633929214::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FanDriveState2566831614 {
    NotAvailable,
    Other,
    EngBrake,
    Timer,
    ACSystem,
    TransRetarder,
    ManualCtrl,
    NotDefined,
    DefaultOperation,
    ExcessiveHydOilTemp,
    ExcessiveTransOilTemp,
    ExcessiveEngCoolantTemp,
    ExcessiveEngOilTemp,
    ExcessiveEngAirTemp,
    EngSystemGeneral,
    FanOff,
    XValue(u64),
}

impl From<u64> for FanDriveState2566831614 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => FanDriveState2566831614::NotAvailable,
            14 => FanDriveState2566831614::Other,
            13 => FanDriveState2566831614::EngBrake,
            12 => FanDriveState2566831614::Timer,
            11 => FanDriveState2566831614::ACSystem,
            10 => FanDriveState2566831614::TransRetarder,
            9 => FanDriveState2566831614::ManualCtrl,
            8 => FanDriveState2566831614::NotDefined,
            7 => FanDriveState2566831614::DefaultOperation,
            6 => FanDriveState2566831614::ExcessiveHydOilTemp,
            5 => FanDriveState2566831614::ExcessiveTransOilTemp,
            4 => FanDriveState2566831614::ExcessiveEngCoolantTemp,
            3 => FanDriveState2566831614::ExcessiveEngOilTemp,
            2 => FanDriveState2566831614::ExcessiveEngAirTemp,
            1 => FanDriveState2566831614::EngSystemGeneral,
            0 => FanDriveState2566831614::FanOff,
            value => FanDriveState2566831614::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngTorqueLimitFeature2566820094 {
    NotAvailable,
    X110reserved,
    CurrentTorqueRating,
    PreviousTorqueRating,
    FirstTorqueRating,
    HighestTorqueRating,
    Reserved,
    XValue(u64),
}

impl From<u64> for EngTorqueLimitFeature2566820094 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => EngTorqueLimitFeature2566820094::NotAvailable,
            5 => EngTorqueLimitFeature2566820094::X110reserved,
            4 => EngTorqueLimitFeature2566820094::CurrentTorqueRating,
            3 => EngTorqueLimitFeature2566820094::PreviousTorqueRating,
            2 => EngTorqueLimitFeature2566820094::FirstTorqueRating,
            1 => EngTorqueLimitFeature2566820094::HighestTorqueRating,
            0 => EngTorqueLimitFeature2566820094::Reserved,
            value => EngTorqueLimitFeature2566820094::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TorqueLimitingFeatureStatus2566820094 {
    NotAvailable,
    Error,
    Enabled,
    Disabled,
    XValue(u64),
}

impl From<u64> for TorqueLimitingFeatureStatus2566820094 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TorqueLimitingFeatureStatus2566820094::NotAvailable,
            2 => TorqueLimitingFeatureStatus2566820094::Error,
            1 => TorqueLimitingFeatureStatus2566820094::Enabled,
            0 => TorqueLimitingFeatureStatus2566820094::Disabled,
            value => TorqueLimitingFeatureStatus2566820094::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode1Indicator2566802174 {
    NotAvailable,
    Error,
    TransMode1Active,
    TransMode1NotActive,
    XValue(u64),
}

impl From<u64> for TransMode1Indicator2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode1Indicator2566802174::NotAvailable,
            2 => TransMode1Indicator2566802174::Error,
            1 => TransMode1Indicator2566802174::TransMode1Active,
            0 => TransMode1Indicator2566802174::TransMode1NotActive,
            value => TransMode1Indicator2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode2Indicator2566802174 {
    NotAvailable,
    Error,
    TransMode2Active,
    TransMode2NotActive,
    XValue(u64),
}

impl From<u64> for TransMode2Indicator2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode2Indicator2566802174::NotAvailable,
            2 => TransMode2Indicator2566802174::Error,
            1 => TransMode2Indicator2566802174::TransMode2Active,
            0 => TransMode2Indicator2566802174::TransMode2NotActive,
            value => TransMode2Indicator2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode3Indicator2566802174 {
    NotAvailable,
    Error,
    TransMode3Active,
    TransMode3NotActive,
    XValue(u64),
}

impl From<u64> for TransMode3Indicator2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode3Indicator2566802174::NotAvailable,
            2 => TransMode3Indicator2566802174::Error,
            1 => TransMode3Indicator2566802174::TransMode3Active,
            0 => TransMode3Indicator2566802174::TransMode3NotActive,
            value => TransMode3Indicator2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransMode4Indicator2566802174 {
    NotAvailable,
    Error,
    TransMode4Active,
    TransMode4NotActive,
    XValue(u64),
}

impl From<u64> for TransMode4Indicator2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransMode4Indicator2566802174::NotAvailable,
            2 => TransMode4Indicator2566802174::Error,
            1 => TransMode4Indicator2566802174::TransMode4Active,
            0 => TransMode4Indicator2566802174::TransMode4NotActive,
            value => TransMode4Indicator2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransShiftInhibitIndicator2566802174 {
    TakeNoAction,
    Reserved,
    ActiveShiftIsInhibited,
    InactiveShiftIsNotInhibited,
    XValue(u64),
}

impl From<u64> for TransShiftInhibitIndicator2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransShiftInhibitIndicator2566802174::TakeNoAction,
            2 => TransShiftInhibitIndicator2566802174::Reserved,
            1 => TransShiftInhibitIndicator2566802174::ActiveShiftIsInhibited,
            0 => TransShiftInhibitIndicator2566802174::InactiveShiftIsNotInhibited,
            value => TransShiftInhibitIndicator2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransEngCrankEnable2566802174 {
    NotAvailable,
    Error,
    CrnkngEnbldEngCrnkngIsAllwdByTr,
    CrnkngDsbldEngCrnkngIsPrhbtdByT,
    XValue(u64),
}

impl From<u64> for TransEngCrankEnable2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransEngCrankEnable2566802174::NotAvailable,
            2 => TransEngCrankEnable2566802174::Error,
            1 => TransEngCrankEnable2566802174::CrnkngEnbldEngCrnkngIsAllwdByTr,
            0 => TransEngCrankEnable2566802174::CrnkngDsbldEngCrnkngIsPrhbtdByT,
            value => TransEngCrankEnable2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ActiveShiftConsoleIndicator2566802174 {
    NotAvailable,
    Reserved,
    SecondShiftConsoleIsActive,
    PrimaryShiftConsoleIsActive,
    XValue(u64),
}

impl From<u64> for ActiveShiftConsoleIndicator2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ActiveShiftConsoleIndicator2566802174::NotAvailable,
            2 => ActiveShiftConsoleIndicator2566802174::Reserved,
            1 => ActiveShiftConsoleIndicator2566802174::SecondShiftConsoleIsActive,
            0 => ActiveShiftConsoleIndicator2566802174::PrimaryShiftConsoleIsActive,
            value => ActiveShiftConsoleIndicator2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransReadyForBrakeRelease2566802174 {
    DontCare,
    Reserved,
    TransReadyForBrakeRelease,
    TransNotReadyForBrakeRelease,
    XValue(u64),
}

impl From<u64> for TransReadyForBrakeRelease2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransReadyForBrakeRelease2566802174::DontCare,
            2 => TransReadyForBrakeRelease2566802174::Reserved,
            1 => TransReadyForBrakeRelease2566802174::TransReadyForBrakeRelease,
            0 => TransReadyForBrakeRelease2566802174::TransNotReadyForBrakeRelease,
            value => TransReadyForBrakeRelease2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransRqedRangeDisplayFlashState2566802174 {
    TakeNoAction,
    Reserved,
    ActvTrnsRqdRngDsplyShldBFlshing,
    InctvTrnsRqdRngDsplyShldNtBFlsh,
    XValue(u64),
}

impl From<u64> for TransRqedRangeDisplayFlashState2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransRqedRangeDisplayFlashState2566802174::TakeNoAction,
            2 => TransRqedRangeDisplayFlashState2566802174::Reserved,
            1 => TransRqedRangeDisplayFlashState2566802174::ActvTrnsRqdRngDsplyShldBFlshing,
            0 => TransRqedRangeDisplayFlashState2566802174::InctvTrnsRqdRngDsplyShldNtBFlsh,
            value => TransRqedRangeDisplayFlashState2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransRqedRangeDisplayBlankState2566802174 {
    TakeNoAction,
    Reserved,
    ActvTrnsRqdRngDsplyShldBBlanked,
    InctvTrnsRqdRngDsplyShldNtBBlnk,
    XValue(u64),
}

impl From<u64> for TransRqedRangeDisplayBlankState2566802174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransRqedRangeDisplayBlankState2566802174::TakeNoAction,
            2 => TransRqedRangeDisplayBlankState2566802174::Reserved,
            1 => TransRqedRangeDisplayBlankState2566802174::ActvTrnsRqdRngDsplyShldBBlanked,
            0 => TransRqedRangeDisplayBlankState2566802174::InctvTrnsRqdRngDsplyShldNtBBlnk,
            value => TransRqedRangeDisplayBlankState2566802174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransForwardDirectionSwitch2633942014 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransForwardDirectionSwitch2633942014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransForwardDirectionSwitch2633942014::NotAvailable,
            2 => TransForwardDirectionSwitch2633942014::Error,
            1 => TransForwardDirectionSwitch2633942014::On,
            0 => TransForwardDirectionSwitch2633942014::Off,
            value => TransForwardDirectionSwitch2633942014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransNeutralSwitch2633942014 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransNeutralSwitch2633942014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransNeutralSwitch2633942014::NotAvailable,
            2 => TransNeutralSwitch2633942014::Error,
            1 => TransNeutralSwitch2633942014::On,
            0 => TransNeutralSwitch2633942014::Off,
            value => TransNeutralSwitch2633942014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransReverseDirectionSwitch2633942014 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransReverseDirectionSwitch2633942014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransReverseDirectionSwitch2633942014::NotAvailable,
            2 => TransReverseDirectionSwitch2633942014::Error,
            1 => TransReverseDirectionSwitch2633942014::On,
            0 => TransReverseDirectionSwitch2633942014::Off,
            value => TransReverseDirectionSwitch2633942014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransLowRangeSenseSwitch2633942014 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransLowRangeSenseSwitch2633942014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransLowRangeSenseSwitch2633942014::NotAvailable,
            2 => TransLowRangeSenseSwitch2633942014::Error,
            1 => TransLowRangeSenseSwitch2633942014::On,
            0 => TransLowRangeSenseSwitch2633942014::Off,
            value => TransLowRangeSenseSwitch2633942014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransHighRangeSenseSwitch2633942014 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransHighRangeSenseSwitch2633942014 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransHighRangeSenseSwitch2633942014::NotAvailable,
            2 => TransHighRangeSenseSwitch2633942014::Error,
            1 => TransHighRangeSenseSwitch2633942014::On,
            0 => TransHighRangeSenseSwitch2633942014::Off,
            value => TransHighRangeSenseSwitch2633942014::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransInertiaBrakeActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransInertiaBrakeActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransInertiaBrakeActuator2633943038::NotAvailable,
            2 => TransInertiaBrakeActuator2633943038::Error,
            1 => TransInertiaBrakeActuator2633943038::On,
            0 => TransInertiaBrakeActuator2633943038::Off,
            value => TransInertiaBrakeActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransDefuelActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransDefuelActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransDefuelActuator2633943038::NotAvailable,
            2 => TransDefuelActuator2633943038::Error,
            1 => TransDefuelActuator2633943038::On,
            0 => TransDefuelActuator2633943038::Off,
            value => TransDefuelActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransLockupClutchActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransLockupClutchActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransLockupClutchActuator2633943038::NotAvailable,
            2 => TransLockupClutchActuator2633943038::Error,
            1 => TransLockupClutchActuator2633943038::On,
            0 => TransLockupClutchActuator2633943038::Off,
            value => TransLockupClutchActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransClutchActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransClutchActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransClutchActuator2633943038::NotAvailable,
            2 => TransClutchActuator2633943038::Error,
            1 => TransClutchActuator2633943038::On,
            0 => TransClutchActuator2633943038::Off,
            value => TransClutchActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransSplitterIndirectActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransSplitterIndirectActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransSplitterIndirectActuator2633943038::NotAvailable,
            2 => TransSplitterIndirectActuator2633943038::Error,
            1 => TransSplitterIndirectActuator2633943038::On,
            0 => TransSplitterIndirectActuator2633943038::Off,
            value => TransSplitterIndirectActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransSplitterDirectActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransSplitterDirectActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransSplitterDirectActuator2633943038::NotAvailable,
            2 => TransSplitterDirectActuator2633943038::Error,
            1 => TransSplitterDirectActuator2633943038::On,
            0 => TransSplitterDirectActuator2633943038::Off,
            value => TransSplitterDirectActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransRangeLowActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransRangeLowActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransRangeLowActuator2633943038::NotAvailable,
            2 => TransRangeLowActuator2633943038::Error,
            1 => TransRangeLowActuator2633943038::On,
            0 => TransRangeLowActuator2633943038::Off,
            value => TransRangeLowActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransRangeHighActuator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransRangeHighActuator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransRangeHighActuator2633943038::NotAvailable,
            2 => TransRangeHighActuator2633943038::Error,
            1 => TransRangeHighActuator2633943038::On,
            0 => TransRangeHighActuator2633943038::Off,
            value => TransRangeHighActuator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransShiftFingerGearActuator22633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransShiftFingerGearActuator22633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransShiftFingerGearActuator22633943038::NotAvailable,
            2 => TransShiftFingerGearActuator22633943038::Error,
            1 => TransShiftFingerGearActuator22633943038::On,
            0 => TransShiftFingerGearActuator22633943038::Off,
            value => TransShiftFingerGearActuator22633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransShiftFingerRailActuator22633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransShiftFingerRailActuator22633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransShiftFingerRailActuator22633943038::NotAvailable,
            2 => TransShiftFingerRailActuator22633943038::Error,
            1 => TransShiftFingerRailActuator22633943038::On,
            0 => TransShiftFingerRailActuator22633943038::Off,
            value => TransShiftFingerRailActuator22633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransShiftFingerGearActuator12633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransShiftFingerGearActuator12633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransShiftFingerGearActuator12633943038::NotAvailable,
            2 => TransShiftFingerGearActuator12633943038::Error,
            1 => TransShiftFingerGearActuator12633943038::On,
            0 => TransShiftFingerGearActuator12633943038::Off,
            value => TransShiftFingerGearActuator12633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransShiftFingerRailActuator12633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransShiftFingerRailActuator12633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransShiftFingerRailActuator12633943038::NotAvailable,
            2 => TransShiftFingerRailActuator12633943038::Error,
            1 => TransShiftFingerRailActuator12633943038::On,
            0 => TransShiftFingerRailActuator12633943038::Off,
            value => TransShiftFingerRailActuator12633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrnsShftFngrCenterRailIndicator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TrnsShftFngrCenterRailIndicator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrnsShftFngrCenterRailIndicator2633943038::NotAvailable,
            2 => TrnsShftFngrCenterRailIndicator2633943038::Error,
            1 => TrnsShftFngrCenterRailIndicator2633943038::On,
            0 => TrnsShftFngrCenterRailIndicator2633943038::Off,
            value => TrnsShftFngrCenterRailIndicator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrnsShftFngrEngagementIndicator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TrnsShftFngrEngagementIndicator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrnsShftFngrEngagementIndicator2633943038::NotAvailable,
            2 => TrnsShftFngrEngagementIndicator2633943038::Error,
            1 => TrnsShftFngrEngagementIndicator2633943038::On,
            0 => TrnsShftFngrEngagementIndicator2633943038::Off,
            value => TrnsShftFngrEngagementIndicator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrnsShiftFingerNeutralIndicator2633943038 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TrnsShiftFingerNeutralIndicator2633943038 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrnsShiftFingerNeutralIndicator2633943038::NotAvailable,
            2 => TrnsShiftFingerNeutralIndicator2633943038::Error,
            1 => TrnsShiftFingerNeutralIndicator2633943038::On,
            0 => TrnsShiftFingerNeutralIndicator2633943038::Off,
            value => TrnsShiftFingerNeutralIndicator2633943038::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProgressiveShiftDisable2364539646 {
    Reserved,
    TakeNoAction,
    ProgressiveShiftIsDisabled,
    ProgressiveShiftIsNotDisabled,
    XValue(u64),
}

impl From<u64> for ProgressiveShiftDisable2364539646 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => ProgressiveShiftDisable2364539646::Reserved,
            3 => ProgressiveShiftDisable2364539646::TakeNoAction,
            1 => ProgressiveShiftDisable2364539646::ProgressiveShiftIsDisabled,
            0 => ProgressiveShiftDisable2364539646::ProgressiveShiftIsNotDisabled,
            value => ProgressiveShiftDisable2364539646::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngMomentaryOverspeedEnable2364539646 {
    Reserved,
    TakeNoAction,
    MomentaryEngOverspeedIsEnabled,
    MomentaryEngOverspeedIsDisabled,
    XValue(u64),
}

impl From<u64> for EngMomentaryOverspeedEnable2364539646 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => EngMomentaryOverspeedEnable2364539646::Reserved,
            3 => EngMomentaryOverspeedEnable2364539646::TakeNoAction,
            1 => EngMomentaryOverspeedEnable2364539646::MomentaryEngOverspeedIsEnabled,
            0 => EngMomentaryOverspeedEnable2364539646::MomentaryEngOverspeedIsDisabled,
            value => EngMomentaryOverspeedEnable2364539646::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransShiftInProcess2364539646 {
    NotAvailable,
    Error,
    ShiftInProcess,
    ShiftIsNotInProcess,
    XValue(u64),
}

impl From<u64> for TransShiftInProcess2364539646 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransShiftInProcess2364539646::NotAvailable,
            2 => TransShiftInProcess2364539646::Error,
            1 => TransShiftInProcess2364539646::ShiftInProcess,
            0 => TransShiftInProcess2364539646::ShiftIsNotInProcess,
            value => TransShiftInProcess2364539646::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TorqueConverterLockupEngaged2364539646 {
    NotAvailable,
    Error,
    TorqueConverterLockupEngaged,
    TorqueConverterLockupDisengaged,
    XValue(u64),
}

impl From<u64> for TorqueConverterLockupEngaged2364539646 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TorqueConverterLockupEngaged2364539646::NotAvailable,
            2 => TorqueConverterLockupEngaged2364539646::Error,
            1 => TorqueConverterLockupEngaged2364539646::TorqueConverterLockupEngaged,
            0 => TorqueConverterLockupEngaged2364539646::TorqueConverterLockupDisengaged,
            value => TorqueConverterLockupEngaged2364539646::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransDrivelineEngaged2364539646 {
    NotAvailable,
    Error,
    DrivelineEngaged,
    DrivelineDisengaged,
    XValue(u64),
}

impl From<u64> for TransDrivelineEngaged2364539646 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransDrivelineEngaged2364539646::NotAvailable,
            2 => TransDrivelineEngaged2364539646::Error,
            1 => TransDrivelineEngaged2364539646::DrivelineEngaged,
            0 => TransDrivelineEngaged2364539646::DrivelineDisengaged,
            value => TransDrivelineEngaged2364539646::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SterableLiftAxleLoweringInhibit2565868542 {
    NotAvailable,
    Reserved,
    LoweringInhibited,
    LoweringAllowed,
    XValue(u64),
}

impl From<u64> for SterableLiftAxleLoweringInhibit2565868542 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SterableLiftAxleLoweringInhibit2565868542::NotAvailable,
            2 => SterableLiftAxleLoweringInhibit2565868542::Reserved,
            1 => SterableLiftAxleLoweringInhibit2565868542::LoweringInhibited,
            0 => SterableLiftAxleLoweringInhibit2565868542::LoweringAllowed,
            value => SterableLiftAxleLoweringInhibit2565868542::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TypeOfSteerTrans2565868542 {
    NotAvailable,
    X1110reservedForSaeAssignment,
    HybrdStrTrnsAStrngTrnsmssnInWhc,
    PrlyElctrcStrTrnsAStrngTrnsmssn,
    PrlyHydStrTrnsAStrngTrnsmssnInW,
    PrlyMchStrTrnsAStrngTrnsmssnInW,
    XValue(u64),
}

impl From<u64> for TypeOfSteerTrans2565868542 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TypeOfSteerTrans2565868542::NotAvailable,
            4 => TypeOfSteerTrans2565868542::X1110reservedForSaeAssignment,
            3 => TypeOfSteerTrans2565868542::HybrdStrTrnsAStrngTrnsmssnInWhc,
            2 => TypeOfSteerTrans2565868542::PrlyElctrcStrTrnsAStrngTrnsmssn,
            1 => TypeOfSteerTrans2565868542::PrlyHydStrTrnsAStrngTrnsmssnInW,
            0 => TypeOfSteerTrans2565868542::PrlyMchStrTrnsAStrngTrnsmssnInW,
            value => TypeOfSteerTrans2565868542::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TypeOfSteerForces2565868542 {
    NotAvailable,
    X1110reservedForSaeAssignment,
    SlfTrckngStrEqpmntASystmDsgndTc,
    FllPwrStrEqpmntStrngFrcsArPrvdd,
    PwrAssstdStrEqpmntStrngFrcsRslt,
    MnlStrEqpmntStrngFrcsRsltSllyFr,
    XValue(u64),
}

impl From<u64> for TypeOfSteerForces2565868542 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TypeOfSteerForces2565868542::NotAvailable,
            4 => TypeOfSteerForces2565868542::X1110reservedForSaeAssignment,
            3 => TypeOfSteerForces2565868542::SlfTrckngStrEqpmntASystmDsgndTc,
            2 => TypeOfSteerForces2565868542::FllPwrStrEqpmntStrngFrcsArPrvdd,
            1 => TypeOfSteerForces2565868542::PwrAssstdStrEqpmntStrngFrcsRslt,
            0 => TypeOfSteerForces2565868542::MnlStrEqpmntStrngFrcsRsltSllyFr,
            value => TypeOfSteerForces2565868542::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SteerType2565868542 {
    NotAvailable,
    X1110reservedForAssignmentBySae,
    AxStrEqpmntASystmInWhchWhlsOnAx,
    MnStrSystmStrngEqpmntOfAVhclWhc,
    XValue(u64),
}

impl From<u64> for SteerType2565868542 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => SteerType2565868542::NotAvailable,
            2 => SteerType2565868542::X1110reservedForAssignmentBySae,
            1 => SteerType2565868542::AxStrEqpmntASystmInWhchWhlsOnAx,
            0 => SteerType2565868542::MnStrSystmStrngEqpmntOfAVhclWhc,
            value => SteerType2565868542::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum StatusOfSteerAxle2565868542 {
    NotAvailable,
    X1110reservedForSaeAssignment,
    AxleSteerInSpecialMode,
    AxleNotActiveBecauseOfAnError,
    AxleCenteredBecauseOfAnError,
    AxleCentered,
    AxleSteerActive,
    AxleSteerNotActive,
    XValue(u64),
}

impl From<u64> for StatusOfSteerAxle2565868542 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => StatusOfSteerAxle2565868542::NotAvailable,
            6 => StatusOfSteerAxle2565868542::X1110reservedForSaeAssignment,
            5 => StatusOfSteerAxle2565868542::AxleSteerInSpecialMode,
            4 => StatusOfSteerAxle2565868542::AxleNotActiveBecauseOfAnError,
            3 => StatusOfSteerAxle2565868542::AxleCenteredBecauseOfAnError,
            2 => StatusOfSteerAxle2565868542::AxleCentered,
            1 => StatusOfSteerAxle2565868542::AxleSteerActive,
            0 => StatusOfSteerAxle2565868542::AxleSteerNotActive,
            value => StatusOfSteerAxle2565868542::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransOutputRetarder2633941758 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TransOutputRetarder2633941758 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransOutputRetarder2633941758::NotAvailable,
            2 => TransOutputRetarder2633941758::Error,
            1 => TransOutputRetarder2633941758::On,
            0 => TransOutputRetarder2633941758::Off,
            value => TransOutputRetarder2633941758::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCoolantLoadIncrease2565865726 {
    NotAvailable,
    Error,
    CoolantLoadIncreasePossible,
    NoCoolantLoadIncrease,
    XValue(u64),
}

impl From<u64> for EngCoolantLoadIncrease2565865726 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCoolantLoadIncrease2565865726::NotAvailable,
            2 => EngCoolantLoadIncrease2565865726::Error,
            1 => EngCoolantLoadIncrease2565865726::CoolantLoadIncreasePossible,
            0 => EngCoolantLoadIncrease2565865726::NoCoolantLoadIncrease,
            value => EngCoolantLoadIncrease2565865726::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetarderEnableShiftAssistSwitch2565865726 {
    NotAvailable,
    Error,
    RetarderShiftAssistEnabled,
    RetarderShiftAssistDisabled,
    XValue(u64),
}

impl From<u64> for RetarderEnableShiftAssistSwitch2565865726 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RetarderEnableShiftAssistSwitch2565865726::NotAvailable,
            2 => RetarderEnableShiftAssistSwitch2565865726::Error,
            1 => RetarderEnableShiftAssistSwitch2565865726::RetarderShiftAssistEnabled,
            0 => RetarderEnableShiftAssistSwitch2565865726::RetarderShiftAssistDisabled,
            value => RetarderEnableShiftAssistSwitch2565865726::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RetarderEnableBrakeAssistSwitch2565865726 {
    NotAvailable,
    Error,
    RetarderBrakeAssistEnabled,
    RetarderBrakeAssistDisabled,
    XValue(u64),
}

impl From<u64> for RetarderEnableBrakeAssistSwitch2565865726 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RetarderEnableBrakeAssistSwitch2565865726::NotAvailable,
            2 => RetarderEnableBrakeAssistSwitch2565865726::Error,
            1 => RetarderEnableBrakeAssistSwitch2565865726::RetarderBrakeAssistEnabled,
            0 => RetarderEnableBrakeAssistSwitch2565865726::RetarderBrakeAssistDisabled,
            value => RetarderEnableBrakeAssistSwitch2565865726::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngExhstGsOxygnSnsrClsdLpOprton2633935358 {
    DontCareTakeNoAction,
    Reserved,
    CmdToEnableFunction,
    CmdToDisableFunction,
    XValue(u64),
}

impl From<u64> for EngExhstGsOxygnSnsrClsdLpOprton2633935358 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngExhstGsOxygnSnsrClsdLpOprton2633935358::DontCareTakeNoAction,
            2 => EngExhstGsOxygnSnsrClsdLpOprton2633935358::Reserved,
            1 => EngExhstGsOxygnSnsrClsdLpOprton2633935358::CmdToEnableFunction,
            0 => EngExhstGsOxygnSnsrClsdLpOprton2633935358::CmdToDisableFunction,
            value => EngExhstGsOxygnSnsrClsdLpOprton2633935358::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GripXAxisDetentPosStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck3GripXAxisDetentPosStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GripXAxisDetentPosStatus2365447166::NotAvailable,
            2 => Jystck3GripXAxisDetentPosStatus2365447166::ErrorIndicator,
            1 => Jystck3GripXAxisDetentPosStatus2365447166::InDetentPos,
            0 => Jystck3GripXAxisDetentPosStatus2365447166::NotInDetentPos,
            value => Jystck3GripXAxisDetentPosStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GripYAxisDetentPosStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck3GripYAxisDetentPosStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GripYAxisDetentPosStatus2365447166::NotAvailable,
            2 => Jystck3GripYAxisDetentPosStatus2365447166::ErrorIndicator,
            1 => Jystck3GripYAxisDetentPosStatus2365447166::InDetentPos,
            0 => Jystck3GripYAxisDetentPosStatus2365447166::NotInDetentPos,
            value => Jystck3GripYAxisDetentPosStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3ThetaAxisDetentPosStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck3ThetaAxisDetentPosStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3ThetaAxisDetentPosStatus2365447166::NotAvailable,
            2 => Jystck3ThetaAxisDetentPosStatus2365447166::ErrorIndicator,
            1 => Jystck3ThetaAxisDetentPosStatus2365447166::InDetentPos,
            0 => Jystck3ThetaAxisDetentPosStatus2365447166::NotInDetentPos,
            value => Jystck3ThetaAxisDetentPosStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3ThtAxsClckwsPstvPsStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3ThtAxsClckwsPstvPsStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3ThtAxsClckwsPstvPsStatus2365447166::NotAvailable,
            2 => Jystck3ThtAxsClckwsPstvPsStatus2365447166::ErrorIndicator,
            1 => Jystck3ThtAxsClckwsPstvPsStatus2365447166::OnPositiveSideOfNeutral,
            0 => Jystck3ThtAxsClckwsPstvPsStatus2365447166::NotOnPositiveSideOfNeutral,
            value => Jystck3ThtAxsClckwsPstvPsStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166::NotAvailable,
            2 => Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166::ErrorIndicator,
            1 => Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166::OnNegativeSideOfNeutral,
            0 => Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166::NotOnNegativeSideOfNeutral,
            value => Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3ThtaAxisNeutralPosStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck3ThtaAxisNeutralPosStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3ThtaAxisNeutralPosStatus2365447166::NotAvailable,
            2 => Jystck3ThtaAxisNeutralPosStatus2365447166::ErrorIndicator,
            1 => Jystck3ThtaAxisNeutralPosStatus2365447166::InNeutralPos,
            0 => Jystck3ThtaAxisNeutralPosStatus2365447166::NotInNeutralPos,
            value => Jystck3ThtaAxisNeutralPosStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166::NotAvailable,
            2 => Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166::ErrorIndicator,
            1 => Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166::OnPositiveSideOfNeutral,
            0 => Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166::NotOnPositiveSideOfNeutral,
            value => Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166::NotAvailable,
            2 => Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166::ErrorIndicator,
            1 => Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166::OnNegativeSideOfNeutral,
            0 => Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166::NotOnNegativeSideOfNeutral,
            value => Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GrpYAxisNeutralPosStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck3GrpYAxisNeutralPosStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GrpYAxisNeutralPosStatus2365447166::NotAvailable,
            2 => Jystck3GrpYAxisNeutralPosStatus2365447166::ErrorIndicator,
            1 => Jystck3GrpYAxisNeutralPosStatus2365447166::InNeutralPos,
            0 => Jystck3GrpYAxisNeutralPosStatus2365447166::NotInNeutralPos,
            value => Jystck3GrpYAxisNeutralPosStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GrpXAxsLvrRghtPstvPsStts2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3GrpXAxsLvrRghtPstvPsStts2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GrpXAxsLvrRghtPstvPsStts2365447166::NotAvailable,
            2 => Jystck3GrpXAxsLvrRghtPstvPsStts2365447166::ErrorIndicator,
            1 => Jystck3GrpXAxsLvrRghtPstvPsStts2365447166::OnPositiveSideOfNeutral,
            0 => Jystck3GrpXAxsLvrRghtPstvPsStts2365447166::NotOnPositiveSideOfNeutral,
            value => Jystck3GrpXAxsLvrRghtPstvPsStts2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166::NotAvailable,
            2 => Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166::ErrorIndicator,
            1 => Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166::OnNegativeSideOfNeutral,
            0 => Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166::NotOnNegativeSideOfNeutral,
            value => Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3GrpXAxisNeutralPosStatus2365447166 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3GrpXAxisNeutralPosStatus2365447166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3GrpXAxisNeutralPosStatus2365447166::NotAvailable,
            2 => Jystck3GrpXAxisNeutralPosStatus2365447166::ErrorIndicator,
            1 => Jystck3GrpXAxisNeutralPosStatus2365447166::OnNegativeSideOfNeutral,
            0 => Jystck3GrpXAxisNeutralPosStatus2365447166::NotOnNegativeSideOfNeutral,
            value => Jystck3GrpXAxisNeutralPosStatus2365447166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GripXAxisDetentPosStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck2GripXAxisDetentPosStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GripXAxisDetentPosStatus2365446654::NotAvailable,
            2 => Jystck2GripXAxisDetentPosStatus2365446654::ErrorIndicator,
            1 => Jystck2GripXAxisDetentPosStatus2365446654::InDetentPos,
            0 => Jystck2GripXAxisDetentPosStatus2365446654::NotInDetentPos,
            value => Jystck2GripXAxisDetentPosStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GripYAxisDetentPosStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck2GripYAxisDetentPosStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GripYAxisDetentPosStatus2365446654::NotAvailable,
            2 => Jystck2GripYAxisDetentPosStatus2365446654::ErrorIndicator,
            1 => Jystck2GripYAxisDetentPosStatus2365446654::InDetentPos,
            0 => Jystck2GripYAxisDetentPosStatus2365446654::NotInDetentPos,
            value => Jystck2GripYAxisDetentPosStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2ThetaAxisDetentPosStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck2ThetaAxisDetentPosStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2ThetaAxisDetentPosStatus2365446654::NotAvailable,
            2 => Jystck2ThetaAxisDetentPosStatus2365446654::ErrorIndicator,
            1 => Jystck2ThetaAxisDetentPosStatus2365446654::InDetentPos,
            0 => Jystck2ThetaAxisDetentPosStatus2365446654::NotInDetentPos,
            value => Jystck2ThetaAxisDetentPosStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2ThtAxsClckwsPstvPsStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2ThtAxsClckwsPstvPsStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2ThtAxsClckwsPstvPsStatus2365446654::NotAvailable,
            2 => Jystck2ThtAxsClckwsPstvPsStatus2365446654::ErrorIndicator,
            1 => Jystck2ThtAxsClckwsPstvPsStatus2365446654::OnPositiveSideOfNeutral,
            0 => Jystck2ThtAxsClckwsPstvPsStatus2365446654::NotOnPositiveSideOfNeutral,
            value => Jystck2ThtAxsClckwsPstvPsStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654::NotAvailable,
            2 => Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654::ErrorIndicator,
            1 => Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654::OnNegativeSideOfNeutral,
            0 => Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654::NotOnNegativeSideOfNeutral,
            value => Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2ThtaAxisNeutralPosStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck2ThtaAxisNeutralPosStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2ThtaAxisNeutralPosStatus2365446654::NotAvailable,
            2 => Jystck2ThtaAxisNeutralPosStatus2365446654::ErrorIndicator,
            1 => Jystck2ThtaAxisNeutralPosStatus2365446654::InNeutralPos,
            0 => Jystck2ThtaAxisNeutralPosStatus2365446654::NotInNeutralPos,
            value => Jystck2ThtaAxisNeutralPosStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654::NotAvailable,
            2 => Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654::ErrorIndicator,
            1 => Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654::OnPositiveSideOfNeutral,
            0 => Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654::NotOnPositiveSideOfNeutral,
            value => Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654::NotAvailable,
            2 => Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654::ErrorIndicator,
            1 => Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654::OnNegativeSideOfNeutral,
            0 => Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654::NotOnNegativeSideOfNeutral,
            value => Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GrpYAxisNeutralPosStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck2GrpYAxisNeutralPosStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GrpYAxisNeutralPosStatus2365446654::NotAvailable,
            2 => Jystck2GrpYAxisNeutralPosStatus2365446654::ErrorIndicator,
            1 => Jystck2GrpYAxisNeutralPosStatus2365446654::InNeutralPos,
            0 => Jystck2GrpYAxisNeutralPosStatus2365446654::NotInNeutralPos,
            value => Jystck2GrpYAxisNeutralPosStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GrpXAxsLvrRghtPstvPsStts2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2GrpXAxsLvrRghtPstvPsStts2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GrpXAxsLvrRghtPstvPsStts2365446654::NotAvailable,
            2 => Jystck2GrpXAxsLvrRghtPstvPsStts2365446654::ErrorIndicator,
            1 => Jystck2GrpXAxsLvrRghtPstvPsStts2365446654::OnPositiveSideOfNeutral,
            0 => Jystck2GrpXAxsLvrRghtPstvPsStts2365446654::NotOnPositiveSideOfNeutral,
            value => Jystck2GrpXAxsLvrRghtPstvPsStts2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654::NotAvailable,
            2 => Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654::ErrorIndicator,
            1 => Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654::OnNegativeSideOfNeutral,
            0 => Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654::NotOnNegativeSideOfNeutral,
            value => Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2GrpXAxisNeutralPosStatus2365446654 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2GrpXAxisNeutralPosStatus2365446654 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2GrpXAxisNeutralPosStatus2365446654::NotAvailable,
            2 => Jystck2GrpXAxisNeutralPosStatus2365446654::ErrorIndicator,
            1 => Jystck2GrpXAxisNeutralPosStatus2365446654::OnNegativeSideOfNeutral,
            0 => Jystck2GrpXAxisNeutralPosStatus2365446654::NotOnNegativeSideOfNeutral,
            value => Jystck2GrpXAxisNeutralPosStatus2365446654::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GripXAxisDetentPosStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck1GripXAxisDetentPosStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GripXAxisDetentPosStatus2365446142::NotAvailable,
            2 => Jystck1GripXAxisDetentPosStatus2365446142::ErrorIndicator,
            1 => Jystck1GripXAxisDetentPosStatus2365446142::InDetentPos,
            0 => Jystck1GripXAxisDetentPosStatus2365446142::NotInDetentPos,
            value => Jystck1GripXAxisDetentPosStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GripYAxisDetentPosStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck1GripYAxisDetentPosStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GripYAxisDetentPosStatus2365446142::NotAvailable,
            2 => Jystck1GripYAxisDetentPosStatus2365446142::ErrorIndicator,
            1 => Jystck1GripYAxisDetentPosStatus2365446142::InDetentPos,
            0 => Jystck1GripYAxisDetentPosStatus2365446142::NotInDetentPos,
            value => Jystck1GripYAxisDetentPosStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1ThetaAxisDetentPosStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Jystck1ThetaAxisDetentPosStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1ThetaAxisDetentPosStatus2365446142::NotAvailable,
            2 => Jystck1ThetaAxisDetentPosStatus2365446142::ErrorIndicator,
            1 => Jystck1ThetaAxisDetentPosStatus2365446142::InDetentPos,
            0 => Jystck1ThetaAxisDetentPosStatus2365446142::NotInDetentPos,
            value => Jystck1ThetaAxisDetentPosStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1ThtAxsClckwsPstvPsStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1ThtAxsClckwsPstvPsStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1ThtAxsClckwsPstvPsStatus2365446142::NotAvailable,
            2 => Jystck1ThtAxsClckwsPstvPsStatus2365446142::ErrorIndicator,
            1 => Jystck1ThtAxsClckwsPstvPsStatus2365446142::OnPositiveSideOfNeutral,
            0 => Jystck1ThtAxsClckwsPstvPsStatus2365446142::NotOnPositiveSideOfNeutral,
            value => Jystck1ThtAxsClckwsPstvPsStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142::NotAvailable,
            2 => Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142::ErrorIndicator,
            1 => Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142::OnNegativeSideOfNeutral,
            0 => Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142::NotOnNegativeSideOfNeutral,
            value => Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1ThtaAxisNeutralPosStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck1ThtaAxisNeutralPosStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1ThtaAxisNeutralPosStatus2365446142::NotAvailable,
            2 => Jystck1ThtaAxisNeutralPosStatus2365446142::ErrorIndicator,
            1 => Jystck1ThtaAxisNeutralPosStatus2365446142::InNeutralPos,
            0 => Jystck1ThtaAxisNeutralPosStatus2365446142::NotInNeutralPos,
            value => Jystck1ThtaAxisNeutralPosStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142::NotAvailable,
            2 => Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142::ErrorIndicator,
            1 => Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142::OnPositiveSideOfNeutral,
            0 => Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142::NotOnPositiveSideOfNeutral,
            value => Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142::NotAvailable,
            2 => Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142::ErrorIndicator,
            1 => Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142::OnNegativeSideOfNeutral,
            0 => Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142::NotOnNegativeSideOfNeutral,
            value => Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GrpYAxisNeutralPosStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck1GrpYAxisNeutralPosStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GrpYAxisNeutralPosStatus2365446142::NotAvailable,
            2 => Jystck1GrpYAxisNeutralPosStatus2365446142::ErrorIndicator,
            1 => Jystck1GrpYAxisNeutralPosStatus2365446142::InNeutralPos,
            0 => Jystck1GrpYAxisNeutralPosStatus2365446142::NotInNeutralPos,
            value => Jystck1GrpYAxisNeutralPosStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GrpXAxsLvrRghtPstvPsStts2365446142 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1GrpXAxsLvrRghtPstvPsStts2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GrpXAxsLvrRghtPstvPsStts2365446142::NotAvailable,
            2 => Jystck1GrpXAxsLvrRghtPstvPsStts2365446142::ErrorIndicator,
            1 => Jystck1GrpXAxsLvrRghtPstvPsStts2365446142::OnPositiveSideOfNeutral,
            0 => Jystck1GrpXAxsLvrRghtPstvPsStts2365446142::NotOnPositiveSideOfNeutral,
            value => Jystck1GrpXAxsLvrRghtPstvPsStts2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142::NotAvailable,
            2 => Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142::ErrorIndicator,
            1 => Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142::OnNegativeSideOfNeutral,
            0 => Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142::NotOnNegativeSideOfNeutral,
            value => Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1GrpXAxisNeutralPosStatus2365446142 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Jystck1GrpXAxisNeutralPosStatus2365446142 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1GrpXAxisNeutralPosStatus2365446142::NotAvailable,
            2 => Jystck1GrpXAxisNeutralPosStatus2365446142::ErrorIndicator,
            1 => Jystck1GrpXAxisNeutralPosStatus2365446142::InNeutralPos,
            0 => Jystck1GrpXAxisNeutralPosStatus2365446142::NotInNeutralPos,
            value => Jystck1GrpXAxisNeutralPosStatus2365446142::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngWasteOilReservoirLevel2566810366 {
    RepresentsCompletelyFull,
    XValue(u64),
}

impl From<u64> for EngWasteOilReservoirLevel2566810366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => EngWasteOilReservoirLevel2566810366::RepresentsCompletelyFull,
            value => EngWasteOilReservoirLevel2566810366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngVentilationStatus2566810366 {
    NotAvailableNotInstalle,
    NtAblTDtrmnIfSufficientlyVented,
    ReservedForSaeAssignment,
    CurrentlyVenting,
    VentilationDelay,
    VentilationNeeded,
    SufficientlyVented,
    XValue(u64),
}

impl From<u64> for EngVentilationStatus2566810366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => EngVentilationStatus2566810366::NotAvailableNotInstalle,
            6 => EngVentilationStatus2566810366::NtAblTDtrmnIfSufficientlyVented,
            5 => EngVentilationStatus2566810366::ReservedForSaeAssignment,
            3 => EngVentilationStatus2566810366::CurrentlyVenting,
            2 => EngVentilationStatus2566810366::VentilationDelay,
            1 => EngVentilationStatus2566810366::VentilationNeeded,
            0 => EngVentilationStatus2566810366::SufficientlyVented,
            value => EngVentilationStatus2566810366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOilPrimingState2566810366 {
    NotAvailableNotInstalled,
    UnblTDtrmnIfSffcentlyLubricated,
    SufficientlyLubricated,
    NotSufficientlyLubricated,
    XValue(u64),
}

impl From<u64> for EngOilPrimingState2566810366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngOilPrimingState2566810366::NotAvailableNotInstalled,
            2 => EngOilPrimingState2566810366::UnblTDtrmnIfSffcentlyLubricated,
            1 => EngOilPrimingState2566810366::SufficientlyLubricated,
            0 => EngOilPrimingState2566810366::NotSufficientlyLubricated,
            value => EngOilPrimingState2566810366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOilPrimingPumpSwitch2566810366 {
    NotAvailableNotInstalled,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngOilPrimingPumpSwitch2566810366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngOilPrimingPumpSwitch2566810366::NotAvailableNotInstalled,
            2 => EngOilPrimingPumpSwitch2566810366::Error,
            1 => EngOilPrimingPumpSwitch2566810366::On,
            0 => EngOilPrimingPumpSwitch2566810366::Off,
            value => EngOilPrimingPumpSwitch2566810366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngOilPreHeatedState2566810366 {
    NotAvailableNotInstalled,
    UnblTDtrmnIfEngOlIsPrhtdSffcntl,
    SufficientlyPreheated,
    NotSufficientlyPreheated,
    XValue(u64),
}

impl From<u64> for EngOilPreHeatedState2566810366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngOilPreHeatedState2566810366::NotAvailableNotInstalled,
            2 => EngOilPreHeatedState2566810366::UnblTDtrmnIfEngOlIsPrhtdSffcntl,
            1 => EngOilPreHeatedState2566810366::SufficientlyPreheated,
            0 => EngOilPreHeatedState2566810366::NotSufficientlyPreheated,
            value => EngOilPreHeatedState2566810366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngCoolantPreheatedState2566810366 {
    NotAvailableNotInstalled,
    UnblTDtrmnEngClntPrhtdSffcently,
    SufficientlyPreheated,
    NotSufficientlyPreheated,
    XValue(u64),
}

impl From<u64> for EngCoolantPreheatedState2566810366 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngCoolantPreheatedState2566810366::NotAvailableNotInstalled,
            2 => EngCoolantPreheatedState2566810366::UnblTDtrmnEngClntPrhtdSffcently,
            1 => EngCoolantPreheatedState2566810366::SufficientlyPreheated,
            0 => EngCoolantPreheatedState2566810366::NotSufficientlyPreheated,
            value => EngCoolantPreheatedState2566810366::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TurningGearEngaged2633929726 {
    TurningGearIsEngaged,
    TurningGearIsNotEngaged,
    XValue(u64),
}

impl From<u64> for TurningGearEngaged2633929726 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => TurningGearEngaged2633929726::TurningGearIsEngaged,
            0 => TurningGearEngaged2633929726::TurningGearIsNotEngaged,
            value => TurningGearEngaged2633929726::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SafetyWireStatus2633929726 {
    NotAvailable,
    Error,
    SafetyWireHasBeenActivated,
    SafetyWireHasNotBeenActivated,
    XValue(u64),
}

impl From<u64> for SafetyWireStatus2633929726 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SafetyWireStatus2633929726::NotAvailable,
            2 => SafetyWireStatus2633929726::Error,
            1 => SafetyWireStatus2633929726::SafetyWireHasBeenActivated,
            0 => SafetyWireStatus2633929726::SafetyWireHasNotBeenActivated,
            value => SafetyWireStatus2633929726::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngVrblGmtryTrbArCtrlShtffValve2566772222 {
    NotAvailable,
    Reserved,
    VgtAirCtrlShutoffValveIsOn,
    VgtAirCtrlShutoffValveIsOff,
    XValue(u64),
}

impl From<u64> for EngVrblGmtryTrbArCtrlShtffValve2566772222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngVrblGmtryTrbArCtrlShtffValve2566772222::NotAvailable,
            2 => EngVrblGmtryTrbArCtrlShtffValve2566772222::Reserved,
            1 => EngVrblGmtryTrbArCtrlShtffValve2566772222::VgtAirCtrlShutoffValveIsOn,
            0 => EngVrblGmtryTrbArCtrlShtffValve2566772222::VgtAirCtrlShutoffValveIsOff,
            value => EngVrblGmtryTrbArCtrlShtffValve2566772222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngRotationDirection2633940734 {
    NotAvailable,
    Reserved,
    ClockWise,
    CounterClockWise,
    XValue(u64),
}

impl From<u64> for EngRotationDirection2633940734 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngRotationDirection2633940734::NotAvailable,
            2 => EngRotationDirection2633940734::Reserved,
            1 => EngRotationDirection2633940734::ClockWise,
            0 => EngRotationDirection2633940734::CounterClockWise,
            value => EngRotationDirection2633940734::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VhclAccelerationRateLimitStatus2364539902 {
    NotAvailable,
    Reserved,
    LimitActive,
    LimitNotActive,
    XValue(u64),
}

impl From<u64> for VhclAccelerationRateLimitStatus2364539902 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VhclAccelerationRateLimitStatus2364539902::NotAvailable,
            2 => VhclAccelerationRateLimitStatus2364539902::Reserved,
            1 => VhclAccelerationRateLimitStatus2364539902::LimitActive,
            0 => VhclAccelerationRateLimitStatus2364539902::LimitNotActive,
            value => VhclAccelerationRateLimitStatus2364539902::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccelPedal2LowIdleSwitch2364539902 {
    NotAvailable,
    Error,
    AccelPedal2InLowIdleCondition,
    AcclPedal2NotInLowIdleCondition,
    XValue(u64),
}

impl From<u64> for AccelPedal2LowIdleSwitch2364539902 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccelPedal2LowIdleSwitch2364539902::NotAvailable,
            2 => AccelPedal2LowIdleSwitch2364539902::Error,
            1 => AccelPedal2LowIdleSwitch2364539902::AccelPedal2InLowIdleCondition,
            0 => AccelPedal2LowIdleSwitch2364539902::AcclPedal2NotInLowIdleCondition,
            value => AccelPedal2LowIdleSwitch2364539902::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RoadSpeedLimitStatus2364539902 {
    NotAvailable,
    Error,
    NotActive,
    Active,
    XValue(u64),
}

impl From<u64> for RoadSpeedLimitStatus2364539902 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RoadSpeedLimitStatus2364539902::NotAvailable,
            2 => RoadSpeedLimitStatus2364539902::Error,
            1 => RoadSpeedLimitStatus2364539902::NotActive,
            0 => RoadSpeedLimitStatus2364539902::Active,
            value => RoadSpeedLimitStatus2364539902::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccelPedalKickdownSwitch2364539902 {
    NotAvailable,
    Error,
    KickdownActive,
    KickdownPassive,
    XValue(u64),
}

impl From<u64> for AccelPedalKickdownSwitch2364539902 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccelPedalKickdownSwitch2364539902::NotAvailable,
            2 => AccelPedalKickdownSwitch2364539902::Error,
            1 => AccelPedalKickdownSwitch2364539902::KickdownActive,
            0 => AccelPedalKickdownSwitch2364539902::KickdownPassive,
            value => AccelPedalKickdownSwitch2364539902::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccelPedal1LowIdleSwitch2364539902 {
    NotAvailable,
    Error,
    AccelPedal1InLowIdleCondition,
    AcclPedal1NotInLowIdleCondition,
    XValue(u64),
}

impl From<u64> for AccelPedal1LowIdleSwitch2364539902 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccelPedal1LowIdleSwitch2364539902::NotAvailable,
            2 => AccelPedal1LowIdleSwitch2364539902::Error,
            1 => AccelPedal1LowIdleSwitch2364539902::AccelPedal1InLowIdleCondition,
            0 => AccelPedal1LowIdleSwitch2364539902::AcclPedal1NotInLowIdleCondition,
            value => AccelPedal1LowIdleSwitch2364539902::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngStarterMode2364540158 {
    NotAvailable,
    Error,
    StarterInhibitedReasonUnknown,
    X1011reserved,
    StrtrInhbtdDueToStarterOvertemp,
    StrtrInhbtdDToActiveImmobilizer,
    StrtrInhbtdDtDrvlnEnggdOthrTrns,
    StrtrInhbtdDtEngNtReadyForStart,
    StrtrInhbtdDToEngAlreadyRunning,
    StrtFnshdStrtrNtActvAftrHvngBnA,
    StarterActiveGearEngaged,
    StarterActiveGearNotEngaged,
    StartNotRqed,
    XValue(u64),
}

impl From<u64> for EngStarterMode2364540158 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngStarterMode2364540158::NotAvailable,
            14 => EngStarterMode2364540158::Error,
            12 => EngStarterMode2364540158::StarterInhibitedReasonUnknown,
            9 => EngStarterMode2364540158::X1011reserved,
            8 => EngStarterMode2364540158::StrtrInhbtdDueToStarterOvertemp,
            7 => EngStarterMode2364540158::StrtrInhbtdDToActiveImmobilizer,
            6 => EngStarterMode2364540158::StrtrInhbtdDtDrvlnEnggdOthrTrns,
            5 => EngStarterMode2364540158::StrtrInhbtdDtEngNtReadyForStart,
            4 => EngStarterMode2364540158::StrtrInhbtdDToEngAlreadyRunning,
            3 => EngStarterMode2364540158::StrtFnshdStrtrNtActvAftrHvngBnA,
            2 => EngStarterMode2364540158::StarterActiveGearEngaged,
            1 => EngStarterMode2364540158::StarterActiveGearNotEngaged,
            0 => EngStarterMode2364540158::StartNotRqed,
            value => EngStarterMode2364540158::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngTorqueMode2364540158 {
    NotAvailable,
    RemoteAccelerator,
    BrakingSystem,
    HighSpeedGovernor,
    TorqueLimiting,
    AbsControl,
    TransmissionControl,
    AsrControl,
    RoadSpeedGovernor,
    PtoGovernor,
    CruiseControl,
    AcceleratorPedalOperatorSelec,
    LowIdleGovernorNoRequestDe,
    XValue(u64),
}

impl From<u64> for EngTorqueMode2364540158 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngTorqueMode2364540158::NotAvailable,
            11 => EngTorqueMode2364540158::RemoteAccelerator,
            10 => EngTorqueMode2364540158::BrakingSystem,
            9 => EngTorqueMode2364540158::HighSpeedGovernor,
            8 => EngTorqueMode2364540158::TorqueLimiting,
            7 => EngTorqueMode2364540158::AbsControl,
            6 => EngTorqueMode2364540158::TransmissionControl,
            5 => EngTorqueMode2364540158::AsrControl,
            4 => EngTorqueMode2364540158::RoadSpeedGovernor,
            3 => EngTorqueMode2364540158::PtoGovernor,
            2 => EngTorqueMode2364540158::CruiseControl,
            1 => EngTorqueMode2364540158::AcceleratorPedalOperatorSelec,
            0 => EngTorqueMode2364540158::LowIdleGovernorNoRequestDe,
            value => EngTorqueMode2364540158::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupportTsc1CtrlPurposeGroup4Of42566841342 {
    P25ReservedForAssignmentBySae,
    XValue(u64),
}

impl From<u64> for SupportTsc1CtrlPurposeGroup4Of42566841342 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupportTsc1CtrlPurposeGroup4Of42566841342::P25ReservedForAssignmentBySae,
            value => SupportTsc1CtrlPurposeGroup4Of42566841342::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupportVariableRateTsc1Message2566841342 {
    MsTransRate,
    XValue(u64),
}

impl From<u64> for SupportVariableRateTsc1Message2566841342 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupportVariableRateTsc1Message2566841342::MsTransRate,
            value => SupportVariableRateTsc1Message2566841342::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupportTsc1CtrlPurposeGroup3Of42566841342 {
    P17ReservedForAssignmentBySae,
    XValue(u64),
}

impl From<u64> for SupportTsc1CtrlPurposeGroup3Of42566841342 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupportTsc1CtrlPurposeGroup3Of42566841342::P17ReservedForAssignmentBySae,
            value => SupportTsc1CtrlPurposeGroup3Of42566841342::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupportTsc1CtrlPurposeGroup2Of42566841342 {
    P9ReservedForAssignmentBySae,
    XValue(u64),
}

impl From<u64> for SupportTsc1CtrlPurposeGroup2Of42566841342 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupportTsc1CtrlPurposeGroup2Of42566841342::P9ReservedForAssignmentBySae,
            value => SupportTsc1CtrlPurposeGroup2Of42566841342::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SupportTsc1CtrlPurposeGroup1Of42566841342 {
    P1AccelPedalOperatorSelection,
    XValue(u64),
}

impl From<u64> for SupportTsc1CtrlPurposeGroup1Of42566841342 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SupportTsc1CtrlPurposeGroup1Of42566841342::P1AccelPedalOperatorSelection,
            value => SupportTsc1CtrlPurposeGroup1Of42566841342::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BrakeTempWarning2566767870 {
    NotAvailable,
    Reserved,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for BrakeTempWarning2566767870 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BrakeTempWarning2566767870::NotAvailable,
            2 => BrakeTempWarning2566767870::Reserved,
            1 => BrakeTempWarning2566767870::Active,
            0 => BrakeTempWarning2566767870::NotActive,
            value => BrakeTempWarning2566767870::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum XbrActiveCtrlMode2566767870 {
    NotAvailable,
    X1110reservedForSaeAssignment,
    MxMdOfXbrAcclrtnCtrlBngExecuted,
    AddtnMdOfXbrAcclrtnCtrlBngExctd,
    DrvrsBrkDmndBngExctdNExtlBrkDmn,
    NoBrakeDemandBeingExecuted,
    XValue(u64),
}

impl From<u64> for XbrActiveCtrlMode2566767870 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => XbrActiveCtrlMode2566767870::NotAvailable,
            4 => XbrActiveCtrlMode2566767870::X1110reservedForSaeAssignment,
            3 => XbrActiveCtrlMode2566767870::MxMdOfXbrAcclrtnCtrlBngExecuted,
            2 => XbrActiveCtrlMode2566767870::AddtnMdOfXbrAcclrtnCtrlBngExctd,
            1 => XbrActiveCtrlMode2566767870::DrvrsBrkDmndBngExctdNExtlBrkDmn,
            0 => XbrActiveCtrlMode2566767870::NoBrakeDemandBeingExecuted,
            value => XbrActiveCtrlMode2566767870::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum XbrSystemState2566767870 {
    NotAvailable,
    NoExtlBrakeDemandWillBeAccepted,
    OnlyExtlBrkDmndOfHghstXbrPrrtyW,
    AnyExtlBrkeDemandWillBeAccepted,
    XValue(u64),
}

impl From<u64> for XbrSystemState2566767870 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => XbrSystemState2566767870::NotAvailable,
            2 => XbrSystemState2566767870::NoExtlBrakeDemandWillBeAccepted,
            1 => XbrSystemState2566767870::OnlyExtlBrkDmndOfHghstXbrPrrtyW,
            0 => XbrSystemState2566767870::AnyExtlBrkeDemandWillBeAccepted,
            value => XbrSystemState2566767870::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FoundationBrakeUse2566767870 {
    NotAvailable,
    Reserved,
    FoundationBrakesInUse,
    FoundationBrakesNotInUse,
    XValue(u64),
}

impl From<u64> for FoundationBrakeUse2566767870 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FoundationBrakeUse2566767870::NotAvailable,
            2 => FoundationBrakeUse2566767870::Reserved,
            1 => FoundationBrakeUse2566767870::FoundationBrakesInUse,
            0 => FoundationBrakeUse2566767870::FoundationBrakesNotInUse,
            value => FoundationBrakeUse2566767870::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HillHolderMode2566767870 {
    NotAvailable,
    Reserved,
    X101notDefined,
    ActvBtWllChngTInctvInAShortTime,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for HillHolderMode2566767870 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => HillHolderMode2566767870::NotAvailable,
            6 => HillHolderMode2566767870::Reserved,
            3 => HillHolderMode2566767870::X101notDefined,
            2 => HillHolderMode2566767870::ActvBtWllChngTInctvInAShortTime,
            1 => HillHolderMode2566767870::Active,
            0 => HillHolderMode2566767870::Inactive,
            value => HillHolderMode2566767870::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HaltBrakeMode2566767870 {
    NotAvailable,
    Reserved,
    X101notDefined,
    ActiveButNotFunctioningProperly,
    Active,
    Inactive,
    XValue(u64),
}

impl From<u64> for HaltBrakeMode2566767870 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => HaltBrakeMode2566767870::NotAvailable,
            6 => HaltBrakeMode2566767870::Reserved,
            3 => HaltBrakeMode2566767870::X101notDefined,
            2 => HaltBrakeMode2566767870::ActiveButNotFunctioningProperly,
            1 => HaltBrakeMode2566767870::Active,
            0 => HaltBrakeMode2566767870::Inactive,
            value => HaltBrakeMode2566767870::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrctrMntdTrilerAbsWarningSignal2565865982 {
    TakeNoAction,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TrctrMntdTrilerAbsWarningSignal2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrctrMntdTrilerAbsWarningSignal2565865982::TakeNoAction,
            2 => TrctrMntdTrilerAbsWarningSignal2565865982::Reserved,
            1 => TrctrMntdTrilerAbsWarningSignal2565865982::On,
            0 => TrctrMntdTrilerAbsWarningSignal2565865982::Off,
            value => TrctrMntdTrilerAbsWarningSignal2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerAbsStatus2565865982 {
    TrlrAbsSttsInfrmtnNtAvlblPrmtrN,
    Reserved,
    TrailerAbsActive,
    TrlrAbsSttsInfrmtnAvlblBtNtActv,
    XValue(u64),
}

impl From<u64> for TrailerAbsStatus2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TrailerAbsStatus2565865982::TrlrAbsSttsInfrmtnNtAvlblPrmtrN,
            2 => TrailerAbsStatus2565865982::Reserved,
            1 => TrailerAbsStatus2565865982::TrailerAbsActive,
            0 => TrailerAbsStatus2565865982::TrlrAbsSttsInfrmtnAvlblBtNtActv,
            value => TrailerAbsStatus2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HaltBrakeSwitch2565865982 {
    NotAvailable,
    Error,
    HaltBrakeSwitchActive,
    HaltBrakeSwitchPassive,
    XValue(u64),
}

impl From<u64> for HaltBrakeSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => HaltBrakeSwitch2565865982::NotAvailable,
            2 => HaltBrakeSwitch2565865982::Error,
            1 => HaltBrakeSwitch2565865982::HaltBrakeSwitchActive,
            0 => HaltBrakeSwitch2565865982::HaltBrakeSwitchPassive,
            value => HaltBrakeSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AtcAsrInformationSignal2565865982 {
    TakeNoAction,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for AtcAsrInformationSignal2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AtcAsrInformationSignal2565865982::TakeNoAction,
            2 => AtcAsrInformationSignal2565865982::Reserved,
            1 => AtcAsrInformationSignal2565865982::On,
            0 => AtcAsrInformationSignal2565865982::Off,
            value => AtcAsrInformationSignal2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AbsEbsAmberWarningSignal2565865982 {
    TakeNoAction,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for AbsEbsAmberWarningSignal2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AbsEbsAmberWarningSignal2565865982::TakeNoAction,
            2 => AbsEbsAmberWarningSignal2565865982::Reserved,
            1 => AbsEbsAmberWarningSignal2565865982::On,
            0 => AbsEbsAmberWarningSignal2565865982::Off,
            value => AbsEbsAmberWarningSignal2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EbsRedWarningSignal2565865982 {
    TakeNoAction,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EbsRedWarningSignal2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EbsRedWarningSignal2565865982::TakeNoAction,
            2 => EbsRedWarningSignal2565865982::Reserved,
            1 => EbsRedWarningSignal2565865982::On,
            0 => EbsRedWarningSignal2565865982::Off,
            value => EbsRedWarningSignal2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AbsFullyOperational2565865982 {
    NotAvailable,
    Reserved,
    FullyOperational,
    NotFullyOperational,
    XValue(u64),
}

impl From<u64> for AbsFullyOperational2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AbsFullyOperational2565865982::NotAvailable,
            2 => AbsFullyOperational2565865982::Reserved,
            1 => AbsFullyOperational2565865982::FullyOperational,
            0 => AbsFullyOperational2565865982::NotFullyOperational,
            value => AbsFullyOperational2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RemoteAccelEnableSwitch2565865982 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for RemoteAccelEnableSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RemoteAccelEnableSwitch2565865982::NotAvailable,
            2 => RemoteAccelEnableSwitch2565865982::Error,
            1 => RemoteAccelEnableSwitch2565865982::On,
            0 => RemoteAccelEnableSwitch2565865982::Off,
            value => RemoteAccelEnableSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngAuxEngShutdownSwitch2565865982 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngAuxEngShutdownSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngAuxEngShutdownSwitch2565865982::NotAvailable,
            2 => EngAuxEngShutdownSwitch2565865982::Error,
            1 => EngAuxEngShutdownSwitch2565865982::On,
            0 => EngAuxEngShutdownSwitch2565865982::Off,
            value => EngAuxEngShutdownSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngDerateSwitch2565865982 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngDerateSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngDerateSwitch2565865982::NotAvailable,
            2 => EngDerateSwitch2565865982::Error,
            1 => EngDerateSwitch2565865982::On,
            0 => EngDerateSwitch2565865982::Off,
            value => EngDerateSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccelInterlockSwitch2565865982 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for AccelInterlockSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccelInterlockSwitch2565865982::NotAvailable,
            2 => AccelInterlockSwitch2565865982::Error,
            1 => AccelInterlockSwitch2565865982::On,
            0 => AccelInterlockSwitch2565865982::Off,
            value => AccelInterlockSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractionCtrlOverrideSwitch2565865982 {
    NotAvailableNotInstalled,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for TractionCtrlOverrideSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TractionCtrlOverrideSwitch2565865982::NotAvailableNotInstalled,
            2 => TractionCtrlOverrideSwitch2565865982::Error,
            1 => TractionCtrlOverrideSwitch2565865982::On,
            0 => TractionCtrlOverrideSwitch2565865982::Off,
            value => TractionCtrlOverrideSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AsrHillHolderSwitch2565865982 {
    NotAvailable,
    Error,
    AsrHillHolderSwitchActive,
    AsrHillHolderSwitchPassive,
    XValue(u64),
}

impl From<u64> for AsrHillHolderSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AsrHillHolderSwitch2565865982::NotAvailable,
            2 => AsrHillHolderSwitch2565865982::Error,
            1 => AsrHillHolderSwitch2565865982::AsrHillHolderSwitchActive,
            0 => AsrHillHolderSwitch2565865982::AsrHillHolderSwitchPassive,
            value => AsrHillHolderSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AsrOffroadSwitch2565865982 {
    Error,
    AsrOffroadSwitchActive,
    AsrOffroadSwitchPassive,
    NotAvailable,
    XValue(u64),
}

impl From<u64> for AsrOffroadSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => AsrOffroadSwitch2565865982::Error,
            1 => AsrOffroadSwitch2565865982::AsrOffroadSwitchActive,
            0 => AsrOffroadSwitch2565865982::AsrOffroadSwitchPassive,
            3 => AsrOffroadSwitch2565865982::NotAvailable,
            value => AsrOffroadSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AbsOffroadSwitch2565865982 {
    NotAvailable,
    Error,
    AbsOffroadSwitchActive,
    AbsOffroadSwitchPassive,
    XValue(u64),
}

impl From<u64> for AbsOffroadSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AbsOffroadSwitch2565865982::NotAvailable,
            2 => AbsOffroadSwitch2565865982::Error,
            1 => AbsOffroadSwitch2565865982::AbsOffroadSwitchActive,
            0 => AbsOffroadSwitch2565865982::AbsOffroadSwitchPassive,
            value => AbsOffroadSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EbsBrakeSwitch2565865982 {
    NotAvailable,
    Error,
    BrakePedalIsBeingPressed,
    BrakePedalIsNotBeingPressed,
    XValue(u64),
}

impl From<u64> for EbsBrakeSwitch2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EbsBrakeSwitch2565865982::NotAvailable,
            2 => EbsBrakeSwitch2565865982::Error,
            1 => EbsBrakeSwitch2565865982::BrakePedalIsBeingPressed,
            0 => EbsBrakeSwitch2565865982::BrakePedalIsNotBeingPressed,
            value => EbsBrakeSwitch2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntiLockBrakingActive2565865982 {
    NotAvailable,
    Reserved,
    AbsActive,
    AbsPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for AntiLockBrakingActive2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntiLockBrakingActive2565865982::NotAvailable,
            2 => AntiLockBrakingActive2565865982::Reserved,
            1 => AntiLockBrakingActive2565865982::AbsActive,
            0 => AntiLockBrakingActive2565865982::AbsPassiveButInstalled,
            value => AntiLockBrakingActive2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AsrBrakeCtrlActive2565865982 {
    NotAvailable,
    Reserved,
    AsrBrakeCtrlActive,
    AsrBrakeCtrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for AsrBrakeCtrlActive2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AsrBrakeCtrlActive2565865982::NotAvailable,
            2 => AsrBrakeCtrlActive2565865982::Reserved,
            1 => AsrBrakeCtrlActive2565865982::AsrBrakeCtrlActive,
            0 => AsrBrakeCtrlActive2565865982::AsrBrakeCtrlPassiveButInstalled,
            value => AsrBrakeCtrlActive2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AsrEngCtrlActive2565865982 {
    NotAvailable,
    Reserved,
    AsrEngCtrlActive,
    AsrEngCtrlPassiveButInstalled,
    XValue(u64),
}

impl From<u64> for AsrEngCtrlActive2565865982 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AsrEngCtrlActive2565865982::NotAvailable,
            2 => AsrEngCtrlActive2565865982::Reserved,
            1 => AsrEngCtrlActive2565865982::AsrEngCtrlActive,
            0 => AsrEngCtrlActive2565865982::AsrEngCtrlPassiveButInstalled,
            value => AsrEngCtrlActive2565865982::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearAxleGroupEngagementStatus2565867262 {
    NotAvailable,
    Error,
    RearAxleGroupEngaged,
    RearAxleGroupDisengaged,
    XValue(u64),
}

impl From<u64> for RearAxleGroupEngagementStatus2565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RearAxleGroupEngagementStatus2565867262::NotAvailable,
            2 => RearAxleGroupEngagementStatus2565867262::Error,
            1 => RearAxleGroupEngagementStatus2565867262::RearAxleGroupEngaged,
            0 => RearAxleGroupEngagementStatus2565867262::RearAxleGroupDisengaged,
            value => RearAxleGroupEngagementStatus2565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontAxleGroupEngagementStatus2565867262 {
    NotAvailable,
    Error,
    FrontAxleGroupEngaged,
    FrontAxleGroupDisengaged,
    XValue(u64),
}

impl From<u64> for FrontAxleGroupEngagementStatus2565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FrontAxleGroupEngagementStatus2565867262::NotAvailable,
            2 => FrontAxleGroupEngagementStatus2565867262::Error,
            1 => FrontAxleGroupEngagementStatus2565867262::FrontAxleGroupEngaged,
            0 => FrontAxleGroupEngagementStatus2565867262::FrontAxleGroupDisengaged,
            value => FrontAxleGroupEngagementStatus2565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateCentralRear2565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateCentralRear2565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateCentralRear2565867262::NotAvailable,
            2 => DiffLockStateCentralRear2565867262::Error,
            1 => DiffLockStateCentralRear2565867262::DiffLockEngaged,
            0 => DiffLockStateCentralRear2565867262::DiffLockDisengaged,
            value => DiffLockStateCentralRear2565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateCentralFront2565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateCentralFront2565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateCentralFront2565867262::NotAvailable,
            2 => DiffLockStateCentralFront2565867262::Error,
            1 => DiffLockStateCentralFront2565867262::DiffLockEngaged,
            0 => DiffLockStateCentralFront2565867262::DiffLockDisengaged,
            value => DiffLockStateCentralFront2565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateCentral2565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateCentral2565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateCentral2565867262::NotAvailable,
            2 => DiffLockStateCentral2565867262::Error,
            1 => DiffLockStateCentral2565867262::DiffLockEngaged,
            0 => DiffLockStateCentral2565867262::DiffLockDisengaged,
            value => DiffLockStateCentral2565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateRearAxle22565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateRearAxle22565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateRearAxle22565867262::NotAvailable,
            2 => DiffLockStateRearAxle22565867262::Error,
            1 => DiffLockStateRearAxle22565867262::DiffLockEngaged,
            0 => DiffLockStateRearAxle22565867262::DiffLockDisengaged,
            value => DiffLockStateRearAxle22565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateRearAxle12565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateRearAxle12565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateRearAxle12565867262::NotAvailable,
            2 => DiffLockStateRearAxle12565867262::Error,
            1 => DiffLockStateRearAxle12565867262::DiffLockEngaged,
            0 => DiffLockStateRearAxle12565867262::DiffLockDisengaged,
            value => DiffLockStateRearAxle12565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateFrontAxle22565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateFrontAxle22565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateFrontAxle22565867262::NotAvailable,
            2 => DiffLockStateFrontAxle22565867262::Error,
            1 => DiffLockStateFrontAxle22565867262::DiffLockEngaged,
            0 => DiffLockStateFrontAxle22565867262::DiffLockDisengaged,
            value => DiffLockStateFrontAxle22565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DiffLockStateFrontAxle12565867262 {
    NotAvailable,
    Error,
    DiffLockEngaged,
    DiffLockDisengaged,
    XValue(u64),
}

impl From<u64> for DiffLockStateFrontAxle12565867262 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DiffLockStateFrontAxle12565867262::NotAvailable,
            2 => DiffLockStateFrontAxle12565867262::Error,
            1 => DiffLockStateFrontAxle12565867262::DiffLockEngaged,
            0 => DiffLockStateFrontAxle12565867262::DiffLockDisengaged,
            value => DiffLockStateFrontAxle12565867262::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngStartEnableDevice2Config2566768382 {
    NotAvailable,
    X1110reserved,
    ElectricInletAirHeaterInstalled,
    EtherInjectionInstalled,
    FuelledStartInstalled,
    GlowPlugsInstalled,
    NoStartEnableDevice2Installed,
    XValue(u64),
}

impl From<u64> for EngStartEnableDevice2Config2566768382 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngStartEnableDevice2Config2566768382::NotAvailable,
            5 => EngStartEnableDevice2Config2566768382::X1110reserved,
            4 => EngStartEnableDevice2Config2566768382::ElectricInletAirHeaterInstalled,
            3 => EngStartEnableDevice2Config2566768382::EtherInjectionInstalled,
            2 => EngStartEnableDevice2Config2566768382::FuelledStartInstalled,
            1 => EngStartEnableDevice2Config2566768382::GlowPlugsInstalled,
            0 => EngStartEnableDevice2Config2566768382::NoStartEnableDevice2Installed,
            value => EngStartEnableDevice2Config2566768382::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngStartEnableDevice1Config2566768382 {
    NotAvailable,
    X1110reserved,
    ElectricInletAirHeaterInstalled,
    EtherInjectionInstalled,
    FuelledStartInstalled,
    GlowPlugsInstalled,
    NoStartEnableDevice1Installed,
    XValue(u64),
}

impl From<u64> for EngStartEnableDevice1Config2566768382 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngStartEnableDevice1Config2566768382::NotAvailable,
            5 => EngStartEnableDevice1Config2566768382::X1110reserved,
            4 => EngStartEnableDevice1Config2566768382::ElectricInletAirHeaterInstalled,
            3 => EngStartEnableDevice1Config2566768382::EtherInjectionInstalled,
            2 => EngStartEnableDevice1Config2566768382::FuelledStartInstalled,
            1 => EngStartEnableDevice1Config2566768382::GlowPlugsInstalled,
            0 => EngStartEnableDevice1Config2566768382::NoStartEnableDevice1Installed,
            value => EngStartEnableDevice1Config2566768382::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngStartEnableDevice22566768382 {
    Reserved,
    StartEnableOn,
    StartEnableOff,
    XValue(u64),
}

impl From<u64> for EngStartEnableDevice22566768382 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => EngStartEnableDevice22566768382::Reserved,
            1 => EngStartEnableDevice22566768382::StartEnableOn,
            0 => EngStartEnableDevice22566768382::StartEnableOff,
            value => EngStartEnableDevice22566768382::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngStartEnableDevice12566768382 {
    NotAvailible,
    Reserved,
    StartEnableOn,
    StartEnableOff,
    XValue(u64),
}

impl From<u64> for EngStartEnableDevice12566768382 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngStartEnableDevice12566768382::NotAvailible,
            2 => EngStartEnableDevice12566768382::Reserved,
            1 => EngStartEnableDevice12566768382::StartEnableOn,
            0 => EngStartEnableDevice12566768382::StartEnableOff,
            value => EngStartEnableDevice12566768382::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransOilLevelRq2566771966 {
    DontCareTakeNoAction,
    Reserved,
    TransOilLevelReadingDesired,
    NoTransOilLevelReadingDesired,
    XValue(u64),
}

impl From<u64> for TransOilLevelRq2566771966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TransOilLevelRq2566771966::DontCareTakeNoAction,
            2 => TransOilLevelRq2566771966::Reserved,
            1 => TransOilLevelRq2566771966::TransOilLevelReadingDesired,
            0 => TransOilLevelRq2566771966::NoTransOilLevelReadingDesired,
            value => TransOilLevelRq2566771966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FifthWheelReleaseCtrl2566771966 {
    NotAvailable,
    Error,
    CplrUnlckdTrlrCnBUnhtchdHitched,
    CouplerLocked,
    XValue(u64),
}

impl From<u64> for FifthWheelReleaseCtrl2566771966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FifthWheelReleaseCtrl2566771966::NotAvailable,
            2 => FifthWheelReleaseCtrl2566771966::Error,
            1 => FifthWheelReleaseCtrl2566771966::CplrUnlckdTrlrCnBUnhtchdHitched,
            0 => FifthWheelReleaseCtrl2566771966::CouplerLocked,
            value => FifthWheelReleaseCtrl2566771966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FfthWhlRlaseCtrlSecurityLockout2566771966 {
    NotAvailable,
    Error,
    FifthWheelReleaseEnabled,
    FifthWheelReleaseDisabled,
    XValue(u64),
}

impl From<u64> for FfthWhlRlaseCtrlSecurityLockout2566771966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FfthWhlRlaseCtrlSecurityLockout2566771966::NotAvailable,
            2 => FfthWhlRlaseCtrlSecurityLockout2566771966::Error,
            1 => FfthWhlRlaseCtrlSecurityLockout2566771966::FifthWheelReleaseEnabled,
            0 => FfthWhlRlaseCtrlSecurityLockout2566771966::FifthWheelReleaseDisabled,
            value => FfthWhlRlaseCtrlSecurityLockout2566771966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransferCaseSelectorSwitch2566771966 {
    ErrorIndicator,
    X101reservedForSaeAssignment,
    Neutral,
    Wheel,
    XValue(u64),
}

impl From<u64> for TransferCaseSelectorSwitch2566771966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => TransferCaseSelectorSwitch2566771966::ErrorIndicator,
            3 => TransferCaseSelectorSwitch2566771966::X101reservedForSaeAssignment,
            2 => TransferCaseSelectorSwitch2566771966::Neutral,
            1 => TransferCaseSelectorSwitch2566771966::Wheel,
            value => TransferCaseSelectorSwitch2566771966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RqCabZoneHeating2564882174 {
    DontCareTakeNoAction,
    Reserved,
    HeatCabZone,
    DoNotCabEngZone,
    XValue(u64),
}

impl From<u64> for RqCabZoneHeating2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RqCabZoneHeating2564882174::DontCareTakeNoAction,
            2 => RqCabZoneHeating2564882174::Reserved,
            1 => RqCabZoneHeating2564882174::HeatCabZone,
            0 => RqCabZoneHeating2564882174::DoNotCabEngZone,
            value => RqCabZoneHeating2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RqEngZoneHeating2564882174 {
    DontCareTakeNoAction,
    Reserved,
    HeatEngZone,
    DoNotHeatEngZone,
    XValue(u64),
}

impl From<u64> for RqEngZoneHeating2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RqEngZoneHeating2564882174::DontCareTakeNoAction,
            2 => RqEngZoneHeating2564882174::Reserved,
            1 => RqEngZoneHeating2564882174::HeatEngZone,
            0 => RqEngZoneHeating2564882174::DoNotHeatEngZone,
            value => RqEngZoneHeating2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxHeaterModeRq2564882174 {
    DontCareTakeNoAction,
    Reserved,
    X1101notDefined,
    NormalMode,
    EconomyMode,
    OffDtadrPrErpnRgltnsFrTrnsprtOf,
    DeactivateAuxHeater,
    XValue(u64),
}

impl From<u64> for AuxHeaterModeRq2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => AuxHeaterModeRq2564882174::DontCareTakeNoAction,
            14 => AuxHeaterModeRq2564882174::Reserved,
            4 => AuxHeaterModeRq2564882174::X1101notDefined,
            3 => AuxHeaterModeRq2564882174::NormalMode,
            2 => AuxHeaterModeRq2564882174::EconomyMode,
            1 => AuxHeaterModeRq2564882174::OffDtadrPrErpnRgltnsFrTrnsprtOf,
            0 => AuxHeaterModeRq2564882174::DeactivateAuxHeater,
            value => AuxHeaterModeRq2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SeatBeltSwitch2564882174 {
    NotAvailable,
    ErrrSwtchStteCannotBeDetermined,
    OkSeatBeltIsBuckled,
    NotBuckled,
    XValue(u64),
}

impl From<u64> for SeatBeltSwitch2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SeatBeltSwitch2564882174::NotAvailable,
            2 => SeatBeltSwitch2564882174::ErrrSwtchStteCannotBeDetermined,
            1 => SeatBeltSwitch2564882174::OkSeatBeltIsBuckled,
            0 => SeatBeltSwitch2564882174::NotBuckled,
            value => SeatBeltSwitch2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OperatorSeatDirectionSwitch2564882174 {
    NotAvailable,
    Error,
    OperatorSeatIsFacingForward,
    OperatorSeatNotFacingForward,
    XValue(u64),
}

impl From<u64> for OperatorSeatDirectionSwitch2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => OperatorSeatDirectionSwitch2564882174::NotAvailable,
            2 => OperatorSeatDirectionSwitch2564882174::Error,
            1 => OperatorSeatDirectionSwitch2564882174::OperatorSeatIsFacingForward,
            0 => OperatorSeatDirectionSwitch2564882174::OperatorSeatNotFacingForward,
            value => OperatorSeatDirectionSwitch2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BatteryMainSwitchHoldRq2564882174 {
    DontCareTakeNoAction,
    Undefined,
    HoldBatteryMainSwitch,
    ReleaseBatteryMainSwitch,
    XValue(u64),
}

impl From<u64> for BatteryMainSwitchHoldRq2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BatteryMainSwitchHoldRq2564882174::DontCareTakeNoAction,
            2 => BatteryMainSwitchHoldRq2564882174::Undefined,
            1 => BatteryMainSwitchHoldRq2564882174::HoldBatteryMainSwitch,
            0 => BatteryMainSwitchHoldRq2564882174::ReleaseBatteryMainSwitch,
            value => BatteryMainSwitchHoldRq2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxHeaterCoolantPumpRq2564882174 {
    DontCareTakeNoAction,
    Reserved,
    ActivateWaterPump,
    DeactivateWaterPump,
    XValue(u64),
}

impl From<u64> for AuxHeaterCoolantPumpRq2564882174 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxHeaterCoolantPumpRq2564882174::DontCareTakeNoAction,
            2 => AuxHeaterCoolantPumpRq2564882174::Reserved,
            1 => AuxHeaterCoolantPumpRq2564882174::ActivateWaterPump,
            0 => AuxHeaterCoolantPumpRq2564882174::DeactivateWaterPump,
            value => AuxHeaterCoolantPumpRq2564882174::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParkBrakeReleaseInhibitRq2566844926 {
    Unavailable,
    SaeReserved,
    ParkBrakeReleaseInhibitRqed,
    ParkBrakeReleaseInhibitNotRqed,
    XValue(u64),
}

impl From<u64> for ParkBrakeReleaseInhibitRq2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ParkBrakeReleaseInhibitRq2566844926::Unavailable,
            2 => ParkBrakeReleaseInhibitRq2566844926::SaeReserved,
            1 => ParkBrakeReleaseInhibitRq2566844926::ParkBrakeReleaseInhibitRqed,
            0 => ParkBrakeReleaseInhibitRq2566844926::ParkBrakeReleaseInhibitNotRqed,
            value => ParkBrakeReleaseInhibitRq2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngShutdownOverrideSwitch2566844926 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngShutdownOverrideSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngShutdownOverrideSwitch2566844926::NotAvailable,
            2 => EngShutdownOverrideSwitch2566844926::Error,
            1 => EngShutdownOverrideSwitch2566844926::On,
            0 => EngShutdownOverrideSwitch2566844926::Off,
            value => EngShutdownOverrideSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngTestModeSwitch2566844926 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngTestModeSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngTestModeSwitch2566844926::NotAvailable,
            2 => EngTestModeSwitch2566844926::Error,
            1 => EngTestModeSwitch2566844926::On,
            0 => EngTestModeSwitch2566844926::Off,
            value => EngTestModeSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleDecrementSwitch2566844926 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngIdleDecrementSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngIdleDecrementSwitch2566844926::NotAvailable,
            2 => EngIdleDecrementSwitch2566844926::Error,
            1 => EngIdleDecrementSwitch2566844926::On,
            0 => EngIdleDecrementSwitch2566844926::Off,
            value => EngIdleDecrementSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngIdleIncrementSwitch2566844926 {
    NotAvailable,
    Error,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for EngIdleIncrementSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => EngIdleIncrementSwitch2566844926::NotAvailable,
            2 => EngIdleIncrementSwitch2566844926::Error,
            1 => EngIdleIncrementSwitch2566844926::On,
            0 => EngIdleIncrementSwitch2566844926::Off,
            value => EngIdleIncrementSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlAccelerateSwitch2566844926 {
    NotAvailable,
    Error,
    CrsCtrlActivatorInPosAccelerate,
    CrsCtrlActvtrNotInPosAccelerate,
    XValue(u64),
}

impl From<u64> for CruiseCtrlAccelerateSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlAccelerateSwitch2566844926::NotAvailable,
            2 => CruiseCtrlAccelerateSwitch2566844926::Error,
            1 => CruiseCtrlAccelerateSwitch2566844926::CrsCtrlActivatorInPosAccelerate,
            0 => CruiseCtrlAccelerateSwitch2566844926::CrsCtrlActvtrNotInPosAccelerate,
            value => CruiseCtrlAccelerateSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlResumeSwitch2566844926 {
    NotAvailable,
    Error,
    CruiseCtrlActivatorInPosResume,
    CrseCtrlActivatorNotInPosResume,
    XValue(u64),
}

impl From<u64> for CruiseCtrlResumeSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlResumeSwitch2566844926::NotAvailable,
            2 => CruiseCtrlResumeSwitch2566844926::Error,
            1 => CruiseCtrlResumeSwitch2566844926::CruiseCtrlActivatorInPosResume,
            0 => CruiseCtrlResumeSwitch2566844926::CrseCtrlActivatorNotInPosResume,
            value => CruiseCtrlResumeSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlCoastSwitch2566844926 {
    NotAvailable,
    Error,
    CruiseCtrlActivatorInPosCoast,
    CriseCtrlActivatorNotInPosCoast,
    XValue(u64),
}

impl From<u64> for CruiseCtrlCoastSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlCoastSwitch2566844926::NotAvailable,
            2 => CruiseCtrlCoastSwitch2566844926::Error,
            1 => CruiseCtrlCoastSwitch2566844926::CruiseCtrlActivatorInPosCoast,
            0 => CruiseCtrlCoastSwitch2566844926::CriseCtrlActivatorNotInPosCoast,
            value => CruiseCtrlCoastSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlSetSwitch2566844926 {
    NotAvailable,
    Error,
    CruiseCtrlActivatorInPosSet,
    CruiseCtrlActivatorNotInPosSet,
    XValue(u64),
}

impl From<u64> for CruiseCtrlSetSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlSetSwitch2566844926::NotAvailable,
            2 => CruiseCtrlSetSwitch2566844926::Error,
            1 => CruiseCtrlSetSwitch2566844926::CruiseCtrlActivatorInPosSet,
            0 => CruiseCtrlSetSwitch2566844926::CruiseCtrlActivatorNotInPosSet,
            value => CruiseCtrlSetSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ClutchSwitch2566844926 {
    NotAvailable,
    Error,
    ClutchPedalDepressed,
    ClutchPedalReleased,
    XValue(u64),
}

impl From<u64> for ClutchSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ClutchSwitch2566844926::NotAvailable,
            2 => ClutchSwitch2566844926::Error,
            1 => ClutchSwitch2566844926::ClutchPedalDepressed,
            0 => ClutchSwitch2566844926::ClutchPedalReleased,
            value => ClutchSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BrakeSwitch2566844926 {
    NotAvailable,
    Error,
    BrakePedalDepressed,
    BrakePedalReleased,
    XValue(u64),
}

impl From<u64> for BrakeSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BrakeSwitch2566844926::NotAvailable,
            2 => BrakeSwitch2566844926::Error,
            1 => BrakeSwitch2566844926::BrakePedalDepressed,
            0 => BrakeSwitch2566844926::BrakePedalReleased,
            value => BrakeSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlEnableSwitch2566844926 {
    NotAvailable,
    Error,
    CruiseCtrlEnabled,
    CruiseCtrlDisabled,
    XValue(u64),
}

impl From<u64> for CruiseCtrlEnableSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlEnableSwitch2566844926::NotAvailable,
            2 => CruiseCtrlEnableSwitch2566844926::Error,
            1 => CruiseCtrlEnableSwitch2566844926::CruiseCtrlEnabled,
            0 => CruiseCtrlEnableSwitch2566844926::CruiseCtrlDisabled,
            value => CruiseCtrlEnableSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlActive2566844926 {
    NotAvailable,
    Error,
    CruiseCtrlSwitchedOn,
    CruiseCtrlSwitchedOff,
    XValue(u64),
}

impl From<u64> for CruiseCtrlActive2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlActive2566844926::NotAvailable,
            2 => CruiseCtrlActive2566844926::Error,
            1 => CruiseCtrlActive2566844926::CruiseCtrlSwitchedOn,
            0 => CruiseCtrlActive2566844926::CruiseCtrlSwitchedOff,
            value => CruiseCtrlActive2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CruiseCtrlPauseSwitch2566844926 {
    TakeNoAction,
    ErrorIndicator,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for CruiseCtrlPauseSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CruiseCtrlPauseSwitch2566844926::TakeNoAction,
            2 => CruiseCtrlPauseSwitch2566844926::ErrorIndicator,
            1 => CruiseCtrlPauseSwitch2566844926::On,
            0 => CruiseCtrlPauseSwitch2566844926::Off,
            value => CruiseCtrlPauseSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParkingBrakeSwitch2566844926 {
    NotAvailable,
    Error,
    ParkingBrakeSet,
    ParkingBrakeNotSet,
    XValue(u64),
}

impl From<u64> for ParkingBrakeSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ParkingBrakeSwitch2566844926::NotAvailable,
            2 => ParkingBrakeSwitch2566844926::Error,
            1 => ParkingBrakeSwitch2566844926::ParkingBrakeSet,
            0 => ParkingBrakeSwitch2566844926::ParkingBrakeNotSet,
            value => ParkingBrakeSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TwoSpeedAxleSwitch2566844926 {
    NotAvailable,
    Error,
    HighSpeedRange,
    LowSpeedRange,
    XValue(u64),
}

impl From<u64> for TwoSpeedAxleSwitch2566844926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => TwoSpeedAxleSwitch2566844926::NotAvailable,
            2 => TwoSpeedAxleSwitch2566844926::Error,
            1 => TwoSpeedAxleSwitch2566844926::HighSpeedRange,
            0 => TwoSpeedAxleSwitch2566844926::LowSpeedRange,
            value => TwoSpeedAxleSwitch2566844926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BatteryMainSwitchHoldState2566809342 {
    DontCareTakeNoAction,
    Reserved,
    BatteryMainSwitchHeld,
    BatteryMainSwitchNotHeld,
    XValue(u64),
}

impl From<u64> for BatteryMainSwitchHoldState2566809342 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BatteryMainSwitchHoldState2566809342::DontCareTakeNoAction,
            2 => BatteryMainSwitchHoldState2566809342::Reserved,
            1 => BatteryMainSwitchHoldState2566809342::BatteryMainSwitchHeld,
            0 => BatteryMainSwitchHoldState2566809342::BatteryMainSwitchNotHeld,
            value => BatteryMainSwitchHoldState2566809342::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3XAxisDetentPosStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Joystick3XAxisDetentPosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3XAxisDetentPosStatus2365446910::NotAvailable,
            2 => Joystick3XAxisDetentPosStatus2365446910::ErrorIndicator,
            1 => Joystick3XAxisDetentPosStatus2365446910::InDetentPos,
            0 => Joystick3XAxisDetentPosStatus2365446910::NotInDetentPos,
            value => Joystick3XAxisDetentPosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button9PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button9PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button9PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button9PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button9PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button9PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button9PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button10PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button10PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button10PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button10PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button10PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button10PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button10PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button11PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button11PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button11PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button11PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button11PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button11PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button11PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button12PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button12PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button12PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button12PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button12PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button12PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button12PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3YAxisDetentPosStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Joystick3YAxisDetentPosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3YAxisDetentPosStatus2365446910::NotAvailable,
            2 => Joystick3YAxisDetentPosStatus2365446910::ErrorIndicator,
            1 => Joystick3YAxisDetentPosStatus2365446910::InDetentPos,
            0 => Joystick3YAxisDetentPosStatus2365446910::NotInDetentPos,
            value => Joystick3YAxisDetentPosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3YAxsLvrFrwrdPstvPsStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3YAxsLvrFrwrdPstvPsStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3YAxsLvrFrwrdPstvPsStatus2365446910::NotAvailable,
            2 => Jystck3YAxsLvrFrwrdPstvPsStatus2365446910::ErrorIndicator,
            1 => Jystck3YAxsLvrFrwrdPstvPsStatus2365446910::OnPositiveSideOfNeutral,
            0 => Jystck3YAxsLvrFrwrdPstvPsStatus2365446910::NotOnPositiveSideOfNeutral,
            value => Jystck3YAxsLvrFrwrdPstvPsStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3YAxsLvrBckNgtvePosStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3YAxsLvrBckNgtvePosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3YAxsLvrBckNgtvePosStatus2365446910::NotAvailable,
            2 => Jystck3YAxsLvrBckNgtvePosStatus2365446910::ErrorIndicator,
            1 => Jystck3YAxsLvrBckNgtvePosStatus2365446910::OnNegativeSideOfNeutral,
            0 => Jystck3YAxsLvrBckNgtvePosStatus2365446910::NotOnNegativeSideOfNeutral,
            value => Jystck3YAxsLvrBckNgtvePosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3YAxisNeutralPosStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Joystick3YAxisNeutralPosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3YAxisNeutralPosStatus2365446910::NotAvailable,
            2 => Joystick3YAxisNeutralPosStatus2365446910::ErrorIndicator,
            1 => Joystick3YAxisNeutralPosStatus2365446910::InNeutralPos,
            0 => Joystick3YAxisNeutralPosStatus2365446910::NotInNeutralPos,
            value => Joystick3YAxisNeutralPosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3XAxsLvrRghtPstvPosStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck3XAxsLvrRghtPstvPosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck3XAxsLvrRghtPstvPosStatus2365446910::NotAvailable,
            2 => Jystck3XAxsLvrRghtPstvPosStatus2365446910::ErrorIndicator,
            1 => Jystck3XAxsLvrRghtPstvPosStatus2365446910::OnPositiveSideOfNeutral,
            0 => Jystck3XAxsLvrRghtPstvPosStatus2365446910::NotOnPositiveSideOfNeutral,
            value => Jystck3XAxsLvrRghtPstvPosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck3XAxsLvrLftNgtvePosStatus2365446910 {
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    NotAvailable,
    XValue(u64),
}

impl From<u64> for Jystck3XAxsLvrLftNgtvePosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => Jystck3XAxsLvrLftNgtvePosStatus2365446910::ErrorIndicator,
            1 => Jystck3XAxsLvrLftNgtvePosStatus2365446910::OnNegativeSideOfNeutral,
            0 => Jystck3XAxsLvrLftNgtvePosStatus2365446910::NotOnNegativeSideOfNeutral,
            3 => Jystck3XAxsLvrLftNgtvePosStatus2365446910::NotAvailable,
            value => Jystck3XAxsLvrLftNgtvePosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3XAxisNeutralPosStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Joystick3XAxisNeutralPosStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3XAxisNeutralPosStatus2365446910::NotAvailable,
            2 => Joystick3XAxisNeutralPosStatus2365446910::ErrorIndicator,
            1 => Joystick3XAxisNeutralPosStatus2365446910::InNeutralPos,
            0 => Joystick3XAxisNeutralPosStatus2365446910::NotInNeutralPos,
            value => Joystick3XAxisNeutralPosStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button5PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button5PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button5PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button5PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button5PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button5PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button5PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button6PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button6PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button6PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button6PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button6PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button6PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button6PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button7PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button7PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button7PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button7PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button7PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button7PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button7PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button8PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button8PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button8PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button8PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button8PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button8PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button8PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button1PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button1PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button1PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button1PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button1PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button1PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button1PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button2PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button2PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button2PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button2PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button2PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button2PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button2PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button3PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button3PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button3PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button3PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button3PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button3PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button3PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick3Button4PressedStatus2365446910 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick3Button4PressedStatus2365446910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick3Button4PressedStatus2365446910::NotAvailable,
            2 => Joystick3Button4PressedStatus2365446910::ErrorIndicator,
            1 => Joystick3Button4PressedStatus2365446910::ButtonPressed,
            0 => Joystick3Button4PressedStatus2365446910::ButtonNotPressed,
            value => Joystick3Button4PressedStatus2365446910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2XAxisDetentPosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Joystick2XAxisDetentPosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2XAxisDetentPosStatus2365446398::NotAvailable,
            2 => Joystick2XAxisDetentPosStatus2365446398::ErrorIndicator,
            1 => Joystick2XAxisDetentPosStatus2365446398::InDetentPos,
            0 => Joystick2XAxisDetentPosStatus2365446398::NotInDetentPos,
            value => Joystick2XAxisDetentPosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2YAxisDetentPosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Joystick2YAxisDetentPosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2YAxisDetentPosStatus2365446398::NotAvailable,
            2 => Joystick2YAxisDetentPosStatus2365446398::ErrorIndicator,
            1 => Joystick2YAxisDetentPosStatus2365446398::InDetentPos,
            0 => Joystick2YAxisDetentPosStatus2365446398::NotInDetentPos,
            value => Joystick2YAxisDetentPosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2YAxsLvrFrwrdPstvPsStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2YAxsLvrFrwrdPstvPsStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2YAxsLvrFrwrdPstvPsStatus2365446398::NotAvailable,
            2 => Jystck2YAxsLvrFrwrdPstvPsStatus2365446398::ErrorIndicator,
            1 => Jystck2YAxsLvrFrwrdPstvPsStatus2365446398::OnPositiveSideOfNeutral,
            0 => Jystck2YAxsLvrFrwrdPstvPsStatus2365446398::NotOnPositiveSideOfNeutral,
            value => Jystck2YAxsLvrFrwrdPstvPsStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2YAxsLvrBckNgtvePosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2YAxsLvrBckNgtvePosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2YAxsLvrBckNgtvePosStatus2365446398::NotAvailable,
            2 => Jystck2YAxsLvrBckNgtvePosStatus2365446398::ErrorIndicator,
            1 => Jystck2YAxsLvrBckNgtvePosStatus2365446398::OnNegativeSideOfNeutral,
            0 => Jystck2YAxsLvrBckNgtvePosStatus2365446398::NotOnNegativeSideOfNeutral,
            value => Jystck2YAxsLvrBckNgtvePosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2YAxisNeutralPosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Joystick2YAxisNeutralPosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2YAxisNeutralPosStatus2365446398::NotAvailable,
            2 => Joystick2YAxisNeutralPosStatus2365446398::ErrorIndicator,
            1 => Joystick2YAxisNeutralPosStatus2365446398::InNeutralPos,
            0 => Joystick2YAxisNeutralPosStatus2365446398::NotInNeutralPos,
            value => Joystick2YAxisNeutralPosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2XAxsLvrRghtPstvPosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2XAxsLvrRghtPstvPosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2XAxsLvrRghtPstvPosStatus2365446398::NotAvailable,
            2 => Jystck2XAxsLvrRghtPstvPosStatus2365446398::ErrorIndicator,
            1 => Jystck2XAxsLvrRghtPstvPosStatus2365446398::OnPositiveSideOfNeutral,
            0 => Jystck2XAxsLvrRghtPstvPosStatus2365446398::NotOnPositiveSideOfNeutral,
            value => Jystck2XAxsLvrRghtPstvPosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck2XAxsLvrLftNgtvePosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck2XAxsLvrLftNgtvePosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck2XAxsLvrLftNgtvePosStatus2365446398::NotAvailable,
            2 => Jystck2XAxsLvrLftNgtvePosStatus2365446398::ErrorIndicator,
            1 => Jystck2XAxsLvrLftNgtvePosStatus2365446398::OnNegativeSideOfNeutral,
            0 => Jystck2XAxsLvrLftNgtvePosStatus2365446398::NotOnNegativeSideOfNeutral,
            value => Jystck2XAxsLvrLftNgtvePosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2XAxisNeutralPosStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Joystick2XAxisNeutralPosStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2XAxisNeutralPosStatus2365446398::NotAvailable,
            2 => Joystick2XAxisNeutralPosStatus2365446398::ErrorIndicator,
            1 => Joystick2XAxisNeutralPosStatus2365446398::InNeutralPos,
            0 => Joystick2XAxisNeutralPosStatus2365446398::NotInNeutralPos,
            value => Joystick2XAxisNeutralPosStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button9PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button9PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button9PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button9PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button9PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button9PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button9PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button10PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button10PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button10PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button10PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button10PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button10PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button10PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button11PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button11PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button11PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button11PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button11PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button11PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button11PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button12PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button12PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button12PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button12PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button12PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button12PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button12PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button5PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button5PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button5PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button5PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button5PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button5PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button5PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button6PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button6PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button6PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button6PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button6PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button6PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button6PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button7PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button7PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button7PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button7PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button7PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button7PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button7PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button8PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button8PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button8PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button8PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button8PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button8PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button8PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button1PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button1PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button1PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button1PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button1PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button1PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button1PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button2PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button2PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button2PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button2PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button2PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button2PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button2PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button3PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button3PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button3PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button3PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button3PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button3PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button3PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick2Button4PressedStatus2365446398 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick2Button4PressedStatus2365446398 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick2Button4PressedStatus2365446398::NotAvailable,
            2 => Joystick2Button4PressedStatus2365446398::ErrorIndicator,
            1 => Joystick2Button4PressedStatus2365446398::ButtonPressed,
            0 => Joystick2Button4PressedStatus2365446398::ButtonNotPressed,
            value => Joystick2Button4PressedStatus2365446398::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1XAxisDetentPosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Joystick1XAxisDetentPosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1XAxisDetentPosStatus2365445886::NotAvailable,
            2 => Joystick1XAxisDetentPosStatus2365445886::ErrorIndicator,
            1 => Joystick1XAxisDetentPosStatus2365445886::InDetentPos,
            0 => Joystick1XAxisDetentPosStatus2365445886::NotInDetentPos,
            value => Joystick1XAxisDetentPosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1YAxisDetentPosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    InDetentPos,
    NotInDetentPos,
    XValue(u64),
}

impl From<u64> for Joystick1YAxisDetentPosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1YAxisDetentPosStatus2365445886::NotAvailable,
            2 => Joystick1YAxisDetentPosStatus2365445886::ErrorIndicator,
            1 => Joystick1YAxisDetentPosStatus2365445886::InDetentPos,
            0 => Joystick1YAxisDetentPosStatus2365445886::NotInDetentPos,
            value => Joystick1YAxisDetentPosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1YAxsLvrFrwrdPstvPsStatus2365445886 {
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    NotAvailable,
    ErrorIndicator,
    XValue(u64),
}

impl From<u64> for Jystck1YAxsLvrFrwrdPstvPsStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => Jystck1YAxsLvrFrwrdPstvPsStatus2365445886::OnPositiveSideOfNeutral,
            0 => Jystck1YAxsLvrFrwrdPstvPsStatus2365445886::NotOnPositiveSideOfNeutral,
            3 => Jystck1YAxsLvrFrwrdPstvPsStatus2365445886::NotAvailable,
            2 => Jystck1YAxsLvrFrwrdPstvPsStatus2365445886::ErrorIndicator,
            value => Jystck1YAxsLvrFrwrdPstvPsStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1YAxsLvrBckNgtvePosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1YAxsLvrBckNgtvePosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1YAxsLvrBckNgtvePosStatus2365445886::NotAvailable,
            2 => Jystck1YAxsLvrBckNgtvePosStatus2365445886::ErrorIndicator,
            1 => Jystck1YAxsLvrBckNgtvePosStatus2365445886::OnNegativeSideOfNeutral,
            0 => Jystck1YAxsLvrBckNgtvePosStatus2365445886::NotOnNegativeSideOfNeutral,
            value => Jystck1YAxsLvrBckNgtvePosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1YAxisNeutralPosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Joystick1YAxisNeutralPosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1YAxisNeutralPosStatus2365445886::NotAvailable,
            2 => Joystick1YAxisNeutralPosStatus2365445886::ErrorIndicator,
            1 => Joystick1YAxisNeutralPosStatus2365445886::InNeutralPos,
            0 => Joystick1YAxisNeutralPosStatus2365445886::NotInNeutralPos,
            value => Joystick1YAxisNeutralPosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button9PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button9PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button9PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button9PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button9PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button9PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button9PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button10PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button10PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button10PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button10PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button10PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button10PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button10PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button11PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button11PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button11PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button11PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button11PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button11PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button11PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button12PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button12PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button12PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button12PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button12PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button12PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button12PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button5PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button5PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button5PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button5PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button5PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button5PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button5PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button6PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button6PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button6PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button6PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button6PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button6PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button6PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button7PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button7PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button7PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button7PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button7PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button7PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button7PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button8PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button8PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button8PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button8PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button8PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button8PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button8PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button1PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button1PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button1PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button1PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button1PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button1PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button1PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button2PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button2PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button2PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button2PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button2PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button2PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button2PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button3PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button3PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button3PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button3PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button3PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button3PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button3PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1Button4PressedStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    ButtonPressed,
    ButtonNotPressed,
    XValue(u64),
}

impl From<u64> for Joystick1Button4PressedStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1Button4PressedStatus2365445886::NotAvailable,
            2 => Joystick1Button4PressedStatus2365445886::ErrorIndicator,
            1 => Joystick1Button4PressedStatus2365445886::ButtonPressed,
            0 => Joystick1Button4PressedStatus2365445886::ButtonNotPressed,
            value => Joystick1Button4PressedStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1XAxsLvrRghtPstvPosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    OnPositiveSideOfNeutral,
    NotOnPositiveSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1XAxsLvrRghtPstvPosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1XAxsLvrRghtPstvPosStatus2365445886::NotAvailable,
            2 => Jystck1XAxsLvrRghtPstvPosStatus2365445886::ErrorIndicator,
            1 => Jystck1XAxsLvrRghtPstvPosStatus2365445886::OnPositiveSideOfNeutral,
            0 => Jystck1XAxsLvrRghtPstvPosStatus2365445886::NotOnPositiveSideOfNeutral,
            value => Jystck1XAxsLvrRghtPstvPosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Jystck1XAxsLvrLftNgtvePosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    OnNegativeSideOfNeutral,
    NotOnNegativeSideOfNeutral,
    XValue(u64),
}

impl From<u64> for Jystck1XAxsLvrLftNgtvePosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Jystck1XAxsLvrLftNgtvePosStatus2365445886::NotAvailable,
            2 => Jystck1XAxsLvrLftNgtvePosStatus2365445886::ErrorIndicator,
            1 => Jystck1XAxsLvrLftNgtvePosStatus2365445886::OnNegativeSideOfNeutral,
            0 => Jystck1XAxsLvrLftNgtvePosStatus2365445886::NotOnNegativeSideOfNeutral,
            value => Jystck1XAxsLvrLftNgtvePosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Joystick1XAxisNeutralPosStatus2365445886 {
    NotAvailable,
    ErrorIndicator,
    InNeutralPos,
    NotInNeutralPos,
    XValue(u64),
}

impl From<u64> for Joystick1XAxisNeutralPosStatus2365445886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Joystick1XAxisNeutralPosStatus2365445886::NotAvailable,
            2 => Joystick1XAxisNeutralPosStatus2365445886::ErrorIndicator,
            1 => Joystick1XAxisNeutralPosStatus2365445886::InNeutralPos,
            0 => Joystick1XAxisNeutralPosStatus2365445886::NotInNeutralPos,
            value => Joystick1XAxisNeutralPosStatus2365445886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParkingBrakeRedWarningSignal2566847230 {
    TakeNoAction,
    Reserved,
    On,
    Off,
    XValue(u64),
}

impl From<u64> for ParkingBrakeRedWarningSignal2566847230 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ParkingBrakeRedWarningSignal2566847230::TakeNoAction,
            2 => ParkingBrakeRedWarningSignal2566847230::Reserved,
            1 => ParkingBrakeRedWarningSignal2566847230::On,
            0 => ParkingBrakeRedWarningSignal2566847230::Off,
            value => ParkingBrakeRedWarningSignal2566847230::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParkBrakeReleaseInhibitStatus2566847230 {
    Unavailable,
    Error,
    ParkBrakeReleaseIsInhibited,
    ParkBrakeReleaseIsNotInhibited,
    XValue(u64),
}

impl From<u64> for ParkBrakeReleaseInhibitStatus2566847230 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ParkBrakeReleaseInhibitStatus2566847230::Unavailable,
            2 => ParkBrakeReleaseInhibitStatus2566847230::Error,
            1 => ParkBrakeReleaseInhibitStatus2566847230::ParkBrakeReleaseIsInhibited,
            0 => ParkBrakeReleaseInhibitStatus2566847230::ParkBrakeReleaseIsNotInhibited,
            value => ParkBrakeReleaseInhibitStatus2566847230::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParkingBrakeActuator2566847230 {
    NotAvailable,
    Error,
    ParkingBrakeActuatorActive,
    ParkingBrakeActuatorInactive,
    XValue(u64),
}

impl From<u64> for ParkingBrakeActuator2566847230 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ParkingBrakeActuator2566847230::NotAvailable,
            2 => ParkingBrakeActuator2566847230::Error,
            1 => ParkingBrakeActuator2566847230::ParkingBrakeActuatorActive,
            0 => ParkingBrakeActuator2566847230::ParkingBrakeActuatorInactive,
            value => ParkingBrakeActuator2566847230::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntitheftComponentStatusStates2631728894 {
    NotDefined,
    BlckdThsSttIndctsThtALckUnlckCm,
    Locked,
    UnlckdThsSttIndctsThtCmpnntCnBs,
    XValue(u64),
}

impl From<u64> for AntitheftComponentStatusStates2631728894 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntitheftComponentStatusStates2631728894::NotDefined,
            2 => AntitheftComponentStatusStates2631728894::BlckdThsSttIndctsThtALckUnlckCm,
            1 => AntitheftComponentStatusStates2631728894::Locked,
            0 => AntitheftComponentStatusStates2631728894::UnlckdThsSttIndctsThtCmpnntCnBs,
            value => AntitheftComponentStatusStates2631728894::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntthftEncryptnSdPrsntIndicator2631728894 {
    NotAvailable,
    Error,
    RandomNumberIsPresent,
    RandomNumberIsNotPresent,
    XValue(u64),
}

impl From<u64> for AntthftEncryptnSdPrsntIndicator2631728894 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntthftEncryptnSdPrsntIndicator2631728894::NotAvailable,
            2 => AntthftEncryptnSdPrsntIndicator2631728894::Error,
            1 => AntthftEncryptnSdPrsntIndicator2631728894::RandomNumberIsPresent,
            0 => AntthftEncryptnSdPrsntIndicator2631728894::RandomNumberIsNotPresent,
            value => AntthftEncryptnSdPrsntIndicator2631728894::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntitheftModifyPwdStates2631728894 {
    Notvalid,
    EmptyOfPwdsThsSttIndctsThtCmpnn,
    FullofPwds,
    OkThsSttIndctsThtRqWsSccssfllyP,
    XValue(u64),
}

impl From<u64> for AntitheftModifyPwdStates2631728894 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntitheftModifyPwdStates2631728894::Notvalid,
            2 => AntitheftModifyPwdStates2631728894::EmptyOfPwdsThsSttIndctsThtCmpnn,
            1 => AntitheftModifyPwdStates2631728894::FullofPwds,
            0 => AntitheftModifyPwdStates2631728894::OkThsSttIndctsThtRqWsSccssfllyP,
            value => AntitheftModifyPwdStates2631728894::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntitheftPwdValidIndicator2631728894 {
    NotAvailable,
    Error,
    PwdIsAValidatedPassword,
    PwdIsNotAValidatedPassword,
    XValue(u64),
}

impl From<u64> for AntitheftPwdValidIndicator2631728894 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntitheftPwdValidIndicator2631728894::NotAvailable,
            2 => AntitheftPwdValidIndicator2631728894::Error,
            1 => AntitheftPwdValidIndicator2631728894::PwdIsAValidatedPassword,
            0 => AntitheftPwdValidIndicator2631728894::PwdIsNotAValidatedPassword,
            value => AntitheftPwdValidIndicator2631728894::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntitheftCmdStates2631794430 {
    X111notDefined,
    Login,
    ChckSttsThsSttRprsntsARqTChckTs,
    LockorUnlock,
    ChngPwdThsSttRprsntsARqTCmpnntT,
    DeletePwd,
    AddPwdThsSttRprsntsARqTCmpnntTa,
    XValue(u64),
}

impl From<u64> for AntitheftCmdStates2631794430 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            6 => AntitheftCmdStates2631794430::X111notDefined,
            5 => AntitheftCmdStates2631794430::Login,
            4 => AntitheftCmdStates2631794430::ChckSttsThsSttRprsntsARqTChckTs,
            3 => AntitheftCmdStates2631794430::LockorUnlock,
            2 => AntitheftCmdStates2631794430::ChngPwdThsSttRprsntsARqTCmpnntT,
            1 => AntitheftCmdStates2631794430::DeletePwd,
            0 => AntitheftCmdStates2631794430::AddPwdThsSttRprsntsARqTCmpnntTa,
            value => AntitheftCmdStates2631794430::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntitheftDesiredExitModeStates2631794430 {
    NotAvailable,
    NotDefined,
    LockWhenKeyOff,
    LckUpnOprtrRqThsSttIsUsdTIndctT,
    XValue(u64),
}

impl From<u64> for AntitheftDesiredExitModeStates2631794430 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntitheftDesiredExitModeStates2631794430::NotAvailable,
            2 => AntitheftDesiredExitModeStates2631794430::NotDefined,
            1 => AntitheftDesiredExitModeStates2631794430::LockWhenKeyOff,
            0 => AntitheftDesiredExitModeStates2631794430::LckUpnOprtrRqThsSttIsUsdTIndctT,
            value => AntitheftDesiredExitModeStates2631794430::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AntthftEncryptonIndicatorStates2631794430 {
    NotAvailable,
    NotDefined,
    EncryptedCodePresent,
    EncryptnSdRqThsSttRprsntsARqstT,
    XValue(u64),
}

impl From<u64> for AntthftEncryptonIndicatorStates2631794430 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AntthftEncryptonIndicatorStates2631794430::NotAvailable,
            2 => AntthftEncryptonIndicatorStates2631794430::NotDefined,
            1 => AntthftEncryptonIndicatorStates2631794430::EncryptedCodePresent,
            0 => AntthftEncryptonIndicatorStates2631794430::EncryptnSdRqThsSttRprsntsARqstT,
            value => AntthftEncryptonIndicatorStates2631794430::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910 {
    NotAvailable,
    Error,
    NormalOperationDampersActive,
    NormalOperationDampersPassive,
    XValue(u64),
}

impl From<u64> for ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910::NotAvailable,
            2 => ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910::Error,
            1 => ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910::NormalOperationDampersActive,
            0 => ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910::NormalOperationDampersPassive,
            value => ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ElctrncShckAbsrbrCtrlMdRearAxle2365478910 {
    NotAvailable,
    Error,
    NormalOperationDampersActive,
    NormalOperationDampersPassive,
    XValue(u64),
}

impl From<u64> for ElctrncShckAbsrbrCtrlMdRearAxle2365478910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ElctrncShckAbsrbrCtrlMdRearAxle2365478910::NotAvailable,
            2 => ElctrncShckAbsrbrCtrlMdRearAxle2365478910::Error,
            1 => ElctrncShckAbsrbrCtrlMdRearAxle2365478910::NormalOperationDampersActive,
            0 => ElctrncShckAbsrbrCtrlMdRearAxle2365478910::NormalOperationDampersPassive,
            value => ElctrncShckAbsrbrCtrlMdRearAxle2365478910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ElctrncShckAbsrbrCtrlMdFrntAxle2365478910 {
    NotAvailable,
    Error,
    NormalOperationDampersActive,
    NormalOperationDampersPassive,
    XValue(u64),
}

impl From<u64> for ElctrncShckAbsrbrCtrlMdFrntAxle2365478910 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ElctrncShckAbsrbrCtrlMdFrntAxle2365478910::NotAvailable,
            2 => ElctrncShckAbsrbrCtrlMdFrntAxle2365478910::Error,
            1 => ElctrncShckAbsrbrCtrlMdFrntAxle2365478910::NormalOperationDampersActive,
            0 => ElctrncShckAbsrbrCtrlMdFrntAxle2365478910::NormalOperationDampersPassive,
            value => ElctrncShckAbsrbrCtrlMdFrntAxle2365478910::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProhibitAirSuspensionCtrl2362638078 {
    NotAvailable,
    ErrorIndicator,
    RqProhibitAirSuspensionCtrl,
    NoRq,
    XValue(u64),
}

impl From<u64> for ProhibitAirSuspensionCtrl2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProhibitAirSuspensionCtrl2362638078::NotAvailable,
            2 => ProhibitAirSuspensionCtrl2362638078::ErrorIndicator,
            1 => ProhibitAirSuspensionCtrl2362638078::RqProhibitAirSuspensionCtrl,
            0 => ProhibitAirSuspensionCtrl2362638078::NoRq,
            value => ProhibitAirSuspensionCtrl2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KneelingCmdRearAxle2362638078 {
    DontCareTakeNoAction,
    Reserved,
    ActivateKneeling,
    DeactivateKneeling,
    XValue(u64),
}

impl From<u64> for KneelingCmdRearAxle2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => KneelingCmdRearAxle2362638078::DontCareTakeNoAction,
            2 => KneelingCmdRearAxle2362638078::Reserved,
            1 => KneelingCmdRearAxle2362638078::ActivateKneeling,
            0 => KneelingCmdRearAxle2362638078::DeactivateKneeling,
            value => KneelingCmdRearAxle2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KneelingCmdFrontAxle2362638078 {
    DontCareTakeNoAction,
    Reserved,
    ActivateKneeling,
    DeactivateKneeling,
    XValue(u64),
}

impl From<u64> for KneelingCmdFrontAxle2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => KneelingCmdFrontAxle2362638078::DontCareTakeNoAction,
            2 => KneelingCmdFrontAxle2362638078::Reserved,
            1 => KneelingCmdFrontAxle2362638078::ActivateKneeling,
            0 => KneelingCmdFrontAxle2362638078::DeactivateKneeling,
            value => KneelingCmdFrontAxle2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelCtrlModeRq2362638078 {
    DontCareTakeNoAction,
    Reserved,
    X1101notDefined,
    ExhaustBellows,
    TractionHelpLoadReduce,
    OptmmTrctn2IPrssAtThDrvnAxlIsCt,
    OptmmTrctn1IPrssAtThDrvnAxlIsCt,
    PrssRt2IRtBtwnThPrssrsAtThDrvnA,
    PrssRt1IRtBtwnThPrssrsAtThDrvnA,
    LdFxngIDrvnAxlnIsLddTaVlDfndByT,
    TrctnHlpIDrvnAxlIsLddTaMxVlGvnB,
    NrmlOprtnISystmPrfrmsAPrCtrlOfT,
    XValue(u64),
}

impl From<u64> for LevelCtrlModeRq2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LevelCtrlModeRq2362638078::DontCareTakeNoAction,
            14 => LevelCtrlModeRq2362638078::Reserved,
            9 => LevelCtrlModeRq2362638078::X1101notDefined,
            8 => LevelCtrlModeRq2362638078::ExhaustBellows,
            7 => LevelCtrlModeRq2362638078::TractionHelpLoadReduce,
            6 => LevelCtrlModeRq2362638078::OptmmTrctn2IPrssAtThDrvnAxlIsCt,
            5 => LevelCtrlModeRq2362638078::OptmmTrctn1IPrssAtThDrvnAxlIsCt,
            4 => LevelCtrlModeRq2362638078::PrssRt2IRtBtwnThPrssrsAtThDrvnA,
            3 => LevelCtrlModeRq2362638078::PrssRt1IRtBtwnThPrssrsAtThDrvnA,
            2 => LevelCtrlModeRq2362638078::LdFxngIDrvnAxlnIsLddTaVlDfndByT,
            1 => LevelCtrlModeRq2362638078::TrctnHlpIDrvnAxlIsLddTaMxVlGvnB,
            0 => LevelCtrlModeRq2362638078::NrmlOprtnISystmPrfrmsAPrCtrlOfT,
            value => LevelCtrlModeRq2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NominalLevelRqRearAxle2362638078 {
    DontCareTakeNoAction,
    Reserved,
    X1101notDefined,
    StopLevelChange,
    LowerLevel,
    UpperLevel,
    CustomerLevel,
    PresetLevel,
    NormalLevel3,
    NormalLevel2,
    NormalLevel1,
    NoLevelRq,
    XValue(u64),
}

impl From<u64> for NominalLevelRqRearAxle2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => NominalLevelRqRearAxle2362638078::DontCareTakeNoAction,
            14 => NominalLevelRqRearAxle2362638078::Reserved,
            9 => NominalLevelRqRearAxle2362638078::X1101notDefined,
            8 => NominalLevelRqRearAxle2362638078::StopLevelChange,
            7 => NominalLevelRqRearAxle2362638078::LowerLevel,
            6 => NominalLevelRqRearAxle2362638078::UpperLevel,
            5 => NominalLevelRqRearAxle2362638078::CustomerLevel,
            4 => NominalLevelRqRearAxle2362638078::PresetLevel,
            3 => NominalLevelRqRearAxle2362638078::NormalLevel3,
            2 => NominalLevelRqRearAxle2362638078::NormalLevel2,
            1 => NominalLevelRqRearAxle2362638078::NormalLevel1,
            0 => NominalLevelRqRearAxle2362638078::NoLevelRq,
            value => NominalLevelRqRearAxle2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NominalLevelRqFrontAxle2362638078 {
    DontCareTakeNoAction,
    Reserved,
    X1101notDefined,
    StopLevelChange,
    LowerLevel,
    UpperLevel,
    CustomerLevel,
    PresetLevel,
    NormalLevel3,
    NormalLevel2,
    NormalLevel1,
    NoLevelRq,
    XValue(u64),
}

impl From<u64> for NominalLevelRqFrontAxle2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => NominalLevelRqFrontAxle2362638078::DontCareTakeNoAction,
            14 => NominalLevelRqFrontAxle2362638078::Reserved,
            9 => NominalLevelRqFrontAxle2362638078::X1101notDefined,
            8 => NominalLevelRqFrontAxle2362638078::StopLevelChange,
            7 => NominalLevelRqFrontAxle2362638078::LowerLevel,
            6 => NominalLevelRqFrontAxle2362638078::UpperLevel,
            5 => NominalLevelRqFrontAxle2362638078::CustomerLevel,
            4 => NominalLevelRqFrontAxle2362638078::PresetLevel,
            3 => NominalLevelRqFrontAxle2362638078::NormalLevel3,
            2 => NominalLevelRqFrontAxle2362638078::NormalLevel2,
            1 => NominalLevelRqFrontAxle2362638078::NormalLevel1,
            0 => NominalLevelRqFrontAxle2362638078::NoLevelRq,
            value => NominalLevelRqFrontAxle2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KneelingCtrlModeRq2362638078 {
    DontCareTakeNoAction,
    Reserved,
    ManuallyActuated,
    AutomaticallyActuated,
    XValue(u64),
}

impl From<u64> for KneelingCtrlModeRq2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => KneelingCtrlModeRq2362638078::DontCareTakeNoAction,
            2 => KneelingCtrlModeRq2362638078::Reserved,
            1 => KneelingCtrlModeRq2362638078::ManuallyActuated,
            0 => KneelingCtrlModeRq2362638078::AutomaticallyActuated,
            value => KneelingCtrlModeRq2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KneelingRqRightSide2362638078 {
    DontCareTakeNoAction,
    Reserved,
    KneelingRq,
    NoKneelingRq,
    XValue(u64),
}

impl From<u64> for KneelingRqRightSide2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => KneelingRqRightSide2362638078::DontCareTakeNoAction,
            2 => KneelingRqRightSide2362638078::Reserved,
            1 => KneelingRqRightSide2362638078::KneelingRq,
            0 => KneelingRqRightSide2362638078::NoKneelingRq,
            value => KneelingRqRightSide2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KneelingRqLeftSide2362638078 {
    DontCareTakeNoAction,
    Reserved,
    KneelingRq,
    NoKneelingRq,
    XValue(u64),
}

impl From<u64> for KneelingRqLeftSide2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => KneelingRqLeftSide2362638078::DontCareTakeNoAction,
            2 => KneelingRqLeftSide2362638078::Reserved,
            1 => KneelingRqLeftSide2362638078::KneelingRq,
            0 => KneelingRqLeftSide2362638078::NoKneelingRq,
            value => KneelingRqLeftSide2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AutomaticTractionHelp2362638078 {
    DontCare,
    Reserved,
    EnableAutomaticTractionHelp,
    DisableAutomaticTractionHelp,
    XValue(u64),
}

impl From<u64> for AutomaticTractionHelp2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AutomaticTractionHelp2362638078::DontCare,
            2 => AutomaticTractionHelp2362638078::Reserved,
            1 => AutomaticTractionHelp2362638078::EnableAutomaticTractionHelp,
            0 => AutomaticTractionHelp2362638078::DisableAutomaticTractionHelp,
            value => AutomaticTractionHelp2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle2PosCmd2362638078 {
    DontCareTakeNoAction,
    Reserved,
    LiftAxlePosUpTagAxleUnladen,
    LiftAxlePosDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle2PosCmd2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle2PosCmd2362638078::DontCareTakeNoAction,
            2 => LiftAxle2PosCmd2362638078::Reserved,
            1 => LiftAxle2PosCmd2362638078::LiftAxlePosUpTagAxleUnladen,
            0 => LiftAxle2PosCmd2362638078::LiftAxlePosDownTagAxleLaden,
            value => LiftAxle2PosCmd2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle1PosCmd2362638078 {
    DontCareTakeNoAction,
    Reserved,
    LiftAxlePosUpTagAxleUnladen,
    LiftAxlePosDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle1PosCmd2362638078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle1PosCmd2362638078::DontCareTakeNoAction,
            2 => LiftAxle1PosCmd2362638078::Reserved,
            1 => LiftAxle1PosCmd2362638078::LiftAxlePosUpTagAxleUnladen,
            0 => LiftAxle1PosCmd2362638078::LiftAxlePosDownTagAxleLaden,
            value => LiftAxle1PosCmd2362638078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SspensionCtrlRefusalInformation2365479678 {
    X1101notDefined,
    NotAvailable,
    Error,
    GnrlRjctInSpcifiedReasonApplies,
    BelowSpeedLimit,
    AboveSpeedLimit,
    BogieDiffNotLocked,
    WouldExceedAxleLoadLimit,
    AxleLoadLimitReached,
    ActualRqNotRefused,
    XValue(u64),
}

impl From<u64> for SspensionCtrlRefusalInformation2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => SspensionCtrlRefusalInformation2365479678::X1101notDefined,
            15 => SspensionCtrlRefusalInformation2365479678::NotAvailable,
            14 => SspensionCtrlRefusalInformation2365479678::Error,
            6 => SspensionCtrlRefusalInformation2365479678::GnrlRjctInSpcifiedReasonApplies,
            5 => SspensionCtrlRefusalInformation2365479678::BelowSpeedLimit,
            4 => SspensionCtrlRefusalInformation2365479678::AboveSpeedLimit,
            3 => SspensionCtrlRefusalInformation2365479678::BogieDiffNotLocked,
            2 => SspensionCtrlRefusalInformation2365479678::WouldExceedAxleLoadLimit,
            1 => SspensionCtrlRefusalInformation2365479678::AxleLoadLimitReached,
            0 => SspensionCtrlRefusalInformation2365479678::ActualRqNotRefused,
            value => SspensionCtrlRefusalInformation2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SuspensionRemoteCtrl22365479678 {
    NotAvailable,
    Error,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for SuspensionRemoteCtrl22365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SuspensionRemoteCtrl22365479678::NotAvailable,
            2 => SuspensionRemoteCtrl22365479678::Error,
            1 => SuspensionRemoteCtrl22365479678::Active,
            0 => SuspensionRemoteCtrl22365479678::NotActive,
            value => SuspensionRemoteCtrl22365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SuspensionRemoteCtrl12365479678 {
    NotAvailable,
    Error,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for SuspensionRemoteCtrl12365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SuspensionRemoteCtrl12365479678::NotAvailable,
            2 => SuspensionRemoteCtrl12365479678::Error,
            1 => SuspensionRemoteCtrl12365479678::Active,
            0 => SuspensionRemoteCtrl12365479678::NotActive,
            value => SuspensionRemoteCtrl12365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RearAxleInBumperRange2365479678 {
    NotAvailable,
    Error,
    ActualLevelWithinBumperRange,
    ActualLevelOutOfBumperRange,
    XValue(u64),
}

impl From<u64> for RearAxleInBumperRange2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RearAxleInBumperRange2365479678::NotAvailable,
            2 => RearAxleInBumperRange2365479678::Error,
            1 => RearAxleInBumperRange2365479678::ActualLevelWithinBumperRange,
            0 => RearAxleInBumperRange2365479678::ActualLevelOutOfBumperRange,
            value => RearAxleInBumperRange2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FrontAxleInBumperRange2365479678 {
    NotAvailable,
    Error,
    ActualLevelWithinBumperRange,
    ActualLevelOutOfBumperRange,
    XValue(u64),
}

impl From<u64> for FrontAxleInBumperRange2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FrontAxleInBumperRange2365479678::NotAvailable,
            2 => FrontAxleInBumperRange2365479678::Error,
            1 => FrontAxleInBumperRange2365479678::ActualLevelWithinBumperRange,
            0 => FrontAxleInBumperRange2365479678::ActualLevelOutOfBumperRange,
            value => FrontAxleInBumperRange2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum DoorRelease2365479678 {
    NotAvailable,
    Error,
    DoorsMayBeOpened,
    DoorsMayNotBeOpened,
    XValue(u64),
}

impl From<u64> for DoorRelease2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => DoorRelease2365479678::NotAvailable,
            2 => DoorRelease2365479678::Error,
            1 => DoorRelease2365479678::DoorsMayBeOpened,
            0 => DoorRelease2365479678::DoorsMayNotBeOpened,
            value => DoorRelease2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VehicleMotionInhibit2365479678 {
    NotAvailable,
    Error,
    VehicleMotionIsInhibited,
    VehicleMayBeMoved,
    XValue(u64),
}

impl From<u64> for VehicleMotionInhibit2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VehicleMotionInhibit2365479678::NotAvailable,
            2 => VehicleMotionInhibit2365479678::Error,
            1 => VehicleMotionInhibit2365479678::VehicleMotionIsInhibited,
            0 => VehicleMotionInhibit2365479678::VehicleMayBeMoved,
            value => VehicleMotionInhibit2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecurityDevice2365479678 {
    NotAvailable,
    Error,
    Active,
    NotActive,
    XValue(u64),
}

impl From<u64> for SecurityDevice2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SecurityDevice2365479678::NotAvailable,
            2 => SecurityDevice2365479678::Error,
            1 => SecurityDevice2365479678::Active,
            0 => SecurityDevice2365479678::NotActive,
            value => SecurityDevice2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LevelCtrlMode2365479678 {
    X1101notDefined,
    NotAvailable,
    Error,
    AirSuspensionCtrlProhibited,
    ExhstngBllwFnctnIBllwsArExhstdT,
    TractionHelpLoadReduce,
    OptmmTrctn2IPrssAtThDrvnAxlIsCt,
    OptmmTrctn1IPrssAtThDrvnAxlIsCt,
    PrssRt2IRtBtwnThPrssrsAtThDrvnA,
    PrssRt1IRtBtwnThPrssrsAtThDrvnA,
    LdFxngIDrvnAxlnIsLddTaVlDfndByT,
    TrctnHlpIDrvnAxlIsLddTaMxVlGvnB,
    NrmlOprtnISystmPrfrmsAPrCtrlOfT,
    XValue(u64),
}

impl From<u64> for LevelCtrlMode2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            10 => LevelCtrlMode2365479678::X1101notDefined,
            15 => LevelCtrlMode2365479678::NotAvailable,
            14 => LevelCtrlMode2365479678::Error,
            9 => LevelCtrlMode2365479678::AirSuspensionCtrlProhibited,
            8 => LevelCtrlMode2365479678::ExhstngBllwFnctnIBllwsArExhstdT,
            7 => LevelCtrlMode2365479678::TractionHelpLoadReduce,
            6 => LevelCtrlMode2365479678::OptmmTrctn2IPrssAtThDrvnAxlIsCt,
            5 => LevelCtrlMode2365479678::OptmmTrctn1IPrssAtThDrvnAxlIsCt,
            4 => LevelCtrlMode2365479678::PrssRt2IRtBtwnThPrssrsAtThDrvnA,
            3 => LevelCtrlMode2365479678::PrssRt1IRtBtwnThPrssrsAtThDrvnA,
            2 => LevelCtrlMode2365479678::LdFxngIDrvnAxlnIsLddTaVlDfndByT,
            1 => LevelCtrlMode2365479678::TrctnHlpIDrvnAxlIsLddTaMxVlGvnB,
            0 => LevelCtrlMode2365479678::NrmlOprtnISystmPrfrmsAPrCtrlOfT,
            value => LevelCtrlMode2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KneelingInformation2365479678 {
    NotAvailable,
    Error,
    X1101notDefined,
    KneelingAborted,
    LiftingActive,
    KneelingLevelReached,
    NotActive,
    XValue(u64),
}

impl From<u64> for KneelingInformation2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => KneelingInformation2365479678::NotAvailable,
            14 => KneelingInformation2365479678::Error,
            5 => KneelingInformation2365479678::X1101notDefined,
            4 => KneelingInformation2365479678::KneelingAborted,
            3 => KneelingInformation2365479678::LiftingActive,
            2 => KneelingInformation2365479678::KneelingLevelReached,
            0 => KneelingInformation2365479678::NotActive,
            value => KneelingInformation2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftingCtrlModeRearAxle2365479678 {
    NotAvailable,
    Error,
    LiftingActive,
    LiftingNotActive,
    XValue(u64),
}

impl From<u64> for LiftingCtrlModeRearAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftingCtrlModeRearAxle2365479678::NotAvailable,
            2 => LiftingCtrlModeRearAxle2365479678::Error,
            1 => LiftingCtrlModeRearAxle2365479678::LiftingActive,
            0 => LiftingCtrlModeRearAxle2365479678::LiftingNotActive,
            value => LiftingCtrlModeRearAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftingCtrlModeFrontAxle2365479678 {
    NotAvailable,
    Error,
    LiftingActive,
    LiftingNotActive,
    XValue(u64),
}

impl From<u64> for LiftingCtrlModeFrontAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftingCtrlModeFrontAxle2365479678::NotAvailable,
            2 => LiftingCtrlModeFrontAxle2365479678::Error,
            1 => LiftingCtrlModeFrontAxle2365479678::LiftingActive,
            0 => LiftingCtrlModeFrontAxle2365479678::LiftingNotActive,
            value => LiftingCtrlModeFrontAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LoweringCtrlModeRearAxle2365479678 {
    NotAvailable,
    Error,
    LoweringActive,
    LoweringNotActive,
    XValue(u64),
}

impl From<u64> for LoweringCtrlModeRearAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LoweringCtrlModeRearAxle2365479678::NotAvailable,
            2 => LoweringCtrlModeRearAxle2365479678::Error,
            1 => LoweringCtrlModeRearAxle2365479678::LoweringActive,
            0 => LoweringCtrlModeRearAxle2365479678::LoweringNotActive,
            value => LoweringCtrlModeRearAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LoweringCtrlModeFrontAxle2365479678 {
    NotAvailable,
    Error,
    LoweringActive,
    LoweringNotActive,
    XValue(u64),
}

impl From<u64> for LoweringCtrlModeFrontAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LoweringCtrlModeFrontAxle2365479678::NotAvailable,
            2 => LoweringCtrlModeFrontAxle2365479678::Error,
            1 => LoweringCtrlModeFrontAxle2365479678::LoweringActive,
            0 => LoweringCtrlModeFrontAxle2365479678::LoweringNotActive,
            value => LoweringCtrlModeFrontAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AboveNominalLevelRearAxle2365479678 {
    NotAvailable,
    Error,
    Above,
    NotAbove,
    XValue(u64),
}

impl From<u64> for AboveNominalLevelRearAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AboveNominalLevelRearAxle2365479678::NotAvailable,
            2 => AboveNominalLevelRearAxle2365479678::Error,
            1 => AboveNominalLevelRearAxle2365479678::Above,
            0 => AboveNominalLevelRearAxle2365479678::NotAbove,
            value => AboveNominalLevelRearAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AboveNominalLevelFrontAxle2365479678 {
    NotAvailable,
    Error,
    Above,
    NotAbove,
    XValue(u64),
}

impl From<u64> for AboveNominalLevelFrontAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AboveNominalLevelFrontAxle2365479678::NotAvailable,
            2 => AboveNominalLevelFrontAxle2365479678::Error,
            1 => AboveNominalLevelFrontAxle2365479678::Above,
            0 => AboveNominalLevelFrontAxle2365479678::NotAbove,
            value => AboveNominalLevelFrontAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BelowNominalLevelRearAxle2365479678 {
    NotAvailable,
    Error,
    Below,
    NotBelow,
    XValue(u64),
}

impl From<u64> for BelowNominalLevelRearAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BelowNominalLevelRearAxle2365479678::NotAvailable,
            2 => BelowNominalLevelRearAxle2365479678::Error,
            1 => BelowNominalLevelRearAxle2365479678::Below,
            0 => BelowNominalLevelRearAxle2365479678::NotBelow,
            value => BelowNominalLevelRearAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum BelowNominalLevelFrontAxle2365479678 {
    NotAvailable,
    Error,
    Below,
    NotBelow,
    XValue(u64),
}

impl From<u64> for BelowNominalLevelFrontAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => BelowNominalLevelFrontAxle2365479678::NotAvailable,
            2 => BelowNominalLevelFrontAxle2365479678::Error,
            1 => BelowNominalLevelFrontAxle2365479678::Below,
            0 => BelowNominalLevelFrontAxle2365479678::NotBelow,
            value => BelowNominalLevelFrontAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NominalLevelRearAxle2365479678 {
    NotAvailable,
    Error,
    X1101notDefined,
    LowerLevel,
    UpperLevel,
    CustomerLevel,
    PresetLevel,
    NormalLevel3,
    NormalLevel2,
    NormalLevel1,
    LevelNotSpecified,
    XValue(u64),
}

impl From<u64> for NominalLevelRearAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => NominalLevelRearAxle2365479678::NotAvailable,
            14 => NominalLevelRearAxle2365479678::Error,
            8 => NominalLevelRearAxle2365479678::X1101notDefined,
            7 => NominalLevelRearAxle2365479678::LowerLevel,
            6 => NominalLevelRearAxle2365479678::UpperLevel,
            5 => NominalLevelRearAxle2365479678::CustomerLevel,
            4 => NominalLevelRearAxle2365479678::PresetLevel,
            3 => NominalLevelRearAxle2365479678::NormalLevel3,
            2 => NominalLevelRearAxle2365479678::NormalLevel2,
            1 => NominalLevelRearAxle2365479678::NormalLevel1,
            0 => NominalLevelRearAxle2365479678::LevelNotSpecified,
            value => NominalLevelRearAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NominalLevelFrontAxle2365479678 {
    NotAvailable,
    Error,
    X1101notDefined,
    LowerLevel,
    UpperLevel,
    CustomerLevel,
    PresetLevel,
    NormalLevel3,
    NormalLevel2,
    NormalLevel1,
    LevelNotSpecified,
    XValue(u64),
}

impl From<u64> for NominalLevelFrontAxle2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => NominalLevelFrontAxle2365479678::NotAvailable,
            14 => NominalLevelFrontAxle2365479678::Error,
            8 => NominalLevelFrontAxle2365479678::X1101notDefined,
            7 => NominalLevelFrontAxle2365479678::LowerLevel,
            6 => NominalLevelFrontAxle2365479678::UpperLevel,
            5 => NominalLevelFrontAxle2365479678::CustomerLevel,
            4 => NominalLevelFrontAxle2365479678::PresetLevel,
            3 => NominalLevelFrontAxle2365479678::NormalLevel3,
            2 => NominalLevelFrontAxle2365479678::NormalLevel2,
            1 => NominalLevelFrontAxle2365479678::NormalLevel1,
            0 => NominalLevelFrontAxle2365479678::LevelNotSpecified,
            value => NominalLevelFrontAxle2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle2Pos2365479678 {
    NotAvailable,
    Error,
    LiftAxlePosUpTagAxleUnladen,
    LiftAxlePosDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle2Pos2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle2Pos2365479678::NotAvailable,
            2 => LiftAxle2Pos2365479678::Error,
            1 => LiftAxle2Pos2365479678::LiftAxlePosUpTagAxleUnladen,
            0 => LiftAxle2Pos2365479678::LiftAxlePosDownTagAxleLaden,
            value => LiftAxle2Pos2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LiftAxle1Pos2365479678 {
    NotAvailable,
    Error,
    LiftAxlePosUpTagAxleUnladen,
    LiftAxlePosDownTagAxleLaden,
    XValue(u64),
}

impl From<u64> for LiftAxle1Pos2365479678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => LiftAxle1Pos2365479678::NotAvailable,
            2 => LiftAxle1Pos2365479678::Error,
            1 => LiftAxle1Pos2365479678::LiftAxlePosUpTagAxleUnladen,
            0 => LiftAxle1Pos2365479678::LiftAxlePosDownTagAxleLaden,
            value => LiftAxle1Pos2365479678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Alt4Status2566837758 {
    NotAvailable,
    Error,
    Alt4Charging,
    Alt4NotCharging,
    XValue(u64),
}

impl From<u64> for Alt4Status2566837758 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Alt4Status2566837758::NotAvailable,
            2 => Alt4Status2566837758::Error,
            1 => Alt4Status2566837758::Alt4Charging,
            0 => Alt4Status2566837758::Alt4NotCharging,
            value => Alt4Status2566837758::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Alt3Status2566837758 {
    NotAvailable,
    Error,
    Alt3Charging,
    Alt3NotCharging,
    XValue(u64),
}

impl From<u64> for Alt3Status2566837758 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Alt3Status2566837758::NotAvailable,
            2 => Alt3Status2566837758::Error,
            1 => Alt3Status2566837758::Alt3Charging,
            0 => Alt3Status2566837758::Alt3NotCharging,
            value => Alt3Status2566837758::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Alt2Status2566837758 {
    NotAvailable,
    Error,
    Alt2Charging,
    Alt2NotCharging,
    XValue(u64),
}

impl From<u64> for Alt2Status2566837758 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Alt2Status2566837758::NotAvailable,
            2 => Alt2Status2566837758::Error,
            1 => Alt2Status2566837758::Alt2Charging,
            0 => Alt2Status2566837758::Alt2NotCharging,
            value => Alt2Status2566837758::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Alt1Status2566837758 {
    NotAvailable,
    Error,
    Alt1Charging,
    Alt1NotCharging,
    XValue(u64),
}

impl From<u64> for Alt1Status2566837758 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Alt1Status2566837758::NotAvailable,
            2 => Alt1Status2566837758::Error,
            1 => Alt1Status2566837758::Alt1Charging,
            0 => Alt1Status2566837758::Alt1NotCharging,
            value => Alt1Status2566837758::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum IndustryGroup2633895166 {
    ReserveForSae,
    IndustrialProcessCtrlStationary,
    Marine,
    Construction,
    AgriculturalAndForestry,
    OnHighway,
    Global,
    XValue(u64),
}

impl From<u64> for IndustryGroup2633895166 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => IndustryGroup2633895166::ReserveForSae,
            5 => IndustryGroup2633895166::IndustrialProcessCtrlStationary,
            4 => IndustryGroup2633895166::Marine,
            3 => IndustryGroup2633895166::Construction,
            2 => IndustryGroup2633895166::AgriculturalAndForestry,
            1 => IndustryGroup2633895166::OnHighway,
            0 => IndustryGroup2633895166::Global,
            value => IndustryGroup2633895166::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52566836222 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52566836222::NotAvailable,
            19 => FailureModeIdentifier52566836222::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52566836222::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52566836222::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52566836222::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52566836222::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52566836222::SpecialIntstructions,
            13 => FailureModeIdentifier52566836222::OutOfCalibration,
            12 => FailureModeIdentifier52566836222::BadIntelligentDevice,
            11 => FailureModeIdentifier52566836222::RootCauseNotKnown,
            10 => FailureModeIdentifier52566836222::AbnormalRateOfChange,
            9 => FailureModeIdentifier52566836222::AbnormalUpdateRate,
            8 => FailureModeIdentifier52566836222::AbnormalFrequency,
            7 => FailureModeIdentifier52566836222::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52566836222::CurrentAboveNormal,
            5 => FailureModeIdentifier52566836222::CurrentBelowNormal,
            4 => FailureModeIdentifier52566836222::VoltageBelowNormal,
            3 => FailureModeIdentifier52566836222::VoltageAboveNormal,
            2 => FailureModeIdentifier52566836222::DataErratic,
            1 => FailureModeIdentifier52566836222::BelowNormalMostSevere,
            0 => FailureModeIdentifier52566836222::AboveNormalMostSevere,
            value => FailureModeIdentifier52566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42566836222 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42566836222::NotAvailable,
            19 => FailureModeIdentifier42566836222::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42566836222::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42566836222::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42566836222::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42566836222::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42566836222::SpecialIntstructions,
            13 => FailureModeIdentifier42566836222::OutOfCalibration,
            12 => FailureModeIdentifier42566836222::BadIntelligentDevice,
            11 => FailureModeIdentifier42566836222::RootCauseNotKnown,
            10 => FailureModeIdentifier42566836222::AbnormalRateOfChange,
            9 => FailureModeIdentifier42566836222::AbnormalUpdateRate,
            8 => FailureModeIdentifier42566836222::AbnormalFrequency,
            7 => FailureModeIdentifier42566836222::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42566836222::CurrentAboveNormal,
            5 => FailureModeIdentifier42566836222::CurrentBelowNormal,
            4 => FailureModeIdentifier42566836222::VoltageBelowNormal,
            3 => FailureModeIdentifier42566836222::VoltageAboveNormal,
            2 => FailureModeIdentifier42566836222::DataErratic,
            1 => FailureModeIdentifier42566836222::BelowNormalMostSevere,
            0 => FailureModeIdentifier42566836222::AboveNormalMostSevere,
            value => FailureModeIdentifier42566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2566836222 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2566836222::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2566836222::Reserved,
            1 => FlashRedStopLamp2566836222::FastFlash,
            0 => FlashRedStopLamp2566836222::SlowFlash,
            value => FlashRedStopLamp2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2566836222 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2566836222::UnavailableDoNotFlash,
            2 => FlashProtectLamp2566836222::Reserved,
            1 => FlashProtectLamp2566836222::FastFlash,
            0 => FlashProtectLamp2566836222::SlowFlash,
            value => FlashProtectLamp2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2566836222 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2566836222::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2566836222::Reserved,
            1 => FlashMalfuncIndicatorLamp2566836222::FastFlash,
            0 => FlashMalfuncIndicatorLamp2566836222::SlowFlash,
            value => FlashMalfuncIndicatorLamp2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2566836222 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2566836222::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2566836222::Reserved,
            1 => FlashAmberWarningLamp2566836222::FastFlash,
            0 => FlashAmberWarningLamp2566836222::SlowFlash,
            value => FlashAmberWarningLamp2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32566836222 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32566836222::NotAvailable,
            19 => FailureModeIdentifier32566836222::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32566836222::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32566836222::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32566836222::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32566836222::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32566836222::SpecialIntstructions,
            13 => FailureModeIdentifier32566836222::OutOfCalibration,
            12 => FailureModeIdentifier32566836222::BadIntelligentDevice,
            11 => FailureModeIdentifier32566836222::RootCauseNotKnown,
            10 => FailureModeIdentifier32566836222::AbnormalRateOfChange,
            9 => FailureModeIdentifier32566836222::AbnormalUpdateRate,
            8 => FailureModeIdentifier32566836222::AbnormalFrequency,
            7 => FailureModeIdentifier32566836222::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32566836222::CurrentAboveNormal,
            5 => FailureModeIdentifier32566836222::CurrentBelowNormal,
            4 => FailureModeIdentifier32566836222::VoltageBelowNormal,
            3 => FailureModeIdentifier32566836222::VoltageAboveNormal,
            2 => FailureModeIdentifier32566836222::DataErratic,
            1 => FailureModeIdentifier32566836222::BelowNormalMostSevere,
            0 => FailureModeIdentifier32566836222::AboveNormalMostSevere,
            value => FailureModeIdentifier32566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22566836222 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22566836222::NotAvailable,
            19 => FailureModeIdentifier22566836222::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22566836222::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22566836222::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22566836222::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22566836222::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22566836222::SpecialIntstructions,
            13 => FailureModeIdentifier22566836222::OutOfCalibration,
            12 => FailureModeIdentifier22566836222::BadIntelligentDevice,
            11 => FailureModeIdentifier22566836222::RootCauseNotKnown,
            10 => FailureModeIdentifier22566836222::AbnormalRateOfChange,
            9 => FailureModeIdentifier22566836222::AbnormalUpdateRate,
            8 => FailureModeIdentifier22566836222::AbnormalFrequency,
            7 => FailureModeIdentifier22566836222::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22566836222::CurrentAboveNormal,
            5 => FailureModeIdentifier22566836222::CurrentBelowNormal,
            4 => FailureModeIdentifier22566836222::VoltageBelowNormal,
            3 => FailureModeIdentifier22566836222::VoltageAboveNormal,
            2 => FailureModeIdentifier22566836222::DataErratic,
            1 => FailureModeIdentifier22566836222::BelowNormalMostSevere,
            0 => FailureModeIdentifier22566836222::AboveNormalMostSevere,
            value => FailureModeIdentifier22566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566836222 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566836222::NotAvailable,
            19 => FailureModeIdentifier12566836222::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566836222::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566836222::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566836222::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566836222::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566836222::SpecialIntstructions,
            13 => FailureModeIdentifier12566836222::OutOfCalibration,
            12 => FailureModeIdentifier12566836222::BadIntelligentDevice,
            11 => FailureModeIdentifier12566836222::RootCauseNotKnown,
            10 => FailureModeIdentifier12566836222::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566836222::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566836222::AbnormalFrequency,
            7 => FailureModeIdentifier12566836222::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566836222::CurrentAboveNormal,
            5 => FailureModeIdentifier12566836222::CurrentBelowNormal,
            4 => FailureModeIdentifier12566836222::VoltageBelowNormal,
            3 => FailureModeIdentifier12566836222::VoltageAboveNormal,
            2 => FailureModeIdentifier12566836222::DataErratic,
            1 => FailureModeIdentifier12566836222::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566836222::AboveNormalMostSevere,
            value => FailureModeIdentifier12566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2566836222 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2566836222::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2566836222::Reserved,
            1 => MalfunctionIndicatorLampStatus2566836222::LampOn,
            0 => MalfunctionIndicatorLampStatus2566836222::LampOff,
            value => MalfunctionIndicatorLampStatus2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2566836222 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2566836222::NotAvailable,
            2 => RedStopLampState2566836222::Reserved,
            1 => RedStopLampState2566836222::LampOn,
            0 => RedStopLampState2566836222::LampOff,
            value => RedStopLampState2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2566836222 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2566836222::NotAvailable,
            2 => AmberWarningLampStatus2566836222::Reserved,
            1 => AmberWarningLampStatus2566836222::LampOn,
            0 => AmberWarningLampStatus2566836222::LampOff,
            value => AmberWarningLampStatus2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2566836222 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2566836222 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2566836222::NotAvailable,
            2 => ProtectLampStatus2566836222::Reserved,
            1 => ProtectLampStatus2566836222::LampOn,
            0 => ProtectLampStatus2566836222::LampOff,
            value => ProtectLampStatus2566836222::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MisfireMonitoringSupport2566835966 {
    NotAvailable,
    Reserved,
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for MisfireMonitoringSupport2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MisfireMonitoringSupport2566835966::NotAvailable,
            2 => MisfireMonitoringSupport2566835966::Reserved,
            1 => MisfireMonitoringSupport2566835966::TestSupported,
            0 => MisfireMonitoringSupport2566835966::TestNotSupported,
            value => MisfireMonitoringSupport2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ObdCompliance2566835966 {
    NotIntendedToMeetObdIiRequ,
    ObdI,
    ObdAndObdIi,
    ObdFederalEpa,
    ObdIiCaliforniaArb,
    ReserverForAssignmentBySae,
    XValue(u64),
}

impl From<u64> for ObdCompliance2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            5 => ObdCompliance2566835966::NotIntendedToMeetObdIiRequ,
            4 => ObdCompliance2566835966::ObdI,
            3 => ObdCompliance2566835966::ObdAndObdIi,
            2 => ObdCompliance2566835966::ObdFederalEpa,
            1 => ObdCompliance2566835966::ObdIiCaliforniaArb,
            0 => ObdCompliance2566835966::ReserverForAssignmentBySae,
            value => ObdCompliance2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecondAirSystemMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for SecondAirSystemMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecondAirSystemMonStatus2566835966::TestNotComplete,
            0 => SecondAirSystemMonStatus2566835966::TestComplete,
            value => SecondAirSystemMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EvaporativeSystemMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for EvaporativeSystemMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EvaporativeSystemMonStatus2566835966::TestNotComplete,
            0 => EvaporativeSystemMonStatus2566835966::TestComplete,
            value => EvaporativeSystemMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AcSystemRefrigerantMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for AcSystemRefrigerantMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AcSystemRefrigerantMonStatus2566835966::TestNotComplete,
            0 => AcSystemRefrigerantMonStatus2566835966::TestComplete,
            value => AcSystemRefrigerantMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorHeaterMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for OxygenSensorHeaterMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorHeaterMonStatus2566835966::TestNotComplete,
            0 => OxygenSensorHeaterMonStatus2566835966::TestComplete,
            value => OxygenSensorHeaterMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for OxygenSensorMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorMonStatus2566835966::TestNotComplete,
            0 => OxygenSensorMonStatus2566835966::TestComplete,
            value => OxygenSensorMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EgrSystemMonitoringStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for EgrSystemMonitoringStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EgrSystemMonitoringStatus2566835966::TestNotComplete,
            0 => EgrSystemMonitoringStatus2566835966::TestComplete,
            value => EgrSystemMonitoringStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CatalystMonStatus2566835966 {
    TestComplete,
    TestNotComplete,
    XValue(u64),
}

impl From<u64> for CatalystMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            0 => CatalystMonStatus2566835966::TestComplete,
            1 => CatalystMonStatus2566835966::TestNotComplete,
            value => CatalystMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ColdStartAidSystemMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for ColdStartAidSystemMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ColdStartAidSystemMonStatus2566835966::TestNotComplete,
            0 => ColdStartAidSystemMonStatus2566835966::TestComplete,
            value => ColdStartAidSystemMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HeatedCatalystMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for HeatedCatalystMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => HeatedCatalystMonStatus2566835966::TestNotComplete,
            0 => HeatedCatalystMonStatus2566835966::TestComplete,
            value => HeatedCatalystMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CatalystMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for CatalystMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => CatalystMonSupp2566835966::TestSupported,
            0 => CatalystMonSupp2566835966::TestNotSupported,
            value => CatalystMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ColdStartAidSystemMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for ColdStartAidSystemMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ColdStartAidSystemMonSupp2566835966::TestSupported,
            0 => ColdStartAidSystemMonSupp2566835966::TestNotSupported,
            value => ColdStartAidSystemMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HeatedCatalystMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for HeatedCatalystMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => HeatedCatalystMonSupp2566835966::TestSupported,
            0 => HeatedCatalystMonSupp2566835966::TestNotSupported,
            value => HeatedCatalystMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EvaporativeSystemMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for EvaporativeSystemMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EvaporativeSystemMonSupp2566835966::TestSupported,
            0 => EvaporativeSystemMonSupp2566835966::TestNotSupported,
            value => EvaporativeSystemMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SecondAirSystemMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for SecondAirSystemMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SecondAirSystemMonSupp2566835966::TestSupported,
            0 => SecondAirSystemMonSupp2566835966::TestNotSupported,
            value => SecondAirSystemMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AcSystemRefrigerantMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for AcSystemRefrigerantMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => AcSystemRefrigerantMonSupp2566835966::TestSupported,
            0 => AcSystemRefrigerantMonSupp2566835966::TestNotSupported,
            value => AcSystemRefrigerantMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for OxygenSensorMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorMonSupp2566835966::TestSupported,
            0 => OxygenSensorMonSupp2566835966::TestNotSupported,
            value => OxygenSensorMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum OxygenSensorHeaterMonSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for OxygenSensorHeaterMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => OxygenSensorHeaterMonSupp2566835966::TestSupported,
            0 => OxygenSensorHeaterMonSupp2566835966::TestNotSupported,
            value => OxygenSensorHeaterMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EgrSystemMonitoringSupp2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for EgrSystemMonitoringSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => EgrSystemMonitoringSupp2566835966::TestSupported,
            0 => EgrSystemMonitoringSupp2566835966::TestNotSupported,
            value => EgrSystemMonitoringSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MisfireMonitoringStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for MisfireMonitoringStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => MisfireMonitoringStatus2566835966::TestNotComplete,
            0 => MisfireMonitoringStatus2566835966::TestComplete,
            value => MisfireMonitoringStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ComprehensiveCompMonStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for ComprehensiveCompMonStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => ComprehensiveCompMonStatus2566835966::TestNotComplete,
            0 => ComprehensiveCompMonStatus2566835966::TestComplete,
            value => ComprehensiveCompMonStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FuelSystemMonitoringStatus2566835966 {
    TestNotComplete,
    TestComplete,
    XValue(u64),
}

impl From<u64> for FuelSystemMonitoringStatus2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FuelSystemMonitoringStatus2566835966::TestNotComplete,
            0 => FuelSystemMonitoringStatus2566835966::TestComplete,
            value => FuelSystemMonitoringStatus2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ComprehensiveComponentMonSupp2566835966 {
    NotAvailable,
    Reserved,
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for ComprehensiveComponentMonSupp2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ComprehensiveComponentMonSupp2566835966::NotAvailable,
            2 => ComprehensiveComponentMonSupp2566835966::Reserved,
            1 => ComprehensiveComponentMonSupp2566835966::TestSupported,
            0 => ComprehensiveComponentMonSupp2566835966::TestNotSupported,
            value => ComprehensiveComponentMonSupp2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FuelSystemMonitoringSupport2566835966 {
    TestSupported,
    TestNotSupported,
    XValue(u64),
}

impl From<u64> for FuelSystemMonitoringSupport2566835966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => FuelSystemMonitoringSupport2566835966::TestSupported,
            0 => FuelSystemMonitoringSupport2566835966::TestNotSupported,
            value => FuelSystemMonitoringSupport2566835966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566835710 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566835710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566835710::NotAvailable,
            19 => FailureModeIdentifier12566835710::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566835710::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566835710::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566835710::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566835710::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566835710::SpecialIntstructions,
            13 => FailureModeIdentifier12566835710::OutOfCalibration,
            12 => FailureModeIdentifier12566835710::BadIntelligentDevice,
            11 => FailureModeIdentifier12566835710::RootCauseNotKnown,
            10 => FailureModeIdentifier12566835710::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566835710::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566835710::AbnormalFrequency,
            7 => FailureModeIdentifier12566835710::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566835710::CurrentAboveNormal,
            5 => FailureModeIdentifier12566835710::CurrentBelowNormal,
            4 => FailureModeIdentifier12566835710::VoltageBelowNormal,
            3 => FailureModeIdentifier12566835710::VoltageAboveNormal,
            2 => FailureModeIdentifier12566835710::DataErratic,
            1 => FailureModeIdentifier12566835710::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566835710::AboveNormalMostSevere,
            value => FailureModeIdentifier12566835710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EngTorqueMode2566835710 {
    NotAvailable,
    RemoteAccelerator,
    BrakingSystem,
    HighSpeedGovernor,
    TorqueLimiting,
    AbsControl,
    TransmissionControl,
    AsrControl,
    RoadSpeedGovernor,
    PtoGovernor,
    CruiseControl,
    AcceleratorPedalOperatorSelec,
    LowIdleGovernorNoRequestDe,
    XValue(u64),
}

impl From<u64> for EngTorqueMode2566835710 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => EngTorqueMode2566835710::NotAvailable,
            11 => EngTorqueMode2566835710::RemoteAccelerator,
            10 => EngTorqueMode2566835710::BrakingSystem,
            9 => EngTorqueMode2566835710::HighSpeedGovernor,
            8 => EngTorqueMode2566835710::TorqueLimiting,
            7 => EngTorqueMode2566835710::AbsControl,
            6 => EngTorqueMode2566835710::TransmissionControl,
            5 => EngTorqueMode2566835710::AsrControl,
            4 => EngTorqueMode2566835710::RoadSpeedGovernor,
            3 => EngTorqueMode2566835710::PtoGovernor,
            2 => EngTorqueMode2566835710::CruiseControl,
            1 => EngTorqueMode2566835710::AcceleratorPedalOperatorSelec,
            0 => EngTorqueMode2566835710::LowIdleGovernorNoRequestDe,
            value => EngTorqueMode2566835710::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566764542 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566764542 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566764542::NotAvailable,
            19 => FailureModeIdentifier12566764542::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566764542::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566764542::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566764542::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566764542::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566764542::SpecialIntstructions,
            13 => FailureModeIdentifier12566764542::OutOfCalibration,
            12 => FailureModeIdentifier12566764542::BadIntelligentDevice,
            11 => FailureModeIdentifier12566764542::RootCauseNotKnown,
            10 => FailureModeIdentifier12566764542::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566764542::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566764542::AbnormalFrequency,
            7 => FailureModeIdentifier12566764542::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566764542::CurrentAboveNormal,
            5 => FailureModeIdentifier12566764542::CurrentBelowNormal,
            4 => FailureModeIdentifier12566764542::VoltageBelowNormal,
            3 => FailureModeIdentifier12566764542::VoltageAboveNormal,
            2 => FailureModeIdentifier12566764542::DataErratic,
            1 => FailureModeIdentifier12566764542::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566764542::AboveNormalMostSevere,
            value => FailureModeIdentifier12566764542::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeStr32566764286 {
    SupportedInScaledTestResults,
    NotSupportedInScaledTestResults,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeStr32566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeStr32566764286::SupportedInScaledTestResults,
            0 => SpnSupportTypeStr32566764286::NotSupportedInScaledTestResults,
            value => SpnSupportTypeStr32566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeStr22566764286 {
    SupportedInScaledTestResults,
    NotSupportedInScaledTestResults,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeStr22566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeStr22566764286::SupportedInScaledTestResults,
            0 => SpnSupportTypeStr22566764286::NotSupportedInScaledTestResults,
            value => SpnSupportTypeStr22566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeEff32566764286 {
    SupportedInExFreezeFrame,
    NotSupportedInExFreezeFrame,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeEff32566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeEff32566764286::SupportedInExFreezeFrame,
            0 => SpnSupportTypeEff32566764286::NotSupportedInExFreezeFrame,
            value => SpnSupportTypeEff32566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeEff22566764286 {
    SupportedInExFreezeFrame,
    NotSupportedInExFreezeFrame,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeEff22566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeEff22566764286::SupportedInExFreezeFrame,
            0 => SpnSupportTypeEff22566764286::NotSupportedInExFreezeFrame,
            value => SpnSupportTypeEff22566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeDs32566764286 {
    SupportedInDataStream,
    NotSupportedInDataStream,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeDs32566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeDs32566764286::SupportedInDataStream,
            0 => SpnSupportTypeDs32566764286::NotSupportedInDataStream,
            value => SpnSupportTypeDs32566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeDs22566764286 {
    SupportedInDataStream,
    NotSupportedInDataStream,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeDs22566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeDs22566764286::SupportedInDataStream,
            0 => SpnSupportTypeDs22566764286::NotSupportedInDataStream,
            value => SpnSupportTypeDs22566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeStr12566764286 {
    SupportedInScaledTestResults,
    NotSupportedInScaledTestResults,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeStr12566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeStr12566764286::SupportedInScaledTestResults,
            0 => SpnSupportTypeStr12566764286::NotSupportedInScaledTestResults,
            value => SpnSupportTypeStr12566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeDs12566764286 {
    SupportedInDataStream,
    NotSupportedInDataStream,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeDs12566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeDs12566764286::SupportedInDataStream,
            0 => SpnSupportTypeDs12566764286::NotSupportedInDataStream,
            value => SpnSupportTypeDs12566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SpnSupportTypeEff12566764286 {
    SupportedInExFreezeFrame,
    NotSupportedInExFreezeFrame,
    XValue(u64),
}

impl From<u64> for SpnSupportTypeEff12566764286 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => SpnSupportTypeEff12566764286::SupportedInExFreezeFrame,
            0 => SpnSupportTypeEff12566764286::NotSupportedInExFreezeFrame,
            value => SpnSupportTypeEff12566764286::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2555576062 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2555576062::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2555576062::Reserved,
            1 => FlashRedStopLamp2555576062::FastFlash,
            0 => FlashRedStopLamp2555576062::SlowFlash,
            value => FlashRedStopLamp2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2555576062 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2555576062::UnavailableDoNotFlash,
            2 => FlashProtectLamp2555576062::Reserved,
            1 => FlashProtectLamp2555576062::FastFlash,
            0 => FlashProtectLamp2555576062::SlowFlash,
            value => FlashProtectLamp2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2555576062 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2555576062::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2555576062::Reserved,
            1 => FlashMalfuncIndicatorLamp2555576062::FastFlash,
            0 => FlashMalfuncIndicatorLamp2555576062::SlowFlash,
            value => FlashMalfuncIndicatorLamp2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2555576062 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2555576062::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2555576062::Reserved,
            1 => FlashAmberWarningLamp2555576062::FastFlash,
            0 => FlashAmberWarningLamp2555576062::SlowFlash,
            value => FlashAmberWarningLamp2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52555576062 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52555576062::NotAvailable,
            19 => FailureModeIdentifier52555576062::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52555576062::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52555576062::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52555576062::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52555576062::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52555576062::SpecialIntstructions,
            13 => FailureModeIdentifier52555576062::OutOfCalibration,
            12 => FailureModeIdentifier52555576062::BadIntelligentDevice,
            11 => FailureModeIdentifier52555576062::RootCauseNotKnown,
            10 => FailureModeIdentifier52555576062::AbnormalRateOfChange,
            9 => FailureModeIdentifier52555576062::AbnormalUpdateRate,
            8 => FailureModeIdentifier52555576062::AbnormalFrequency,
            7 => FailureModeIdentifier52555576062::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52555576062::CurrentAboveNormal,
            5 => FailureModeIdentifier52555576062::CurrentBelowNormal,
            4 => FailureModeIdentifier52555576062::VoltageBelowNormal,
            3 => FailureModeIdentifier52555576062::VoltageAboveNormal,
            2 => FailureModeIdentifier52555576062::DataErratic,
            1 => FailureModeIdentifier52555576062::BelowNormalMostSevere,
            0 => FailureModeIdentifier52555576062::AboveNormalMostSevere,
            value => FailureModeIdentifier52555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42555576062 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42555576062::NotAvailable,
            19 => FailureModeIdentifier42555576062::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42555576062::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42555576062::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42555576062::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42555576062::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42555576062::SpecialIntstructions,
            13 => FailureModeIdentifier42555576062::OutOfCalibration,
            12 => FailureModeIdentifier42555576062::BadIntelligentDevice,
            11 => FailureModeIdentifier42555576062::RootCauseNotKnown,
            10 => FailureModeIdentifier42555576062::AbnormalRateOfChange,
            9 => FailureModeIdentifier42555576062::AbnormalUpdateRate,
            8 => FailureModeIdentifier42555576062::AbnormalFrequency,
            7 => FailureModeIdentifier42555576062::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42555576062::CurrentAboveNormal,
            5 => FailureModeIdentifier42555576062::CurrentBelowNormal,
            4 => FailureModeIdentifier42555576062::VoltageBelowNormal,
            3 => FailureModeIdentifier42555576062::VoltageAboveNormal,
            2 => FailureModeIdentifier42555576062::DataErratic,
            1 => FailureModeIdentifier42555576062::BelowNormalMostSevere,
            0 => FailureModeIdentifier42555576062::AboveNormalMostSevere,
            value => FailureModeIdentifier42555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12555576062 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12555576062::NotAvailable,
            19 => FailureModeIdentifier12555576062::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12555576062::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12555576062::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12555576062::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12555576062::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12555576062::SpecialIntstructions,
            13 => FailureModeIdentifier12555576062::OutOfCalibration,
            12 => FailureModeIdentifier12555576062::BadIntelligentDevice,
            11 => FailureModeIdentifier12555576062::RootCauseNotKnown,
            10 => FailureModeIdentifier12555576062::AbnormalRateOfChange,
            9 => FailureModeIdentifier12555576062::AbnormalUpdateRate,
            8 => FailureModeIdentifier12555576062::AbnormalFrequency,
            7 => FailureModeIdentifier12555576062::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12555576062::CurrentAboveNormal,
            5 => FailureModeIdentifier12555576062::CurrentBelowNormal,
            4 => FailureModeIdentifier12555576062::VoltageBelowNormal,
            3 => FailureModeIdentifier12555576062::VoltageAboveNormal,
            2 => FailureModeIdentifier12555576062::DataErratic,
            1 => FailureModeIdentifier12555576062::BelowNormalMostSevere,
            0 => FailureModeIdentifier12555576062::AboveNormalMostSevere,
            value => FailureModeIdentifier12555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2555576062 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2555576062::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2555576062::Reserved,
            1 => MalfunctionIndicatorLampStatus2555576062::LampOn,
            0 => MalfunctionIndicatorLampStatus2555576062::LampOff,
            value => MalfunctionIndicatorLampStatus2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2555576062 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2555576062::NotAvailable,
            2 => RedStopLampState2555576062::Reserved,
            1 => RedStopLampState2555576062::LampOn,
            0 => RedStopLampState2555576062::LampOff,
            value => RedStopLampState2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2555576062 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2555576062::NotAvailable,
            2 => AmberWarningLampStatus2555576062::Reserved,
            1 => AmberWarningLampStatus2555576062::LampOn,
            0 => AmberWarningLampStatus2555576062::LampOff,
            value => AmberWarningLampStatus2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2555576062 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2555576062::NotAvailable,
            2 => ProtectLampStatus2555576062::Reserved,
            1 => ProtectLampStatus2555576062::LampOn,
            0 => ProtectLampStatus2555576062::LampOff,
            value => ProtectLampStatus2555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32555576062 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32555576062::NotAvailable,
            19 => FailureModeIdentifier32555576062::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32555576062::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32555576062::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32555576062::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32555576062::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32555576062::SpecialIntstructions,
            13 => FailureModeIdentifier32555576062::OutOfCalibration,
            12 => FailureModeIdentifier32555576062::BadIntelligentDevice,
            11 => FailureModeIdentifier32555576062::RootCauseNotKnown,
            10 => FailureModeIdentifier32555576062::AbnormalRateOfChange,
            9 => FailureModeIdentifier32555576062::AbnormalUpdateRate,
            8 => FailureModeIdentifier32555576062::AbnormalFrequency,
            7 => FailureModeIdentifier32555576062::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32555576062::CurrentAboveNormal,
            5 => FailureModeIdentifier32555576062::CurrentBelowNormal,
            4 => FailureModeIdentifier32555576062::VoltageBelowNormal,
            3 => FailureModeIdentifier32555576062::VoltageAboveNormal,
            2 => FailureModeIdentifier32555576062::DataErratic,
            1 => FailureModeIdentifier32555576062::BelowNormalMostSevere,
            0 => FailureModeIdentifier32555576062::AboveNormalMostSevere,
            value => FailureModeIdentifier32555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22555576062 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22555576062 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22555576062::NotAvailable,
            19 => FailureModeIdentifier22555576062::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22555576062::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22555576062::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22555576062::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22555576062::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22555576062::SpecialIntstructions,
            13 => FailureModeIdentifier22555576062::OutOfCalibration,
            12 => FailureModeIdentifier22555576062::BadIntelligentDevice,
            11 => FailureModeIdentifier22555576062::RootCauseNotKnown,
            10 => FailureModeIdentifier22555576062::AbnormalRateOfChange,
            9 => FailureModeIdentifier22555576062::AbnormalUpdateRate,
            8 => FailureModeIdentifier22555576062::AbnormalFrequency,
            7 => FailureModeIdentifier22555576062::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22555576062::CurrentAboveNormal,
            5 => FailureModeIdentifier22555576062::CurrentBelowNormal,
            4 => FailureModeIdentifier22555576062::VoltageBelowNormal,
            3 => FailureModeIdentifier22555576062::VoltageAboveNormal,
            2 => FailureModeIdentifier22555576062::DataErratic,
            1 => FailureModeIdentifier22555576062::BelowNormalMostSevere,
            0 => FailureModeIdentifier22555576062::AboveNormalMostSevere,
            value => FailureModeIdentifier22555576062::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12562981630 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12562981630 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12562981630::NotAvailable,
            19 => FailureModeIdentifier12562981630::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12562981630::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12562981630::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12562981630::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12562981630::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12562981630::SpecialIntstructions,
            13 => FailureModeIdentifier12562981630::OutOfCalibration,
            12 => FailureModeIdentifier12562981630::BadIntelligentDevice,
            11 => FailureModeIdentifier12562981630::RootCauseNotKnown,
            10 => FailureModeIdentifier12562981630::AbnormalRateOfChange,
            9 => FailureModeIdentifier12562981630::AbnormalUpdateRate,
            8 => FailureModeIdentifier12562981630::AbnormalFrequency,
            7 => FailureModeIdentifier12562981630::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12562981630::CurrentAboveNormal,
            5 => FailureModeIdentifier12562981630::CurrentBelowNormal,
            4 => FailureModeIdentifier12562981630::VoltageBelowNormal,
            3 => FailureModeIdentifier12562981630::VoltageAboveNormal,
            2 => FailureModeIdentifier12562981630::DataErratic,
            1 => FailureModeIdentifier12562981630::BelowNormalMostSevere,
            0 => FailureModeIdentifier12562981630::AboveNormalMostSevere,
            value => FailureModeIdentifier12562981630::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52566835198 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52566835198::NotAvailable,
            19 => FailureModeIdentifier52566835198::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52566835198::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52566835198::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52566835198::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52566835198::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52566835198::SpecialIntstructions,
            13 => FailureModeIdentifier52566835198::OutOfCalibration,
            12 => FailureModeIdentifier52566835198::BadIntelligentDevice,
            11 => FailureModeIdentifier52566835198::RootCauseNotKnown,
            10 => FailureModeIdentifier52566835198::AbnormalRateOfChange,
            9 => FailureModeIdentifier52566835198::AbnormalUpdateRate,
            8 => FailureModeIdentifier52566835198::AbnormalFrequency,
            7 => FailureModeIdentifier52566835198::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52566835198::CurrentAboveNormal,
            5 => FailureModeIdentifier52566835198::CurrentBelowNormal,
            4 => FailureModeIdentifier52566835198::VoltageBelowNormal,
            3 => FailureModeIdentifier52566835198::VoltageAboveNormal,
            2 => FailureModeIdentifier52566835198::DataErratic,
            1 => FailureModeIdentifier52566835198::BelowNormalMostSevere,
            0 => FailureModeIdentifier52566835198::AboveNormalMostSevere,
            value => FailureModeIdentifier52566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42566835198 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42566835198::NotAvailable,
            19 => FailureModeIdentifier42566835198::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42566835198::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42566835198::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42566835198::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42566835198::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42566835198::SpecialIntstructions,
            13 => FailureModeIdentifier42566835198::OutOfCalibration,
            12 => FailureModeIdentifier42566835198::BadIntelligentDevice,
            11 => FailureModeIdentifier42566835198::RootCauseNotKnown,
            10 => FailureModeIdentifier42566835198::AbnormalRateOfChange,
            9 => FailureModeIdentifier42566835198::AbnormalUpdateRate,
            8 => FailureModeIdentifier42566835198::AbnormalFrequency,
            7 => FailureModeIdentifier42566835198::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42566835198::CurrentAboveNormal,
            5 => FailureModeIdentifier42566835198::CurrentBelowNormal,
            4 => FailureModeIdentifier42566835198::VoltageBelowNormal,
            3 => FailureModeIdentifier42566835198::VoltageAboveNormal,
            2 => FailureModeIdentifier42566835198::DataErratic,
            1 => FailureModeIdentifier42566835198::BelowNormalMostSevere,
            0 => FailureModeIdentifier42566835198::AboveNormalMostSevere,
            value => FailureModeIdentifier42566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566835198 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566835198::NotAvailable,
            19 => FailureModeIdentifier12566835198::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566835198::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566835198::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566835198::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566835198::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566835198::SpecialIntstructions,
            13 => FailureModeIdentifier12566835198::OutOfCalibration,
            12 => FailureModeIdentifier12566835198::BadIntelligentDevice,
            11 => FailureModeIdentifier12566835198::RootCauseNotKnown,
            10 => FailureModeIdentifier12566835198::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566835198::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566835198::AbnormalFrequency,
            7 => FailureModeIdentifier12566835198::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566835198::CurrentAboveNormal,
            5 => FailureModeIdentifier12566835198::CurrentBelowNormal,
            4 => FailureModeIdentifier12566835198::VoltageBelowNormal,
            3 => FailureModeIdentifier12566835198::VoltageAboveNormal,
            2 => FailureModeIdentifier12566835198::DataErratic,
            1 => FailureModeIdentifier12566835198::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566835198::AboveNormalMostSevere,
            value => FailureModeIdentifier12566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2566835198 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2566835198::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2566835198::Reserved,
            1 => MalfunctionIndicatorLampStatus2566835198::LampOn,
            0 => MalfunctionIndicatorLampStatus2566835198::LampOff,
            value => MalfunctionIndicatorLampStatus2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2566835198 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2566835198::NotAvailable,
            2 => RedStopLampState2566835198::Reserved,
            1 => RedStopLampState2566835198::LampOn,
            0 => RedStopLampState2566835198::LampOff,
            value => RedStopLampState2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2566835198 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2566835198::NotAvailable,
            2 => AmberWarningLampStatus2566835198::Reserved,
            1 => AmberWarningLampStatus2566835198::LampOn,
            0 => AmberWarningLampStatus2566835198::LampOff,
            value => AmberWarningLampStatus2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2566835198 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2566835198::NotAvailable,
            2 => ProtectLampStatus2566835198::Reserved,
            1 => ProtectLampStatus2566835198::LampOn,
            0 => ProtectLampStatus2566835198::LampOff,
            value => ProtectLampStatus2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32566835198 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32566835198::NotAvailable,
            19 => FailureModeIdentifier32566835198::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32566835198::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32566835198::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32566835198::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32566835198::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32566835198::SpecialIntstructions,
            13 => FailureModeIdentifier32566835198::OutOfCalibration,
            12 => FailureModeIdentifier32566835198::BadIntelligentDevice,
            11 => FailureModeIdentifier32566835198::RootCauseNotKnown,
            10 => FailureModeIdentifier32566835198::AbnormalRateOfChange,
            9 => FailureModeIdentifier32566835198::AbnormalUpdateRate,
            8 => FailureModeIdentifier32566835198::AbnormalFrequency,
            7 => FailureModeIdentifier32566835198::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32566835198::CurrentAboveNormal,
            5 => FailureModeIdentifier32566835198::CurrentBelowNormal,
            4 => FailureModeIdentifier32566835198::VoltageBelowNormal,
            3 => FailureModeIdentifier32566835198::VoltageAboveNormal,
            2 => FailureModeIdentifier32566835198::DataErratic,
            1 => FailureModeIdentifier32566835198::BelowNormalMostSevere,
            0 => FailureModeIdentifier32566835198::AboveNormalMostSevere,
            value => FailureModeIdentifier32566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2566835198 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2566835198::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2566835198::Reserved,
            1 => FlashRedStopLamp2566835198::FastFlash,
            0 => FlashRedStopLamp2566835198::SlowFlash,
            value => FlashRedStopLamp2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2566835198 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2566835198::UnavailableDoNotFlash,
            2 => FlashProtectLamp2566835198::Reserved,
            1 => FlashProtectLamp2566835198::FastFlash,
            0 => FlashProtectLamp2566835198::SlowFlash,
            value => FlashProtectLamp2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2566835198 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2566835198::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2566835198::Reserved,
            1 => FlashMalfuncIndicatorLamp2566835198::FastFlash,
            0 => FlashMalfuncIndicatorLamp2566835198::SlowFlash,
            value => FlashMalfuncIndicatorLamp2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2566835198 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2566835198::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2566835198::Reserved,
            1 => FlashAmberWarningLamp2566835198::FastFlash,
            0 => FlashAmberWarningLamp2566835198::SlowFlash,
            value => FlashAmberWarningLamp2566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22566835198 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22566835198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22566835198::NotAvailable,
            19 => FailureModeIdentifier22566835198::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22566835198::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22566835198::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22566835198::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22566835198::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22566835198::SpecialIntstructions,
            13 => FailureModeIdentifier22566835198::OutOfCalibration,
            12 => FailureModeIdentifier22566835198::BadIntelligentDevice,
            11 => FailureModeIdentifier22566835198::RootCauseNotKnown,
            10 => FailureModeIdentifier22566835198::AbnormalRateOfChange,
            9 => FailureModeIdentifier22566835198::AbnormalUpdateRate,
            8 => FailureModeIdentifier22566835198::AbnormalFrequency,
            7 => FailureModeIdentifier22566835198::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22566835198::CurrentAboveNormal,
            5 => FailureModeIdentifier22566835198::CurrentBelowNormal,
            4 => FailureModeIdentifier22566835198::VoltageBelowNormal,
            3 => FailureModeIdentifier22566835198::VoltageAboveNormal,
            2 => FailureModeIdentifier22566835198::DataErratic,
            1 => FailureModeIdentifier22566835198::BelowNormalMostSevere,
            0 => FailureModeIdentifier22566835198::AboveNormalMostSevere,
            value => FailureModeIdentifier22566835198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Seed2564357886 {
    NoFurtherKeyRequiredOfTool,
    UseLongSeedOrKeyFromDataSecMsg,
    SeedCompletedBeginSendingKey,
    XValue(u64),
}

impl From<u64> for Seed2564357886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            255 => Seed2564357886::NoFurtherKeyRequiredOfTool,
            1 => Seed2564357886::UseLongSeedOrKeyFromDataSecMsg,
            0 => Seed2564357886::SeedCompletedBeginSendingKey,
            value => Seed2564357886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum EdcpExtension2564357886 {
    DataInErrIndAndDataInSeedIsTime,
    DataInErrorIndicator,
    ConcatenateDataAsLowerEdcParam,
    ConcatenateDataAsHigherEdcParam,
    Completed,
    NoErrIndicatorEdcParamAvailable,
    XValue(u64),
}

impl From<u64> for EdcpExtension2564357886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            9 => EdcpExtension2564357886::DataInErrIndAndDataInSeedIsTime,
            6 => EdcpExtension2564357886::DataInErrorIndicator,
            3 => EdcpExtension2564357886::ConcatenateDataAsLowerEdcParam,
            2 => EdcpExtension2564357886::ConcatenateDataAsHigherEdcParam,
            0 => EdcpExtension2564357886::Completed,
            255 => EdcpExtension2564357886::NoErrIndicatorEdcParamAvailable,
            value => EdcpExtension2564357886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ErrorIndicator2564357886 {
    NoErrorIndicatorAvailable,
    TransprtNotComplWithinTimeAllowd,
    TransportNotInitWithinTimeAllowd,
    NoResponseInTheTimeAllowed,
    ModuleExceedingNumberOfRetries,
    AbortFromExtToNormalSoftwareProc,
    VehicleNotInParkOrNotStationary,
    EngineRunning,
    NotInEngineeringOrDevelopmentMode,
    NotInDiagnosticMode,
    InvalidKey,
    InvalidUserLevel,
    InvalidPassword,
    SecurityErrorGeneral,
    NameDoesNotConformToExpectdValue,
    DataDoesNotConformToValueRanges,
    AddrForBootLoadExeInvalidBoundary,
    AddrForBootLoadExeOutsideExeMem,
    OpReqExeTransfAndEraseOfProgMem,
    OpRequiresPriorEraseOfProgramMem,
    OpRequiresPriorEraseOfDataMem,
    ReqMemoryExceededAvailableMemory,
    LengthNotValidForMemStructAndOp,
    AddressNotOnValidBoundary,
    AddressingOrDataGeneralError,
    InternalFailurePreventingReq,
    PromDidNotVerifyOnWrite,
    FlashDidNotVerifyOnWrite,
    RamDidNotVerifyOnWrite,
    EdcParaNotCorrectForDataStream,
    ProcessUnspecReqFromThisAddress,
    ProcessingEdcpGenerationReq,
    ProcessingBootLoadReq,
    ProcessingStatusReq,
    ProcessingWriteReq,
    ProcessingReadReq,
    ProcessingEraseReq,
    ProcessingForSomeoneElse,
    ErrorNotIdentified,
    NoError,
    XValue(u64),
}

impl From<u64> for ErrorIndicator2564357886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            16777215 => ErrorIndicator2564357886::NoErrorIndicatorAvailable,
            65540 => ErrorIndicator2564357886::TransprtNotComplWithinTimeAllowd,
            65539 => ErrorIndicator2564357886::TransportNotInitWithinTimeAllowd,
            65538 => ErrorIndicator2564357886::NoResponseInTheTimeAllowed,
            65537 => ErrorIndicator2564357886::ModuleExceedingNumberOfRetries,
            65536 => ErrorIndicator2564357886::AbortFromExtToNormalSoftwareProc,
            4103 => ErrorIndicator2564357886::VehicleNotInParkOrNotStationary,
            4102 => ErrorIndicator2564357886::EngineRunning,
            4101 => ErrorIndicator2564357886::NotInEngineeringOrDevelopmentMode,
            4100 => ErrorIndicator2564357886::NotInDiagnosticMode,
            4099 => ErrorIndicator2564357886::InvalidKey,
            4098 => ErrorIndicator2564357886::InvalidUserLevel,
            4097 => ErrorIndicator2564357886::InvalidPassword,
            4096 => ErrorIndicator2564357886::SecurityErrorGeneral,
            266 => ErrorIndicator2564357886::NameDoesNotConformToExpectdValue,
            265 => ErrorIndicator2564357886::DataDoesNotConformToValueRanges,
            264 => ErrorIndicator2564357886::AddrForBootLoadExeInvalidBoundary,
            263 => ErrorIndicator2564357886::AddrForBootLoadExeOutsideExeMem,
            262 => ErrorIndicator2564357886::OpReqExeTransfAndEraseOfProgMem,
            261 => ErrorIndicator2564357886::OpRequiresPriorEraseOfProgramMem,
            260 => ErrorIndicator2564357886::OpRequiresPriorEraseOfDataMem,
            259 => ErrorIndicator2564357886::ReqMemoryExceededAvailableMemory,
            258 => ErrorIndicator2564357886::LengthNotValidForMemStructAndOp,
            257 => ErrorIndicator2564357886::AddressNotOnValidBoundary,
            256 => ErrorIndicator2564357886::AddressingOrDataGeneralError,
            36 => ErrorIndicator2564357886::InternalFailurePreventingReq,
            35 => ErrorIndicator2564357886::PromDidNotVerifyOnWrite,
            34 => ErrorIndicator2564357886::FlashDidNotVerifyOnWrite,
            33 => ErrorIndicator2564357886::RamDidNotVerifyOnWrite,
            32 => ErrorIndicator2564357886::EdcParaNotCorrectForDataStream,
            31 => ErrorIndicator2564357886::ProcessUnspecReqFromThisAddress,
            23 => ErrorIndicator2564357886::ProcessingEdcpGenerationReq,
            22 => ErrorIndicator2564357886::ProcessingBootLoadReq,
            19 => ErrorIndicator2564357886::ProcessingStatusReq,
            18 => ErrorIndicator2564357886::ProcessingWriteReq,
            17 => ErrorIndicator2564357886::ProcessingReadReq,
            16 => ErrorIndicator2564357886::ProcessingEraseReq,
            2 => ErrorIndicator2564357886::ProcessingForSomeoneElse,
            1 => ErrorIndicator2564357886::ErrorNotIdentified,
            0 => ErrorIndicator2564357886::NoError,
            value => ErrorIndicator2564357886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Status2564357886 {
    Reserved4,
    Reserved3,
    OperationFailed,
    OperationCompleted,
    Reserved2,
    Reserved1,
    Busy,
    Proceed,
    XValue(u64),
}

impl From<u64> for Status2564357886 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => Status2564357886::Reserved4,
            6 => Status2564357886::Reserved3,
            5 => Status2564357886::OperationFailed,
            4 => Status2564357886::OperationCompleted,
            3 => Status2564357886::Reserved2,
            2 => Status2564357886::Reserved1,
            1 => Status2564357886::Busy,
            0 => Status2564357886::Proceed,
            value => Status2564357886::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum KeyOrUserLevel2564423422 {
    NoKeyAvailable,
    UseLongSeedOrKey,
    XValue(u64),
}

impl From<u64> for KeyOrUserLevel2564423422 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            65535 => KeyOrUserLevel2564423422::NoKeyAvailable,
            0 => KeyOrUserLevel2564423422::UseLongSeedOrKey,
            value => KeyOrUserLevel2564423422::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PointerExtension2564423422 {
    SpnSpace,
    XValue(u64),
}

impl From<u64> for PointerExtension2564423422 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            0 => PointerExtension2564423422::SpnSpace,
            value => PointerExtension2564423422::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Command2564423422 {
    EdcpGeneration,
    BootLoad,
    OperationFailed,
    OperationCompleted,
    StatusRequest,
    Write,
    Read,
    Erase,
    XValue(u64),
}

impl From<u64> for Command2564423422 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => Command2564423422::EdcpGeneration,
            6 => Command2564423422::BootLoad,
            5 => Command2564423422::OperationFailed,
            4 => Command2564423422::OperationCompleted,
            3 => Command2564423422::StatusRequest,
            2 => Command2564423422::Write,
            1 => Command2564423422::Read,
            0 => Command2564423422::Erase,
            value => Command2564423422::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PointerType2564423422 {
    DirectedSpatialAddressing,
    DirectMemoryAddressing,
    XValue(u64),
}

impl From<u64> for PointerType2564423422 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => PointerType2564423422::DirectedSpatialAddressing,
            0 => PointerType2564423422::DirectMemoryAddressing,
            value => PointerType2564423422::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum HoldSignal2564816638 {
    NotAvailable,
    DevicesWhoseBroadcastStateHa,
    AllDevices,
    XValue(u64),
}

impl From<u64> for HoldSignal2564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => HoldSignal2564816638::NotAvailable,
            1 => HoldSignal2564816638::DevicesWhoseBroadcastStateHa,
            0 => HoldSignal2564816638::AllDevices,
            value => HoldSignal2564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum J1939Network32564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for J1939Network32564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => J1939Network32564816638::DonXtCare,
            2 => J1939Network32564816638::Reserved,
            1 => J1939Network32564816638::StartBroadcast,
            0 => J1939Network32564816638::StopBroadcast,
            value => J1939Network32564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum J1939Network22564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for J1939Network22564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => J1939Network22564816638::DonXtCare,
            2 => J1939Network22564816638::Reserved,
            1 => J1939Network22564816638::StartBroadcast,
            0 => J1939Network22564816638::StopBroadcast,
            value => J1939Network22564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Iso91412564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for Iso91412564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Iso91412564816638::DonXtCare,
            2 => Iso91412564816638::Reserved,
            1 => Iso91412564816638::StartBroadcast,
            0 => Iso91412564816638::StopBroadcast,
            value => Iso91412564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SaeJ18502564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for SaeJ18502564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SaeJ18502564816638::DonXtCare,
            2 => SaeJ18502564816638::Reserved,
            1 => SaeJ18502564816638::StartBroadcast,
            0 => SaeJ18502564816638::StopBroadcast,
            value => SaeJ18502564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ManufacturerSpecificPort2564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for ManufacturerSpecificPort2564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ManufacturerSpecificPort2564816638::DonXtCare,
            2 => ManufacturerSpecificPort2564816638::Reserved,
            1 => ManufacturerSpecificPort2564816638::StartBroadcast,
            0 => ManufacturerSpecificPort2564816638::StopBroadcast,
            value => ManufacturerSpecificPort2564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum CurrentDataLink2564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for CurrentDataLink2564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => CurrentDataLink2564816638::DonXtCare,
            2 => CurrentDataLink2564816638::Reserved,
            1 => CurrentDataLink2564816638::StartBroadcast,
            0 => CurrentDataLink2564816638::StopBroadcast,
            value => CurrentDataLink2564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SaeJ15872564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for SaeJ15872564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SaeJ15872564816638::DonXtCare,
            2 => SaeJ15872564816638::Reserved,
            1 => SaeJ15872564816638::StartBroadcast,
            0 => SaeJ15872564816638::StopBroadcast,
            value => SaeJ15872564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SaeJ19222564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for SaeJ19222564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => SaeJ19222564816638::DonXtCare,
            2 => SaeJ19222564816638::Reserved,
            1 => SaeJ19222564816638::StartBroadcast,
            0 => SaeJ19222564816638::StopBroadcast,
            value => SaeJ19222564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum J1939Network12564816638 {
    DonXtCare,
    Reserved,
    StartBroadcast,
    StopBroadcast,
    XValue(u64),
}

impl From<u64> for J1939Network12564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => J1939Network12564816638::DonXtCare,
            2 => J1939Network12564816638::Reserved,
            1 => J1939Network12564816638::StartBroadcast,
            0 => J1939Network12564816638::StopBroadcast,
            value => J1939Network12564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum SuspendSignal2564816638 {
    NotAvailable,
    ResumingNormalBroadcastPattern,
    TemporarySuspensionOfSomeMessages,
    TemporarySuspensionOfAllBroadcasts,
    IndefiniteSuspensionOfSomeMessages,
    IndefiniteSuspensionOfAllBroadcasts,
    XValue(u64),
}

impl From<u64> for SuspendSignal2564816638 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => SuspendSignal2564816638::NotAvailable,
            14 => SuspendSignal2564816638::ResumingNormalBroadcastPattern,
            3 => SuspendSignal2564816638::TemporarySuspensionOfSomeMessages,
            2 => SuspendSignal2564816638::TemporarySuspensionOfAllBroadcasts,
            1 => SuspendSignal2564816638::IndefiniteSuspensionOfSomeMessages,
            0 => SuspendSignal2564816638::IndefiniteSuspensionOfAllBroadcasts,
            value => SuspendSignal2564816638::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2566837502 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2566837502::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2566837502::Reserved,
            1 => FlashRedStopLamp2566837502::FastFlash,
            0 => FlashRedStopLamp2566837502::SlowFlash,
            value => FlashRedStopLamp2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2566837502 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2566837502::UnavailableDoNotFlash,
            2 => FlashProtectLamp2566837502::Reserved,
            1 => FlashProtectLamp2566837502::FastFlash,
            0 => FlashProtectLamp2566837502::SlowFlash,
            value => FlashProtectLamp2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52566837502 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52566837502::NotAvailable,
            19 => FailureModeIdentifier52566837502::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52566837502::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52566837502::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52566837502::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52566837502::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52566837502::SpecialIntstructions,
            13 => FailureModeIdentifier52566837502::OutOfCalibration,
            12 => FailureModeIdentifier52566837502::BadIntelligentDevice,
            11 => FailureModeIdentifier52566837502::RootCauseNotKnown,
            10 => FailureModeIdentifier52566837502::AbnormalRateOfChange,
            9 => FailureModeIdentifier52566837502::AbnormalUpdateRate,
            8 => FailureModeIdentifier52566837502::AbnormalFrequency,
            7 => FailureModeIdentifier52566837502::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52566837502::CurrentAboveNormal,
            5 => FailureModeIdentifier52566837502::CurrentBelowNormal,
            4 => FailureModeIdentifier52566837502::VoltageBelowNormal,
            3 => FailureModeIdentifier52566837502::VoltageAboveNormal,
            2 => FailureModeIdentifier52566837502::DataErratic,
            1 => FailureModeIdentifier52566837502::BelowNormalMostSevere,
            0 => FailureModeIdentifier52566837502::AboveNormalMostSevere,
            value => FailureModeIdentifier52566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42566837502 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42566837502::NotAvailable,
            19 => FailureModeIdentifier42566837502::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42566837502::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42566837502::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42566837502::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42566837502::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42566837502::SpecialIntstructions,
            13 => FailureModeIdentifier42566837502::OutOfCalibration,
            12 => FailureModeIdentifier42566837502::BadIntelligentDevice,
            11 => FailureModeIdentifier42566837502::RootCauseNotKnown,
            10 => FailureModeIdentifier42566837502::AbnormalRateOfChange,
            9 => FailureModeIdentifier42566837502::AbnormalUpdateRate,
            8 => FailureModeIdentifier42566837502::AbnormalFrequency,
            7 => FailureModeIdentifier42566837502::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42566837502::CurrentAboveNormal,
            5 => FailureModeIdentifier42566837502::CurrentBelowNormal,
            4 => FailureModeIdentifier42566837502::VoltageBelowNormal,
            3 => FailureModeIdentifier42566837502::VoltageAboveNormal,
            2 => FailureModeIdentifier42566837502::DataErratic,
            1 => FailureModeIdentifier42566837502::BelowNormalMostSevere,
            0 => FailureModeIdentifier42566837502::AboveNormalMostSevere,
            value => FailureModeIdentifier42566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32566837502 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32566837502::NotAvailable,
            19 => FailureModeIdentifier32566837502::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32566837502::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32566837502::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32566837502::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32566837502::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32566837502::SpecialIntstructions,
            13 => FailureModeIdentifier32566837502::OutOfCalibration,
            12 => FailureModeIdentifier32566837502::BadIntelligentDevice,
            11 => FailureModeIdentifier32566837502::RootCauseNotKnown,
            10 => FailureModeIdentifier32566837502::AbnormalRateOfChange,
            9 => FailureModeIdentifier32566837502::AbnormalUpdateRate,
            8 => FailureModeIdentifier32566837502::AbnormalFrequency,
            7 => FailureModeIdentifier32566837502::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32566837502::CurrentAboveNormal,
            5 => FailureModeIdentifier32566837502::CurrentBelowNormal,
            4 => FailureModeIdentifier32566837502::VoltageBelowNormal,
            3 => FailureModeIdentifier32566837502::VoltageAboveNormal,
            2 => FailureModeIdentifier32566837502::DataErratic,
            1 => FailureModeIdentifier32566837502::BelowNormalMostSevere,
            0 => FailureModeIdentifier32566837502::AboveNormalMostSevere,
            value => FailureModeIdentifier32566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566837502 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566837502::NotAvailable,
            19 => FailureModeIdentifier12566837502::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566837502::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566837502::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566837502::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566837502::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566837502::SpecialIntstructions,
            13 => FailureModeIdentifier12566837502::OutOfCalibration,
            12 => FailureModeIdentifier12566837502::BadIntelligentDevice,
            11 => FailureModeIdentifier12566837502::RootCauseNotKnown,
            10 => FailureModeIdentifier12566837502::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566837502::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566837502::AbnormalFrequency,
            7 => FailureModeIdentifier12566837502::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566837502::CurrentAboveNormal,
            5 => FailureModeIdentifier12566837502::CurrentBelowNormal,
            4 => FailureModeIdentifier12566837502::VoltageBelowNormal,
            3 => FailureModeIdentifier12566837502::VoltageAboveNormal,
            2 => FailureModeIdentifier12566837502::DataErratic,
            1 => FailureModeIdentifier12566837502::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566837502::AboveNormalMostSevere,
            value => FailureModeIdentifier12566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2566837502 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2566837502::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2566837502::Reserved,
            1 => MalfunctionIndicatorLampStatus2566837502::LampOn,
            0 => MalfunctionIndicatorLampStatus2566837502::LampOff,
            value => MalfunctionIndicatorLampStatus2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2566837502 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2566837502::NotAvailable,
            2 => RedStopLampState2566837502::Reserved,
            1 => RedStopLampState2566837502::LampOn,
            0 => RedStopLampState2566837502::LampOff,
            value => RedStopLampState2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2566837502 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2566837502::NotAvailable,
            2 => AmberWarningLampStatus2566837502::Reserved,
            1 => AmberWarningLampStatus2566837502::LampOn,
            0 => AmberWarningLampStatus2566837502::LampOff,
            value => AmberWarningLampStatus2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2566837502 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2566837502::NotAvailable,
            2 => ProtectLampStatus2566837502::Reserved,
            1 => ProtectLampStatus2566837502::LampOn,
            0 => ProtectLampStatus2566837502::LampOff,
            value => ProtectLampStatus2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2566837502 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2566837502::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2566837502::Reserved,
            1 => FlashMalfuncIndicatorLamp2566837502::FastFlash,
            0 => FlashMalfuncIndicatorLamp2566837502::SlowFlash,
            value => FlashMalfuncIndicatorLamp2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2566837502 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2566837502::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2566837502::Reserved,
            1 => FlashAmberWarningLamp2566837502::FastFlash,
            0 => FlashAmberWarningLamp2566837502::SlowFlash,
            value => FlashAmberWarningLamp2566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22566837502 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22566837502 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22566837502::NotAvailable,
            19 => FailureModeIdentifier22566837502::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22566837502::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22566837502::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22566837502::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22566837502::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22566837502::SpecialIntstructions,
            13 => FailureModeIdentifier22566837502::OutOfCalibration,
            12 => FailureModeIdentifier22566837502::BadIntelligentDevice,
            11 => FailureModeIdentifier22566837502::RootCauseNotKnown,
            10 => FailureModeIdentifier22566837502::AbnormalRateOfChange,
            9 => FailureModeIdentifier22566837502::AbnormalUpdateRate,
            8 => FailureModeIdentifier22566837502::AbnormalFrequency,
            7 => FailureModeIdentifier22566837502::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22566837502::CurrentAboveNormal,
            5 => FailureModeIdentifier22566837502::CurrentBelowNormal,
            4 => FailureModeIdentifier22566837502::VoltageBelowNormal,
            3 => FailureModeIdentifier22566837502::VoltageAboveNormal,
            2 => FailureModeIdentifier22566837502::DataErratic,
            1 => FailureModeIdentifier22566837502::BelowNormalMostSevere,
            0 => FailureModeIdentifier22566837502::AboveNormalMostSevere,
            value => FailureModeIdentifier22566837502::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52566834942 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52566834942::NotAvailable,
            19 => FailureModeIdentifier52566834942::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52566834942::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52566834942::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52566834942::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52566834942::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52566834942::SpecialIntstructions,
            13 => FailureModeIdentifier52566834942::OutOfCalibration,
            12 => FailureModeIdentifier52566834942::BadIntelligentDevice,
            11 => FailureModeIdentifier52566834942::RootCauseNotKnown,
            10 => FailureModeIdentifier52566834942::AbnormalRateOfChange,
            9 => FailureModeIdentifier52566834942::AbnormalUpdateRate,
            8 => FailureModeIdentifier52566834942::AbnormalFrequency,
            7 => FailureModeIdentifier52566834942::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52566834942::CurrentAboveNormal,
            5 => FailureModeIdentifier52566834942::CurrentBelowNormal,
            4 => FailureModeIdentifier52566834942::VoltageBelowNormal,
            3 => FailureModeIdentifier52566834942::VoltageAboveNormal,
            2 => FailureModeIdentifier52566834942::DataErratic,
            1 => FailureModeIdentifier52566834942::BelowNormalMostSevere,
            0 => FailureModeIdentifier52566834942::AboveNormalMostSevere,
            value => FailureModeIdentifier52566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42566834942 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42566834942::NotAvailable,
            19 => FailureModeIdentifier42566834942::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42566834942::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42566834942::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42566834942::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42566834942::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42566834942::SpecialIntstructions,
            13 => FailureModeIdentifier42566834942::OutOfCalibration,
            12 => FailureModeIdentifier42566834942::BadIntelligentDevice,
            11 => FailureModeIdentifier42566834942::RootCauseNotKnown,
            10 => FailureModeIdentifier42566834942::AbnormalRateOfChange,
            9 => FailureModeIdentifier42566834942::AbnormalUpdateRate,
            8 => FailureModeIdentifier42566834942::AbnormalFrequency,
            7 => FailureModeIdentifier42566834942::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42566834942::CurrentAboveNormal,
            5 => FailureModeIdentifier42566834942::CurrentBelowNormal,
            4 => FailureModeIdentifier42566834942::VoltageBelowNormal,
            3 => FailureModeIdentifier42566834942::VoltageAboveNormal,
            2 => FailureModeIdentifier42566834942::DataErratic,
            1 => FailureModeIdentifier42566834942::BelowNormalMostSevere,
            0 => FailureModeIdentifier42566834942::AboveNormalMostSevere,
            value => FailureModeIdentifier42566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32566834942 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32566834942::NotAvailable,
            19 => FailureModeIdentifier32566834942::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32566834942::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32566834942::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32566834942::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32566834942::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32566834942::SpecialIntstructions,
            13 => FailureModeIdentifier32566834942::OutOfCalibration,
            12 => FailureModeIdentifier32566834942::BadIntelligentDevice,
            11 => FailureModeIdentifier32566834942::RootCauseNotKnown,
            10 => FailureModeIdentifier32566834942::AbnormalRateOfChange,
            9 => FailureModeIdentifier32566834942::AbnormalUpdateRate,
            8 => FailureModeIdentifier32566834942::AbnormalFrequency,
            7 => FailureModeIdentifier32566834942::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32566834942::CurrentAboveNormal,
            5 => FailureModeIdentifier32566834942::CurrentBelowNormal,
            4 => FailureModeIdentifier32566834942::VoltageBelowNormal,
            3 => FailureModeIdentifier32566834942::VoltageAboveNormal,
            2 => FailureModeIdentifier32566834942::DataErratic,
            1 => FailureModeIdentifier32566834942::BelowNormalMostSevere,
            0 => FailureModeIdentifier32566834942::AboveNormalMostSevere,
            value => FailureModeIdentifier32566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2566834942 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2566834942::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2566834942::Reserved,
            1 => FlashRedStopLamp2566834942::FastFlash,
            0 => FlashRedStopLamp2566834942::SlowFlash,
            value => FlashRedStopLamp2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2566834942 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2566834942::UnavailableDoNotFlash,
            2 => FlashProtectLamp2566834942::Reserved,
            1 => FlashProtectLamp2566834942::FastFlash,
            0 => FlashProtectLamp2566834942::SlowFlash,
            value => FlashProtectLamp2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2566834942 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2566834942::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2566834942::Reserved,
            1 => FlashMalfuncIndicatorLamp2566834942::FastFlash,
            0 => FlashMalfuncIndicatorLamp2566834942::SlowFlash,
            value => FlashMalfuncIndicatorLamp2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2566834942 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2566834942::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2566834942::Reserved,
            1 => FlashAmberWarningLamp2566834942::FastFlash,
            0 => FlashAmberWarningLamp2566834942::SlowFlash,
            value => FlashAmberWarningLamp2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2566834942 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2566834942::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2566834942::Reserved,
            1 => MalfunctionIndicatorLampStatus2566834942::LampOn,
            0 => MalfunctionIndicatorLampStatus2566834942::LampOff,
            value => MalfunctionIndicatorLampStatus2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2566834942 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2566834942::NotAvailable,
            2 => AmberWarningLampStatus2566834942::Reserved,
            1 => AmberWarningLampStatus2566834942::LampOn,
            0 => AmberWarningLampStatus2566834942::LampOff,
            value => AmberWarningLampStatus2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566834942 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566834942::NotAvailable,
            19 => FailureModeIdentifier12566834942::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566834942::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566834942::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566834942::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566834942::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566834942::SpecialIntstructions,
            13 => FailureModeIdentifier12566834942::OutOfCalibration,
            12 => FailureModeIdentifier12566834942::BadIntelligentDevice,
            11 => FailureModeIdentifier12566834942::RootCauseNotKnown,
            10 => FailureModeIdentifier12566834942::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566834942::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566834942::AbnormalFrequency,
            7 => FailureModeIdentifier12566834942::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566834942::CurrentAboveNormal,
            5 => FailureModeIdentifier12566834942::CurrentBelowNormal,
            4 => FailureModeIdentifier12566834942::VoltageBelowNormal,
            3 => FailureModeIdentifier12566834942::VoltageAboveNormal,
            2 => FailureModeIdentifier12566834942::DataErratic,
            1 => FailureModeIdentifier12566834942::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566834942::AboveNormalMostSevere,
            value => FailureModeIdentifier12566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2566834942 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2566834942::NotAvailable,
            2 => RedStopLampState2566834942::Reserved,
            1 => RedStopLampState2566834942::LampOn,
            0 => RedStopLampState2566834942::LampOff,
            value => RedStopLampState2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2566834942 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2566834942::NotAvailable,
            2 => ProtectLampStatus2566834942::Reserved,
            1 => ProtectLampStatus2566834942::LampOn,
            0 => ProtectLampStatus2566834942::LampOff,
            value => ProtectLampStatus2566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22566834942 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22566834942 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22566834942::NotAvailable,
            19 => FailureModeIdentifier22566834942::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22566834942::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22566834942::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22566834942::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22566834942::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22566834942::SpecialIntstructions,
            13 => FailureModeIdentifier22566834942::OutOfCalibration,
            12 => FailureModeIdentifier22566834942::BadIntelligentDevice,
            11 => FailureModeIdentifier22566834942::RootCauseNotKnown,
            10 => FailureModeIdentifier22566834942::AbnormalRateOfChange,
            9 => FailureModeIdentifier22566834942::AbnormalUpdateRate,
            8 => FailureModeIdentifier22566834942::AbnormalFrequency,
            7 => FailureModeIdentifier22566834942::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22566834942::CurrentAboveNormal,
            5 => FailureModeIdentifier22566834942::CurrentBelowNormal,
            4 => FailureModeIdentifier22566834942::VoltageBelowNormal,
            3 => FailureModeIdentifier22566834942::VoltageAboveNormal,
            2 => FailureModeIdentifier22566834942::DataErratic,
            1 => FailureModeIdentifier22566834942::BelowNormalMostSevere,
            0 => FailureModeIdentifier22566834942::AboveNormalMostSevere,
            value => FailureModeIdentifier22566834942::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum IndustryGroup2566838526 {
    ReserveForSae,
    IndustrialProcessCtrlStationary,
    Marine,
    Construction,
    AgriculturalAndForestry,
    OnHighway,
    Global,
    XValue(u64),
}

impl From<u64> for IndustryGroup2566838526 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => IndustryGroup2566838526::ReserveForSae,
            5 => IndustryGroup2566838526::IndustrialProcessCtrlStationary,
            4 => IndustryGroup2566838526::Marine,
            3 => IndustryGroup2566838526::Construction,
            2 => IndustryGroup2566838526::AgriculturalAndForestry,
            1 => IndustryGroup2566838526::OnHighway,
            0 => IndustryGroup2566838526::Global,
            value => IndustryGroup2566838526::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum IndustryGroup2565799678 {
    ReserveForSae,
    IndustrialProcessCtrlStationary,
    Marine,
    Construction,
    AgriculturalAndForestry,
    OnHighway,
    Global,
    XValue(u64),
}

impl From<u64> for IndustryGroup2565799678 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => IndustryGroup2565799678::ReserveForSae,
            5 => IndustryGroup2565799678::IndustrialProcessCtrlStationary,
            4 => IndustryGroup2565799678::Marine,
            3 => IndustryGroup2565799678::Construction,
            2 => IndustryGroup2565799678::AgriculturalAndForestry,
            1 => IndustryGroup2565799678::OnHighway,
            0 => IndustryGroup2565799678::Global,
            value => IndustryGroup2565799678::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PgNumber2565668606 {
    NotAvailable,
    XValue(u64),
}

impl From<u64> for PgNumber2565668606 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            255 => PgNumber2565668606::NotAvailable,
            value => PgNumber2565668606::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ControlByte2565668606 {
    EAbort,
    EEoMack,
    Edpo,
    Ects,
    Erts,
    Abort,
    Bam,
    EoMa,
    Cts,
    Rts,
    XValue(u64),
}

impl From<u64> for ControlByte2565668606 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            24 => ControlByte2565668606::EAbort,
            23 => ControlByte2565668606::EEoMack,
            22 => ControlByte2565668606::Edpo,
            21 => ControlByte2565668606::Ects,
            20 => ControlByte2565668606::Erts,
            255 => ControlByte2565668606::Abort,
            32 => ControlByte2565668606::Bam,
            19 => ControlByte2565668606::EoMa,
            17 => ControlByte2565668606::Cts,
            16 => ControlByte2565668606::Rts,
            value => ControlByte2565668606::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum UseTransferMode2563374846 {
    Na,
    Undefined,
    Yes,
    No,
    XValue(u64),
}

impl From<u64> for UseTransferMode2563374846 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => UseTransferMode2563374846::Na,
            2 => UseTransferMode2563374846::Undefined,
            1 => UseTransferMode2563374846::Yes,
            0 => UseTransferMode2563374846::No,
            value => UseTransferMode2563374846::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52566750462 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52566750462::NotAvailable,
            19 => FailureModeIdentifier52566750462::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52566750462::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52566750462::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52566750462::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52566750462::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52566750462::SpecialIntstructions,
            13 => FailureModeIdentifier52566750462::OutOfCalibration,
            12 => FailureModeIdentifier52566750462::BadIntelligentDevice,
            11 => FailureModeIdentifier52566750462::RootCauseNotKnown,
            10 => FailureModeIdentifier52566750462::AbnormalRateOfChange,
            9 => FailureModeIdentifier52566750462::AbnormalUpdateRate,
            8 => FailureModeIdentifier52566750462::AbnormalFrequency,
            7 => FailureModeIdentifier52566750462::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52566750462::CurrentAboveNormal,
            5 => FailureModeIdentifier52566750462::CurrentBelowNormal,
            4 => FailureModeIdentifier52566750462::VoltageBelowNormal,
            3 => FailureModeIdentifier52566750462::VoltageAboveNormal,
            2 => FailureModeIdentifier52566750462::DataErratic,
            1 => FailureModeIdentifier52566750462::BelowNormalMostSevere,
            0 => FailureModeIdentifier52566750462::AboveNormalMostSevere,
            value => FailureModeIdentifier52566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42566750462 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42566750462::NotAvailable,
            19 => FailureModeIdentifier42566750462::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42566750462::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42566750462::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42566750462::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42566750462::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42566750462::SpecialIntstructions,
            13 => FailureModeIdentifier42566750462::OutOfCalibration,
            12 => FailureModeIdentifier42566750462::BadIntelligentDevice,
            11 => FailureModeIdentifier42566750462::RootCauseNotKnown,
            10 => FailureModeIdentifier42566750462::AbnormalRateOfChange,
            9 => FailureModeIdentifier42566750462::AbnormalUpdateRate,
            8 => FailureModeIdentifier42566750462::AbnormalFrequency,
            7 => FailureModeIdentifier42566750462::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42566750462::CurrentAboveNormal,
            5 => FailureModeIdentifier42566750462::CurrentBelowNormal,
            4 => FailureModeIdentifier42566750462::VoltageBelowNormal,
            3 => FailureModeIdentifier42566750462::VoltageAboveNormal,
            2 => FailureModeIdentifier42566750462::DataErratic,
            1 => FailureModeIdentifier42566750462::BelowNormalMostSevere,
            0 => FailureModeIdentifier42566750462::AboveNormalMostSevere,
            value => FailureModeIdentifier42566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32566750462 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32566750462::NotAvailable,
            19 => FailureModeIdentifier32566750462::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32566750462::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32566750462::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32566750462::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32566750462::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32566750462::SpecialIntstructions,
            13 => FailureModeIdentifier32566750462::OutOfCalibration,
            12 => FailureModeIdentifier32566750462::BadIntelligentDevice,
            11 => FailureModeIdentifier32566750462::RootCauseNotKnown,
            10 => FailureModeIdentifier32566750462::AbnormalRateOfChange,
            9 => FailureModeIdentifier32566750462::AbnormalUpdateRate,
            8 => FailureModeIdentifier32566750462::AbnormalFrequency,
            7 => FailureModeIdentifier32566750462::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32566750462::CurrentAboveNormal,
            5 => FailureModeIdentifier32566750462::CurrentBelowNormal,
            4 => FailureModeIdentifier32566750462::VoltageBelowNormal,
            3 => FailureModeIdentifier32566750462::VoltageAboveNormal,
            2 => FailureModeIdentifier32566750462::DataErratic,
            1 => FailureModeIdentifier32566750462::BelowNormalMostSevere,
            0 => FailureModeIdentifier32566750462::AboveNormalMostSevere,
            value => FailureModeIdentifier32566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2566750462 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2566750462::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2566750462::Reserved,
            1 => FlashRedStopLamp2566750462::FastFlash,
            0 => FlashRedStopLamp2566750462::SlowFlash,
            value => FlashRedStopLamp2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2566750462 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2566750462::UnavailableDoNotFlash,
            2 => FlashProtectLamp2566750462::Reserved,
            1 => FlashProtectLamp2566750462::FastFlash,
            0 => FlashProtectLamp2566750462::SlowFlash,
            value => FlashProtectLamp2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2566750462 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2566750462::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2566750462::Reserved,
            1 => FlashMalfuncIndicatorLamp2566750462::FastFlash,
            0 => FlashMalfuncIndicatorLamp2566750462::SlowFlash,
            value => FlashMalfuncIndicatorLamp2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2566750462 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2566750462::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2566750462::Reserved,
            1 => FlashAmberWarningLamp2566750462::FastFlash,
            0 => FlashAmberWarningLamp2566750462::SlowFlash,
            value => FlashAmberWarningLamp2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2566750462 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2566750462::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2566750462::Reserved,
            1 => MalfunctionIndicatorLampStatus2566750462::LampOn,
            0 => MalfunctionIndicatorLampStatus2566750462::LampOff,
            value => MalfunctionIndicatorLampStatus2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2566750462 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2566750462::NotAvailable,
            2 => AmberWarningLampStatus2566750462::Reserved,
            1 => AmberWarningLampStatus2566750462::LampOn,
            0 => AmberWarningLampStatus2566750462::LampOff,
            value => AmberWarningLampStatus2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566750462 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566750462::NotAvailable,
            19 => FailureModeIdentifier12566750462::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566750462::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566750462::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566750462::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566750462::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566750462::SpecialIntstructions,
            13 => FailureModeIdentifier12566750462::OutOfCalibration,
            12 => FailureModeIdentifier12566750462::BadIntelligentDevice,
            11 => FailureModeIdentifier12566750462::RootCauseNotKnown,
            10 => FailureModeIdentifier12566750462::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566750462::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566750462::AbnormalFrequency,
            7 => FailureModeIdentifier12566750462::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566750462::CurrentAboveNormal,
            5 => FailureModeIdentifier12566750462::CurrentBelowNormal,
            4 => FailureModeIdentifier12566750462::VoltageBelowNormal,
            3 => FailureModeIdentifier12566750462::VoltageAboveNormal,
            2 => FailureModeIdentifier12566750462::DataErratic,
            1 => FailureModeIdentifier12566750462::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566750462::AboveNormalMostSevere,
            value => FailureModeIdentifier12566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2566750462 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2566750462::NotAvailable,
            2 => RedStopLampState2566750462::Reserved,
            1 => RedStopLampState2566750462::LampOn,
            0 => RedStopLampState2566750462::LampOff,
            value => RedStopLampState2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2566750462 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2566750462::NotAvailable,
            2 => ProtectLampStatus2566750462::Reserved,
            1 => ProtectLampStatus2566750462::LampOn,
            0 => ProtectLampStatus2566750462::LampOff,
            value => ProtectLampStatus2566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22566750462 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22566750462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22566750462::NotAvailable,
            19 => FailureModeIdentifier22566750462::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22566750462::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22566750462::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22566750462::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22566750462::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22566750462::SpecialIntstructions,
            13 => FailureModeIdentifier22566750462::OutOfCalibration,
            12 => FailureModeIdentifier22566750462::BadIntelligentDevice,
            11 => FailureModeIdentifier22566750462::RootCauseNotKnown,
            10 => FailureModeIdentifier22566750462::AbnormalRateOfChange,
            9 => FailureModeIdentifier22566750462::AbnormalUpdateRate,
            8 => FailureModeIdentifier22566750462::AbnormalFrequency,
            7 => FailureModeIdentifier22566750462::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22566750462::CurrentAboveNormal,
            5 => FailureModeIdentifier22566750462::CurrentBelowNormal,
            4 => FailureModeIdentifier22566750462::VoltageBelowNormal,
            3 => FailureModeIdentifier22566750462::VoltageAboveNormal,
            2 => FailureModeIdentifier22566750462::DataErratic,
            1 => FailureModeIdentifier22566750462::BelowNormalMostSevere,
            0 => FailureModeIdentifier22566750462::AboveNormalMostSevere,
            value => FailureModeIdentifier22566750462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier52566750974 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier52566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier52566750974::NotAvailable,
            19 => FailureModeIdentifier52566750974::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier52566750974::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier52566750974::BelowNormalLeastSevere,
            16 => FailureModeIdentifier52566750974::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier52566750974::AboveNormalLeastSevere,
            14 => FailureModeIdentifier52566750974::SpecialIntstructions,
            13 => FailureModeIdentifier52566750974::OutOfCalibration,
            12 => FailureModeIdentifier52566750974::BadIntelligentDevice,
            11 => FailureModeIdentifier52566750974::RootCauseNotKnown,
            10 => FailureModeIdentifier52566750974::AbnormalRateOfChange,
            9 => FailureModeIdentifier52566750974::AbnormalUpdateRate,
            8 => FailureModeIdentifier52566750974::AbnormalFrequency,
            7 => FailureModeIdentifier52566750974::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier52566750974::CurrentAboveNormal,
            5 => FailureModeIdentifier52566750974::CurrentBelowNormal,
            4 => FailureModeIdentifier52566750974::VoltageBelowNormal,
            3 => FailureModeIdentifier52566750974::VoltageAboveNormal,
            2 => FailureModeIdentifier52566750974::DataErratic,
            1 => FailureModeIdentifier52566750974::BelowNormalMostSevere,
            0 => FailureModeIdentifier52566750974::AboveNormalMostSevere,
            value => FailureModeIdentifier52566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier42566750974 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier42566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier42566750974::NotAvailable,
            19 => FailureModeIdentifier42566750974::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier42566750974::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier42566750974::BelowNormalLeastSevere,
            16 => FailureModeIdentifier42566750974::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier42566750974::AboveNormalLeastSevere,
            14 => FailureModeIdentifier42566750974::SpecialIntstructions,
            13 => FailureModeIdentifier42566750974::OutOfCalibration,
            12 => FailureModeIdentifier42566750974::BadIntelligentDevice,
            11 => FailureModeIdentifier42566750974::RootCauseNotKnown,
            10 => FailureModeIdentifier42566750974::AbnormalRateOfChange,
            9 => FailureModeIdentifier42566750974::AbnormalUpdateRate,
            8 => FailureModeIdentifier42566750974::AbnormalFrequency,
            7 => FailureModeIdentifier42566750974::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier42566750974::CurrentAboveNormal,
            5 => FailureModeIdentifier42566750974::CurrentBelowNormal,
            4 => FailureModeIdentifier42566750974::VoltageBelowNormal,
            3 => FailureModeIdentifier42566750974::VoltageAboveNormal,
            2 => FailureModeIdentifier42566750974::DataErratic,
            1 => FailureModeIdentifier42566750974::BelowNormalMostSevere,
            0 => FailureModeIdentifier42566750974::AboveNormalMostSevere,
            value => FailureModeIdentifier42566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier32566750974 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier32566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier32566750974::NotAvailable,
            19 => FailureModeIdentifier32566750974::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier32566750974::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier32566750974::BelowNormalLeastSevere,
            16 => FailureModeIdentifier32566750974::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier32566750974::AboveNormalLeastSevere,
            14 => FailureModeIdentifier32566750974::SpecialIntstructions,
            13 => FailureModeIdentifier32566750974::OutOfCalibration,
            12 => FailureModeIdentifier32566750974::BadIntelligentDevice,
            11 => FailureModeIdentifier32566750974::RootCauseNotKnown,
            10 => FailureModeIdentifier32566750974::AbnormalRateOfChange,
            9 => FailureModeIdentifier32566750974::AbnormalUpdateRate,
            8 => FailureModeIdentifier32566750974::AbnormalFrequency,
            7 => FailureModeIdentifier32566750974::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier32566750974::CurrentAboveNormal,
            5 => FailureModeIdentifier32566750974::CurrentBelowNormal,
            4 => FailureModeIdentifier32566750974::VoltageBelowNormal,
            3 => FailureModeIdentifier32566750974::VoltageAboveNormal,
            2 => FailureModeIdentifier32566750974::DataErratic,
            1 => FailureModeIdentifier32566750974::BelowNormalMostSevere,
            0 => FailureModeIdentifier32566750974::AboveNormalMostSevere,
            value => FailureModeIdentifier32566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashRedStopLamp2566750974 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashRedStopLamp2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashRedStopLamp2566750974::UnavailableDoNotFlash,
            2 => FlashRedStopLamp2566750974::Reserved,
            1 => FlashRedStopLamp2566750974::FastFlash,
            0 => FlashRedStopLamp2566750974::SlowFlash,
            value => FlashRedStopLamp2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashProtectLamp2566750974 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashProtectLamp2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashProtectLamp2566750974::UnavailableDoNotFlash,
            2 => FlashProtectLamp2566750974::Reserved,
            1 => FlashProtectLamp2566750974::FastFlash,
            0 => FlashProtectLamp2566750974::SlowFlash,
            value => FlashProtectLamp2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashMalfuncIndicatorLamp2566750974 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashMalfuncIndicatorLamp2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashMalfuncIndicatorLamp2566750974::UnavailableDoNotFlash,
            2 => FlashMalfuncIndicatorLamp2566750974::Reserved,
            1 => FlashMalfuncIndicatorLamp2566750974::FastFlash,
            0 => FlashMalfuncIndicatorLamp2566750974::SlowFlash,
            value => FlashMalfuncIndicatorLamp2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FlashAmberWarningLamp2566750974 {
    UnavailableDoNotFlash,
    Reserved,
    FastFlash,
    SlowFlash,
    XValue(u64),
}

impl From<u64> for FlashAmberWarningLamp2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FlashAmberWarningLamp2566750974::UnavailableDoNotFlash,
            2 => FlashAmberWarningLamp2566750974::Reserved,
            1 => FlashAmberWarningLamp2566750974::FastFlash,
            0 => FlashAmberWarningLamp2566750974::SlowFlash,
            value => FlashAmberWarningLamp2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum MalfunctionIndicatorLampStatus2566750974 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for MalfunctionIndicatorLampStatus2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => MalfunctionIndicatorLampStatus2566750974::NotAvailable,
            2 => MalfunctionIndicatorLampStatus2566750974::Reserved,
            1 => MalfunctionIndicatorLampStatus2566750974::LampOn,
            0 => MalfunctionIndicatorLampStatus2566750974::LampOff,
            value => MalfunctionIndicatorLampStatus2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AmberWarningLampStatus2566750974 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for AmberWarningLampStatus2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AmberWarningLampStatus2566750974::NotAvailable,
            2 => AmberWarningLampStatus2566750974::Reserved,
            1 => AmberWarningLampStatus2566750974::LampOn,
            0 => AmberWarningLampStatus2566750974::LampOff,
            value => AmberWarningLampStatus2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier12566750974 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier12566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier12566750974::NotAvailable,
            19 => FailureModeIdentifier12566750974::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier12566750974::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier12566750974::BelowNormalLeastSevere,
            16 => FailureModeIdentifier12566750974::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier12566750974::AboveNormalLeastSevere,
            14 => FailureModeIdentifier12566750974::SpecialIntstructions,
            13 => FailureModeIdentifier12566750974::OutOfCalibration,
            12 => FailureModeIdentifier12566750974::BadIntelligentDevice,
            11 => FailureModeIdentifier12566750974::RootCauseNotKnown,
            10 => FailureModeIdentifier12566750974::AbnormalRateOfChange,
            9 => FailureModeIdentifier12566750974::AbnormalUpdateRate,
            8 => FailureModeIdentifier12566750974::AbnormalFrequency,
            7 => FailureModeIdentifier12566750974::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier12566750974::CurrentAboveNormal,
            5 => FailureModeIdentifier12566750974::CurrentBelowNormal,
            4 => FailureModeIdentifier12566750974::VoltageBelowNormal,
            3 => FailureModeIdentifier12566750974::VoltageAboveNormal,
            2 => FailureModeIdentifier12566750974::DataErratic,
            1 => FailureModeIdentifier12566750974::BelowNormalMostSevere,
            0 => FailureModeIdentifier12566750974::AboveNormalMostSevere,
            value => FailureModeIdentifier12566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RedStopLampState2566750974 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for RedStopLampState2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RedStopLampState2566750974::NotAvailable,
            2 => RedStopLampState2566750974::Reserved,
            1 => RedStopLampState2566750974::LampOn,
            0 => RedStopLampState2566750974::LampOff,
            value => RedStopLampState2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ProtectLampStatus2566750974 {
    NotAvailable,
    Reserved,
    LampOn,
    LampOff,
    XValue(u64),
}

impl From<u64> for ProtectLampStatus2566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ProtectLampStatus2566750974::NotAvailable,
            2 => ProtectLampStatus2566750974::Reserved,
            1 => ProtectLampStatus2566750974::LampOn,
            0 => ProtectLampStatus2566750974::LampOff,
            value => ProtectLampStatus2566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FailureModeIdentifier22566750974 {
    NotAvailable,
    ReceivedNetworkDataInError,
    BelowNormalModeratelsSevere,
    BelowNormalLeastSevere,
    AboveNormalModeratelySevere,
    AboveNormalLeastSevere,
    SpecialIntstructions,
    OutOfCalibration,
    BadIntelligentDevice,
    RootCauseNotKnown,
    AbnormalRateOfChange,
    AbnormalUpdateRate,
    AbnormalFrequency,
    MechanicalSystemNotResponding,
    CurrentAboveNormal,
    CurrentBelowNormal,
    VoltageBelowNormal,
    VoltageAboveNormal,
    DataErratic,
    BelowNormalMostSevere,
    AboveNormalMostSevere,
    XValue(u64),
}

impl From<u64> for FailureModeIdentifier22566750974 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            31 => FailureModeIdentifier22566750974::NotAvailable,
            19 => FailureModeIdentifier22566750974::ReceivedNetworkDataInError,
            18 => FailureModeIdentifier22566750974::BelowNormalModeratelsSevere,
            17 => FailureModeIdentifier22566750974::BelowNormalLeastSevere,
            16 => FailureModeIdentifier22566750974::AboveNormalModeratelySevere,
            15 => FailureModeIdentifier22566750974::AboveNormalLeastSevere,
            14 => FailureModeIdentifier22566750974::SpecialIntstructions,
            13 => FailureModeIdentifier22566750974::OutOfCalibration,
            12 => FailureModeIdentifier22566750974::BadIntelligentDevice,
            11 => FailureModeIdentifier22566750974::RootCauseNotKnown,
            10 => FailureModeIdentifier22566750974::AbnormalRateOfChange,
            9 => FailureModeIdentifier22566750974::AbnormalUpdateRate,
            8 => FailureModeIdentifier22566750974::AbnormalFrequency,
            7 => FailureModeIdentifier22566750974::MechanicalSystemNotResponding,
            6 => FailureModeIdentifier22566750974::CurrentAboveNormal,
            5 => FailureModeIdentifier22566750974::CurrentBelowNormal,
            4 => FailureModeIdentifier22566750974::VoltageBelowNormal,
            3 => FailureModeIdentifier22566750974::VoltageAboveNormal,
            2 => FailureModeIdentifier22566750974::DataErratic,
            1 => FailureModeIdentifier22566750974::BelowNormalMostSevere,
            0 => FailureModeIdentifier22566750974::AboveNormalMostSevere,
            value => FailureModeIdentifier22566750974::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AetcDataCollectionStandard2566754558 {
    NotAvailable,
    X1101notDefined,
    Saej1995,
    XValue(u64),
}

impl From<u64> for AetcDataCollectionStandard2566754558 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => AetcDataCollectionStandard2566754558::NotAvailable,
            1 => AetcDataCollectionStandard2566754558::X1101notDefined,
            0 => AetcDataCollectionStandard2566754558::Saej1995,
            value => AetcDataCollectionStandard2566754558::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RightHeadlampLightDistribution2566749950 {
    NotAvailable,
    X1110reserved,
    DffrntLghtDstrbtnsNtAvlblNafsDs,
    LghtDstrbtnFlrMdlIsDmgdCrrntPsM,
    LghtDstrbtnFlSfPsMdlIsDmgdCrrnt,
    LghtDstrbtnAdvrsWthrAdvrsWthrLg,
    LghtDstrbtnHghBmHghBmDstrbtnOfT,
    LghtDstrbtnMtrwyTskOfMtrwyLghtI,
    LghtDstrbtnCntryCntryLghtIsMstl,
    LghtDstrbtnTwnBscLghtDstrbtnFrT,
    XValue(u64),
}

impl From<u64> for RightHeadlampLightDistribution2566749950 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => RightHeadlampLightDistribution2566749950::NotAvailable,
            8 => RightHeadlampLightDistribution2566749950::X1110reserved,
            7 => RightHeadlampLightDistribution2566749950::DffrntLghtDstrbtnsNtAvlblNafsDs,
            6 => RightHeadlampLightDistribution2566749950::LghtDstrbtnFlrMdlIsDmgdCrrntPsM,
            5 => RightHeadlampLightDistribution2566749950::LghtDstrbtnFlSfPsMdlIsDmgdCrrnt,
            4 => RightHeadlampLightDistribution2566749950::LghtDstrbtnAdvrsWthrAdvrsWthrLg,
            3 => RightHeadlampLightDistribution2566749950::LghtDstrbtnHghBmHghBmDstrbtnOfT,
            2 => RightHeadlampLightDistribution2566749950::LghtDstrbtnMtrwyTskOfMtrwyLghtI,
            1 => RightHeadlampLightDistribution2566749950::LghtDstrbtnCntryCntryLghtIsMstl,
            0 => RightHeadlampLightDistribution2566749950::LghtDstrbtnTwnBscLghtDstrbtnFrT,
            value => RightHeadlampLightDistribution2566749950::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LeftHeadlampLightDistribution2566749950 {
    NotAvailable,
    X1110reserved,
    DffrntLghtDstrbtnsNtAvlblNafsDs,
    LghtDstrbtnFlrMdlIsDmgdCrrntPsM,
    LghtDstrbtnFlSfPsMdlIsDmgdCrrnt,
    LghtDstrbtnAdvrsWthrAdvrsWthrLg,
    LghtDstrbtnHghBmHghBmDstrbtnOfT,
    LghtDstrbtnMtrwyTskOfMtrwyLghtI,
    LghtDstrbtnCntryCntryLghtIsMstl,
    LghtDstrbtnTwnBscLghtDstrbtnFrT,
    XValue(u64),
}

impl From<u64> for LeftHeadlampLightDistribution2566749950 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => LeftHeadlampLightDistribution2566749950::NotAvailable,
            8 => LeftHeadlampLightDistribution2566749950::X1110reserved,
            7 => LeftHeadlampLightDistribution2566749950::DffrntLghtDstrbtnsNtAvlblNafsDs,
            6 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnFlrMdlIsDmgdCrrntPsM,
            5 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnFlSfPsMdlIsDmgdCrrnt,
            4 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnAdvrsWthrAdvrsWthrLg,
            3 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnHghBmHghBmDstrbtnOfT,
            2 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnMtrwyTskOfMtrwyLghtI,
            1 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnCntryCntryLghtIsMstl,
            0 => LeftHeadlampLightDistribution2566749950::LghtDstrbtnTwnBscLghtDstrbtnFrT,
            value => LeftHeadlampLightDistribution2566749950::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RghtHeadlampDynamicBendingLight2566749950 {
    NotAvailable,
    X110reserved,
    DynmcBndngLghtFlrBndngLghtDsNtW,
    DynmcBndngLghtFlSfPsBndngLghtIs,
    DynmcBndngLghtIsWrkngPrprlyNrml,
    DynmcBndngLghtDctvtdThrIsNPrblm,
    XValue(u64),
}

impl From<u64> for RghtHeadlampDynamicBendingLight2566749950 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => RghtHeadlampDynamicBendingLight2566749950::NotAvailable,
            4 => RghtHeadlampDynamicBendingLight2566749950::X110reserved,
            3 => RghtHeadlampDynamicBendingLight2566749950::DynmcBndngLghtFlrBndngLghtDsNtW,
            2 => RghtHeadlampDynamicBendingLight2566749950::DynmcBndngLghtFlSfPsBndngLghtIs,
            1 => RghtHeadlampDynamicBendingLight2566749950::DynmcBndngLghtIsWrkngPrprlyNrml,
            0 => RghtHeadlampDynamicBendingLight2566749950::DynmcBndngLghtDctvtdThrIsNPrblm,
            value => RghtHeadlampDynamicBendingLight2566749950::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum LeftHeadlampDynamicBendingLight2566749950 {
    NotAvailable,
    X110reserved,
    DynmcBndngLghtFlrBndngLghtDsNtW,
    DynmcBndngLghtFlSfPsBndngLghtIs,
    DynmcBndngLghtIsWrkngPrprlyNrml,
    DynmcBndngLghtDctvtdThrIsNPrblm,
    XValue(u64),
}

impl From<u64> for LeftHeadlampDynamicBendingLight2566749950 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => LeftHeadlampDynamicBendingLight2566749950::NotAvailable,
            4 => LeftHeadlampDynamicBendingLight2566749950::X110reserved,
            3 => LeftHeadlampDynamicBendingLight2566749950::DynmcBndngLghtFlrBndngLghtDsNtW,
            2 => LeftHeadlampDynamicBendingLight2566749950::DynmcBndngLghtFlSfPsBndngLghtIs,
            1 => LeftHeadlampDynamicBendingLight2566749950::DynmcBndngLghtIsWrkngPrprlyNrml,
            0 => LeftHeadlampDynamicBendingLight2566749950::DynmcBndngLghtDctvtdThrIsNPrblm,
            value => LeftHeadlampDynamicBendingLight2566749950::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310 {
    HeaterOff,
    Preheat1,
    Preheat2,
    Automatic,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310::HeaterOff,
            2 => Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310::Preheat1,
            1 => Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310::Preheat2,
            0 => Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310::Automatic,
            value => Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1IntkWdRngO2RdngStble2565869310 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1IntkWdRngO2RdngStble2565869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1IntkWdRngO2RdngStble2565869310::NotAvailable,
            2 => Aftrtrtmnt1IntkWdRngO2RdngStble2565869310::Error,
            1 => Aftrtrtmnt1IntkWdRngO2RdngStble2565869310::Stable,
            0 => Aftrtrtmnt1IntkWdRngO2RdngStble2565869310::NotStable,
            value => Aftrtrtmnt1IntkWdRngO2RdngStble2565869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1IntkNOxReadingStable2565869310 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1IntkNOxReadingStable2565869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1IntkNOxReadingStable2565869310::NotAvailable,
            2 => Aftrtrtmnt1IntkNOxReadingStable2565869310::Error,
            1 => Aftrtrtmnt1IntkNOxReadingStable2565869310::Stable,
            0 => Aftrtrtmnt1IntkNOxReadingStable2565869310::NotStable,
            value => Aftrtrtmnt1IntkNOxReadingStable2565869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310::NotAvailable,
            2 => Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310::Error,
            1 => Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310::InRange,
            0 => Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310::NotInRange,
            value => Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566 {
    HeaterOff,
    Preheat1,
    Preheat2,
    Automatic,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566::HeaterOff,
            2 => Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566::Preheat1,
            1 => Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566::Preheat2,
            0 => Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566::Automatic,
            value => Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1OtltWdRngO2RdngStble2565869566 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1OtltWdRngO2RdngStble2565869566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1OtltWdRngO2RdngStble2565869566::NotAvailable,
            2 => Aftrtrtmnt1OtltWdRngO2RdngStble2565869566::Error,
            1 => Aftrtrtmnt1OtltWdRngO2RdngStble2565869566::Stable,
            0 => Aftrtrtmnt1OtltWdRngO2RdngStble2565869566::NotStable,
            value => Aftrtrtmnt1OtltWdRngO2RdngStble2565869566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1OtltNOxReadingStable2565869566 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1OtltNOxReadingStable2565869566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1OtltNOxReadingStable2565869566::NotAvailable,
            2 => Aftrtrtmnt1OtltNOxReadingStable2565869566::Error,
            1 => Aftrtrtmnt1OtltNOxReadingStable2565869566::Stable,
            0 => Aftrtrtmnt1OtltNOxReadingStable2565869566::NotStable,
            value => Aftrtrtmnt1OtltNOxReadingStable2565869566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1OtletGasSensorAtTemp2565869566 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1OtletGasSensorAtTemp2565869566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1OtletGasSensorAtTemp2565869566::NotAvailable,
            2 => Aftrtrtmnt1OtletGasSensorAtTemp2565869566::Error,
            1 => Aftrtrtmnt1OtletGasSensorAtTemp2565869566::InRange,
            0 => Aftrtrtmnt1OtletGasSensorAtTemp2565869566::NotInRange,
            value => Aftrtrtmnt1OtletGasSensorAtTemp2565869566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566::NotAvailable,
            2 => Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566::Error,
            1 => Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566::InRange,
            0 => Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566::NotInRange,
            value => Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822 {
    HeaterOff,
    Preheat1,
    Preheat2,
    Automatic,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822::HeaterOff,
            2 => Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822::Preheat1,
            1 => Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822::Preheat2,
            0 => Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822::Automatic,
            value => Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2IntkWdRngO2RdngStble2565869822 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2IntkWdRngO2RdngStble2565869822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2IntkWdRngO2RdngStble2565869822::NotAvailable,
            2 => Aftrtrtmnt2IntkWdRngO2RdngStble2565869822::Error,
            1 => Aftrtrtmnt2IntkWdRngO2RdngStble2565869822::Stable,
            0 => Aftrtrtmnt2IntkWdRngO2RdngStble2565869822::NotStable,
            value => Aftrtrtmnt2IntkWdRngO2RdngStble2565869822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2IntkNOxReadingStable2565869822 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2IntkNOxReadingStable2565869822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2IntkNOxReadingStable2565869822::NotAvailable,
            2 => Aftrtrtmnt2IntkNOxReadingStable2565869822::Error,
            1 => Aftrtrtmnt2IntkNOxReadingStable2565869822::Stable,
            0 => Aftrtrtmnt2IntkNOxReadingStable2565869822::NotStable,
            value => Aftrtrtmnt2IntkNOxReadingStable2565869822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2IntkeGasSensorAtTemp2565869822 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2IntkeGasSensorAtTemp2565869822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2IntkeGasSensorAtTemp2565869822::NotAvailable,
            2 => Aftrtrtmnt2IntkeGasSensorAtTemp2565869822::Error,
            1 => Aftrtrtmnt2IntkeGasSensorAtTemp2565869822::InRange,
            0 => Aftrtrtmnt2IntkeGasSensorAtTemp2565869822::NotInRange,
            value => Aftrtrtmnt2IntkeGasSensorAtTemp2565869822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822::NotAvailable,
            2 => Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822::Error,
            1 => Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822::InRange,
            0 => Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822::NotInRange,
            value => Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078 {
    HeaterOff,
    Preheat1,
    Preheat2,
    Automatic,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078::HeaterOff,
            2 => Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078::Preheat1,
            1 => Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078::Preheat2,
            0 => Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078::Automatic,
            value => Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2OtltWdRngO2RdngStble2565870078 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2OtltWdRngO2RdngStble2565870078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2OtltWdRngO2RdngStble2565870078::NotAvailable,
            2 => Aftrtrtmnt2OtltWdRngO2RdngStble2565870078::Error,
            1 => Aftrtrtmnt2OtltWdRngO2RdngStble2565870078::Stable,
            0 => Aftrtrtmnt2OtltWdRngO2RdngStble2565870078::NotStable,
            value => Aftrtrtmnt2OtltWdRngO2RdngStble2565870078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2OtltNOxReadingStable2565870078 {
    NotAvailable,
    Error,
    Stable,
    NotStable,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2OtltNOxReadingStable2565870078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2OtltNOxReadingStable2565870078::NotAvailable,
            2 => Aftrtrtmnt2OtltNOxReadingStable2565870078::Error,
            1 => Aftrtrtmnt2OtltNOxReadingStable2565870078::Stable,
            0 => Aftrtrtmnt2OtltNOxReadingStable2565870078::NotStable,
            value => Aftrtrtmnt2OtltNOxReadingStable2565870078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2OtletGasSensorAtTemp2565870078 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2OtletGasSensorAtTemp2565870078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2OtletGasSensorAtTemp2565870078::NotAvailable,
            2 => Aftrtrtmnt2OtletGasSensorAtTemp2565870078::Error,
            1 => Aftrtrtmnt2OtletGasSensorAtTemp2565870078::InRange,
            0 => Aftrtrtmnt2OtletGasSensorAtTemp2565870078::NotInRange,
            value => Aftrtrtmnt2OtletGasSensorAtTemp2565870078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078 {
    NotAvailable,
    Error,
    InRange,
    NotInRange,
    XValue(u64),
}

impl From<u64> for Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078::NotAvailable,
            2 => Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078::Error,
            1 => Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078::InRange,
            0 => Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078::NotInRange,
            value => Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParticulateTrap1AshLoadPercent2566749182 {
    LevelIsTargetAshServiceInterval,
    XValue(u64),
}

impl From<u64> for ParticulateTrap1AshLoadPercent2566749182 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => ParticulateTrap1AshLoadPercent2566749182::LevelIsTargetAshServiceInterval,
            value => ParticulateTrap1AshLoadPercent2566749182::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParticulateTrap1SootLoadPercent2566749182 {
    LvlIsActvRgnerationTriggerLevel,
    XValue(u64),
}

impl From<u64> for ParticulateTrap1SootLoadPercent2566749182 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => ParticulateTrap1SootLoadPercent2566749182::LvlIsActvRgnerationTriggerLevel,
            value => ParticulateTrap1SootLoadPercent2566749182::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParticulateTrap2AshLoadPercent2566748926 {
    LevelIsTargetAshServiceInterval,
    XValue(u64),
}

impl From<u64> for ParticulateTrap2AshLoadPercent2566748926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => ParticulateTrap2AshLoadPercent2566748926::LevelIsTargetAshServiceInterval,
            value => ParticulateTrap2AshLoadPercent2566748926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ParticulateTrap2SootLoadPercent2566748926 {
    LvlIsActvRgnerationTriggerLevel,
    XValue(u64),
}

impl From<u64> for ParticulateTrap2SootLoadPercent2566748926 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => ParticulateTrap2SootLoadPercent2566748926::LvlIsActvRgnerationTriggerLevel,
            value => ParticulateTrap2SootLoadPercent2566748926::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO452561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO452561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO452561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO452561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO452561146622::AuxChannelOn,
            0 => AuxIO452561146622::AuxChannelOff,
            value => AuxIO452561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO462561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO462561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO462561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO462561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO462561146622::AuxChannelOn,
            0 => AuxIO462561146622::AuxChannelOff,
            value => AuxIO462561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO472561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO472561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO472561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO472561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO472561146622::AuxChannelOn,
            0 => AuxIO472561146622::AuxChannelOff,
            value => AuxIO472561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO482561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO482561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO482561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO482561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO482561146622::AuxChannelOn,
            0 => AuxIO482561146622::AuxChannelOff,
            value => AuxIO482561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO412561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO412561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO412561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO412561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO412561146622::AuxChannelOn,
            0 => AuxIO412561146622::AuxChannelOff,
            value => AuxIO412561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO422561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO422561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO422561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO422561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO422561146622::AuxChannelOn,
            0 => AuxIO422561146622::AuxChannelOff,
            value => AuxIO422561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO432561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO432561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO432561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO432561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO432561146622::AuxChannelOn,
            0 => AuxIO432561146622::AuxChannelOff,
            value => AuxIO432561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO442561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO442561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO442561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO442561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO442561146622::AuxChannelOn,
            0 => AuxIO442561146622::AuxChannelOff,
            value => AuxIO442561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO372561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO372561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO372561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO372561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO372561146622::AuxChannelOn,
            0 => AuxIO372561146622::AuxChannelOff,
            value => AuxIO372561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO382561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO382561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO382561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO382561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO382561146622::AuxChannelOn,
            0 => AuxIO382561146622::AuxChannelOff,
            value => AuxIO382561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO392561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO392561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO392561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO392561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO392561146622::AuxChannelOn,
            0 => AuxIO392561146622::AuxChannelOff,
            value => AuxIO392561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO402561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO402561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO402561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO402561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO402561146622::AuxChannelOn,
            0 => AuxIO402561146622::AuxChannelOff,
            value => AuxIO402561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO332561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO332561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO332561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO332561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO332561146622::AuxChannelOn,
            0 => AuxIO332561146622::AuxChannelOff,
            value => AuxIO332561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO342561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO342561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO342561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO342561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO342561146622::AuxChannelOn,
            0 => AuxIO342561146622::AuxChannelOff,
            value => AuxIO342561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO352561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO352561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO352561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO352561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO352561146622::AuxChannelOn,
            0 => AuxIO352561146622::AuxChannelOff,
            value => AuxIO352561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO362561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO362561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO362561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO362561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO362561146622::AuxChannelOn,
            0 => AuxIO362561146622::AuxChannelOff,
            value => AuxIO362561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO292561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO292561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO292561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO292561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO292561146622::AuxChannelOn,
            0 => AuxIO292561146622::AuxChannelOff,
            value => AuxIO292561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO302561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO302561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO302561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO302561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO302561146622::AuxChannelOn,
            0 => AuxIO302561146622::AuxChannelOff,
            value => AuxIO302561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO312561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO312561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO312561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO312561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO312561146622::AuxChannelOn,
            0 => AuxIO312561146622::AuxChannelOff,
            value => AuxIO312561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO322561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO322561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO322561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO322561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO322561146622::AuxChannelOn,
            0 => AuxIO322561146622::AuxChannelOff,
            value => AuxIO322561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO252561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO252561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO252561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO252561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO252561146622::AuxChannelOn,
            0 => AuxIO252561146622::AuxChannelOff,
            value => AuxIO252561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO262561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO262561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO262561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO262561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO262561146622::AuxChannelOn,
            0 => AuxIO262561146622::AuxChannelOff,
            value => AuxIO262561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO272561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO272561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO272561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO272561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO272561146622::AuxChannelOn,
            0 => AuxIO272561146622::AuxChannelOff,
            value => AuxIO272561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO282561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO282561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO282561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO282561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO282561146622::AuxChannelOn,
            0 => AuxIO282561146622::AuxChannelOff,
            value => AuxIO282561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO212561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO212561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO212561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO212561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO212561146622::AuxChannelOn,
            0 => AuxIO212561146622::AuxChannelOff,
            value => AuxIO212561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO222561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO222561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO222561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO222561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO222561146622::AuxChannelOn,
            0 => AuxIO222561146622::AuxChannelOff,
            value => AuxIO222561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO232561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO232561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO232561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO232561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO232561146622::AuxChannelOn,
            0 => AuxIO232561146622::AuxChannelOff,
            value => AuxIO232561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO242561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO242561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO242561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO242561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO242561146622::AuxChannelOn,
            0 => AuxIO242561146622::AuxChannelOff,
            value => AuxIO242561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO172561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO172561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO172561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO172561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO172561146622::AuxChannelOn,
            0 => AuxIO172561146622::AuxChannelOff,
            value => AuxIO172561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO182561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO182561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO182561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO182561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO182561146622::AuxChannelOn,
            0 => AuxIO182561146622::AuxChannelOff,
            value => AuxIO182561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO192561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO192561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO192561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO192561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO192561146622::AuxChannelOn,
            0 => AuxIO192561146622::AuxChannelOff,
            value => AuxIO192561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO202561146622 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO202561146622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO202561146622::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO202561146622::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO202561146622::AuxChannelOn,
            0 => AuxIO202561146622::AuxChannelOff,
            value => AuxIO202561146622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO772561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO772561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO772561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO772561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO772561081086::AuxChannelOn,
            0 => AuxIO772561081086::AuxChannelOff,
            value => AuxIO772561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO782561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO782561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO782561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO782561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO782561081086::AuxChannelOn,
            0 => AuxIO782561081086::AuxChannelOff,
            value => AuxIO782561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO792561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO792561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO792561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO792561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO792561081086::AuxChannelOn,
            0 => AuxIO792561081086::AuxChannelOff,
            value => AuxIO792561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO802561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO802561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO802561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO802561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO802561081086::AuxChannelOn,
            0 => AuxIO802561081086::AuxChannelOff,
            value => AuxIO802561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO732561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO732561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO732561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO732561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO732561081086::AuxChannelOn,
            0 => AuxIO732561081086::AuxChannelOff,
            value => AuxIO732561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO742561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO742561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO742561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO742561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO742561081086::AuxChannelOn,
            0 => AuxIO742561081086::AuxChannelOff,
            value => AuxIO742561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO752561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO752561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO752561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO752561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO752561081086::AuxChannelOn,
            0 => AuxIO752561081086::AuxChannelOff,
            value => AuxIO752561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO762561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO762561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO762561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO762561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO762561081086::AuxChannelOn,
            0 => AuxIO762561081086::AuxChannelOff,
            value => AuxIO762561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO692561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO692561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO692561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO692561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO692561081086::AuxChannelOn,
            0 => AuxIO692561081086::AuxChannelOff,
            value => AuxIO692561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO702561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO702561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO702561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO702561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO702561081086::AuxChannelOn,
            0 => AuxIO702561081086::AuxChannelOff,
            value => AuxIO702561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO712561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO712561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO712561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO712561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO712561081086::AuxChannelOn,
            0 => AuxIO712561081086::AuxChannelOff,
            value => AuxIO712561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO722561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO722561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO722561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO722561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO722561081086::AuxChannelOn,
            0 => AuxIO722561081086::AuxChannelOff,
            value => AuxIO722561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO652561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO652561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO652561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO652561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO652561081086::AuxChannelOn,
            0 => AuxIO652561081086::AuxChannelOff,
            value => AuxIO652561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO662561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO662561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO662561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO662561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO662561081086::AuxChannelOn,
            0 => AuxIO662561081086::AuxChannelOff,
            value => AuxIO662561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO672561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO672561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO672561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO672561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO672561081086::AuxChannelOn,
            0 => AuxIO672561081086::AuxChannelOff,
            value => AuxIO672561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO682561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO682561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO682561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO682561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO682561081086::AuxChannelOn,
            0 => AuxIO682561081086::AuxChannelOff,
            value => AuxIO682561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO612561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO612561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO612561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO612561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO612561081086::AuxChannelOn,
            0 => AuxIO612561081086::AuxChannelOff,
            value => AuxIO612561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO622561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO622561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO622561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO622561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO622561081086::AuxChannelOn,
            0 => AuxIO622561081086::AuxChannelOff,
            value => AuxIO622561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO632561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO632561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO632561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO632561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO632561081086::AuxChannelOn,
            0 => AuxIO632561081086::AuxChannelOff,
            value => AuxIO632561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO642561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO642561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO642561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO642561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO642561081086::AuxChannelOn,
            0 => AuxIO642561081086::AuxChannelOff,
            value => AuxIO642561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO572561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO572561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO572561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO572561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO572561081086::AuxChannelOn,
            0 => AuxIO572561081086::AuxChannelOff,
            value => AuxIO572561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO582561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO582561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO582561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO582561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO582561081086::AuxChannelOn,
            0 => AuxIO582561081086::AuxChannelOff,
            value => AuxIO582561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO592561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO592561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO592561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO592561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO592561081086::AuxChannelOn,
            0 => AuxIO592561081086::AuxChannelOff,
            value => AuxIO592561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO602561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO602561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO602561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO602561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO602561081086::AuxChannelOn,
            0 => AuxIO602561081086::AuxChannelOff,
            value => AuxIO602561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO532561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO532561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO532561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO532561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO532561081086::AuxChannelOn,
            0 => AuxIO532561081086::AuxChannelOff,
            value => AuxIO532561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO542561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO542561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO542561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO542561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO542561081086::AuxChannelOn,
            0 => AuxIO542561081086::AuxChannelOff,
            value => AuxIO542561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO552561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO552561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO552561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO552561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO552561081086::AuxChannelOn,
            0 => AuxIO552561081086::AuxChannelOff,
            value => AuxIO552561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO562561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO562561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO562561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO562561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO562561081086::AuxChannelOn,
            0 => AuxIO562561081086::AuxChannelOff,
            value => AuxIO562561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO492561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO492561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO492561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO492561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO492561081086::AuxChannelOn,
            0 => AuxIO492561081086::AuxChannelOff,
            value => AuxIO492561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO502561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO502561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO502561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO502561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO502561081086::AuxChannelOn,
            0 => AuxIO502561081086::AuxChannelOff,
            value => AuxIO502561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO512561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO512561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO512561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO512561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO512561081086::AuxChannelOn,
            0 => AuxIO512561081086::AuxChannelOff,
            value => AuxIO512561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO522561081086 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO522561081086 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO522561081086::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO522561081086::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO522561081086::AuxChannelOn,
            0 => AuxIO522561081086::AuxChannelOff,
            value => AuxIO522561081086::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO922561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO922561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO922561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO922561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO922561015550::AuxChannelOn,
            0 => AuxIO922561015550::AuxChannelOff,
            value => AuxIO922561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO852561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO852561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO852561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO852561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO852561015550::AuxChannelOn,
            0 => AuxIO852561015550::AuxChannelOff,
            value => AuxIO852561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO862561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO862561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO862561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO862561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO862561015550::AuxChannelOn,
            0 => AuxIO862561015550::AuxChannelOff,
            value => AuxIO862561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO872561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO872561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO872561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO872561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO872561015550::AuxChannelOn,
            0 => AuxIO872561015550::AuxChannelOff,
            value => AuxIO872561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO882561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO882561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO882561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO882561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO882561015550::AuxChannelOn,
            0 => AuxIO882561015550::AuxChannelOff,
            value => AuxIO882561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO812561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO812561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO812561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO812561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO812561015550::AuxChannelOn,
            0 => AuxIO812561015550::AuxChannelOff,
            value => AuxIO812561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO822561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO822561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO822561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO822561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO822561015550::AuxChannelOn,
            0 => AuxIO822561015550::AuxChannelOff,
            value => AuxIO822561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO832561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO832561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO832561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO832561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO832561015550::AuxChannelOn,
            0 => AuxIO832561015550::AuxChannelOff,
            value => AuxIO832561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO842561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO842561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO842561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO842561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO842561015550::AuxChannelOn,
            0 => AuxIO842561015550::AuxChannelOff,
            value => AuxIO842561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1092561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1092561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1092561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1092561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1092561015550::AuxChannelOn,
            0 => AuxIO1092561015550::AuxChannelOff,
            value => AuxIO1092561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1102561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1102561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1102561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1102561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1102561015550::AuxChannelOn,
            0 => AuxIO1102561015550::AuxChannelOff,
            value => AuxIO1102561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1112561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1112561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1112561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1112561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1112561015550::AuxChannelOn,
            0 => AuxIO1112561015550::AuxChannelOff,
            value => AuxIO1112561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1122561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1122561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1122561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1122561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1122561015550::AuxChannelOn,
            0 => AuxIO1122561015550::AuxChannelOff,
            value => AuxIO1122561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1052561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1052561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1052561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1052561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1052561015550::AuxChannelOn,
            0 => AuxIO1052561015550::AuxChannelOff,
            value => AuxIO1052561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1062561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1062561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1062561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1062561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1062561015550::AuxChannelOn,
            0 => AuxIO1062561015550::AuxChannelOff,
            value => AuxIO1062561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1072561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1072561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1072561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1072561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1072561015550::AuxChannelOn,
            0 => AuxIO1072561015550::AuxChannelOff,
            value => AuxIO1072561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1082561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1082561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1082561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1082561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1082561015550::AuxChannelOn,
            0 => AuxIO1082561015550::AuxChannelOff,
            value => AuxIO1082561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1012561015550 {
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    NtAvlblTkNoActionDependingOnApp,
    XValue(u64),
}

impl From<u64> for AuxIO1012561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            2 => AuxIO1012561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1012561015550::AuxChannelOn,
            0 => AuxIO1012561015550::AuxChannelOff,
            3 => AuxIO1012561015550::NtAvlblTkNoActionDependingOnApp,
            value => AuxIO1012561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1022561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1022561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1022561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1022561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1022561015550::AuxChannelOn,
            0 => AuxIO1022561015550::AuxChannelOff,
            value => AuxIO1022561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1032561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1032561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1032561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1032561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1032561015550::AuxChannelOn,
            0 => AuxIO1032561015550::AuxChannelOff,
            value => AuxIO1032561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1042561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1042561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1042561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1042561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1042561015550::AuxChannelOn,
            0 => AuxIO1042561015550::AuxChannelOff,
            value => AuxIO1042561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO972561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO972561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO972561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO972561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO972561015550::AuxChannelOn,
            0 => AuxIO972561015550::AuxChannelOff,
            value => AuxIO972561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO982561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO982561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO982561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO982561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO982561015550::AuxChannelOn,
            0 => AuxIO982561015550::AuxChannelOff,
            value => AuxIO982561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO992561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO992561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO992561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO992561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO992561015550::AuxChannelOn,
            0 => AuxIO992561015550::AuxChannelOff,
            value => AuxIO992561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO1002561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO1002561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO1002561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO1002561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO1002561015550::AuxChannelOn,
            0 => AuxIO1002561015550::AuxChannelOff,
            value => AuxIO1002561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO932561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO932561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO932561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO932561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO932561015550::AuxChannelOn,
            0 => AuxIO932561015550::AuxChannelOff,
            value => AuxIO932561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO942561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO942561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO942561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO942561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO942561015550::AuxChannelOn,
            0 => AuxIO942561015550::AuxChannelOff,
            value => AuxIO942561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO952561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO952561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO952561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO952561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO952561015550::AuxChannelOn,
            0 => AuxIO952561015550::AuxChannelOff,
            value => AuxIO952561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO962561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO962561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO962561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO962561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO962561015550::AuxChannelOn,
            0 => AuxIO962561015550::AuxChannelOff,
            value => AuxIO962561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO892561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO892561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO892561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO892561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO892561015550::AuxChannelOn,
            0 => AuxIO892561015550::AuxChannelOff,
            value => AuxIO892561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO902561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO902561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO902561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO902561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO902561015550::AuxChannelOn,
            0 => AuxIO902561015550::AuxChannelOff,
            value => AuxIO902561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AuxIO912561015550 {
    NtAvlblTkNoActionDependingOnApp,
    ErrrIndctrNotUsedDependingOnApp,
    AuxChannelOn,
    AuxChannelOff,
    XValue(u64),
}

impl From<u64> for AuxIO912561015550 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AuxIO912561015550::NtAvlblTkNoActionDependingOnApp,
            2 => AuxIO912561015550::ErrrIndctrNotUsedDependingOnApp,
            1 => AuxIO912561015550::AuxChannelOn,
            0 => AuxIO912561015550::AuxChannelOff,
            value => AuxIO912561015550::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle5Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle5Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle5Right2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle5Right2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle5Right2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle5Right2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle5Right2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle5Right2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle5Right2566746622::Ok,
            value => TrailerBrakeStrokeAxle5Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle5Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle5Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle5Left2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle5Left2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle5Left2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle5Left2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle5Left2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle5Left2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle5Left2566746622::Ok,
            value => TrailerBrakeStrokeAxle5Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle4Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle4Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle4Right2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle4Right2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle4Right2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle4Right2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle4Right2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle4Right2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle4Right2566746622::Ok,
            value => TrailerBrakeStrokeAxle4Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle4Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle4Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle4Left2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle4Left2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle4Left2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle4Left2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle4Left2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle4Left2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle4Left2566746622::Ok,
            value => TrailerBrakeStrokeAxle4Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle3Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle3Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle3Right2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle3Right2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle3Right2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle3Right2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle3Right2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle3Right2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle3Right2566746622::Ok,
            value => TrailerBrakeStrokeAxle3Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle3Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle3Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle3Left2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle3Left2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle3Left2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle3Left2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle3Left2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle3Left2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle3Left2566746622::Ok,
            value => TrailerBrakeStrokeAxle3Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle2Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle2Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle2Right2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle2Right2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle2Right2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle2Right2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle2Right2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle2Right2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle2Right2566746622::Ok,
            value => TrailerBrakeStrokeAxle2Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle2Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle2Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle2Left2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle2Left2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle2Left2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle2Left2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle2Left2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle2Left2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle2Left2566746622::Ok,
            value => TrailerBrakeStrokeAxle2Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle1Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle1Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle1Right2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle1Right2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle1Right2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle1Right2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle1Right2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle1Right2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle1Right2566746622::Ok,
            value => TrailerBrakeStrokeAxle1Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TrailerBrakeStrokeAxle1Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TrailerBrakeStrokeAxle1Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TrailerBrakeStrokeAxle1Left2566746622::NotAvailable,
            6 => TrailerBrakeStrokeAxle1Left2566746622::SensorError,
            5 => TrailerBrakeStrokeAxle1Left2566746622::Reserved,
            3 => TrailerBrakeStrokeAxle1Left2566746622::DraggingBrake,
            2 => TrailerBrakeStrokeAxle1Left2566746622::Overstroke,
            1 => TrailerBrakeStrokeAxle1Left2566746622::Nonfunctioning,
            0 => TrailerBrakeStrokeAxle1Left2566746622::Ok,
            value => TrailerBrakeStrokeAxle1Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle5Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle5Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle5Right2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle5Right2566746622::SensorError,
            5 => TractorBrakeStrokeAxle5Right2566746622::Reserved,
            3 => TractorBrakeStrokeAxle5Right2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle5Right2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle5Right2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle5Right2566746622::Ok,
            value => TractorBrakeStrokeAxle5Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle5Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle5Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle5Left2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle5Left2566746622::SensorError,
            5 => TractorBrakeStrokeAxle5Left2566746622::Reserved,
            3 => TractorBrakeStrokeAxle5Left2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle5Left2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle5Left2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle5Left2566746622::Ok,
            value => TractorBrakeStrokeAxle5Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle4Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle4Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle4Right2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle4Right2566746622::SensorError,
            5 => TractorBrakeStrokeAxle4Right2566746622::Reserved,
            3 => TractorBrakeStrokeAxle4Right2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle4Right2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle4Right2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle4Right2566746622::Ok,
            value => TractorBrakeStrokeAxle4Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle4Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle4Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle4Left2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle4Left2566746622::SensorError,
            5 => TractorBrakeStrokeAxle4Left2566746622::Reserved,
            3 => TractorBrakeStrokeAxle4Left2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle4Left2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle4Left2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle4Left2566746622::Ok,
            value => TractorBrakeStrokeAxle4Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle3Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle3Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle3Right2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle3Right2566746622::SensorError,
            5 => TractorBrakeStrokeAxle3Right2566746622::Reserved,
            3 => TractorBrakeStrokeAxle3Right2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle3Right2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle3Right2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle3Right2566746622::Ok,
            value => TractorBrakeStrokeAxle3Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle3Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle3Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle3Left2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle3Left2566746622::SensorError,
            5 => TractorBrakeStrokeAxle3Left2566746622::Reserved,
            3 => TractorBrakeStrokeAxle3Left2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle3Left2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle3Left2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle3Left2566746622::Ok,
            value => TractorBrakeStrokeAxle3Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle2Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle2Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle2Right2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle2Right2566746622::SensorError,
            5 => TractorBrakeStrokeAxle2Right2566746622::Reserved,
            3 => TractorBrakeStrokeAxle2Right2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle2Right2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle2Right2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle2Right2566746622::Ok,
            value => TractorBrakeStrokeAxle2Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle2Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle2Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle2Left2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle2Left2566746622::SensorError,
            5 => TractorBrakeStrokeAxle2Left2566746622::Reserved,
            3 => TractorBrakeStrokeAxle2Left2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle2Left2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle2Left2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle2Left2566746622::Ok,
            value => TractorBrakeStrokeAxle2Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle1Right2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle1Right2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle1Right2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle1Right2566746622::SensorError,
            5 => TractorBrakeStrokeAxle1Right2566746622::Reserved,
            3 => TractorBrakeStrokeAxle1Right2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle1Right2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle1Right2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle1Right2566746622::Ok,
            value => TractorBrakeStrokeAxle1Right2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TractorBrakeStrokeAxle1Left2566746622 {
    NotAvailable,
    SensorError,
    Reserved,
    DraggingBrake,
    Overstroke,
    Nonfunctioning,
    Ok,
    XValue(u64),
}

impl From<u64> for TractorBrakeStrokeAxle1Left2566746622 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => TractorBrakeStrokeAxle1Left2566746622::NotAvailable,
            6 => TractorBrakeStrokeAxle1Left2566746622::SensorError,
            5 => TractorBrakeStrokeAxle1Left2566746622::Reserved,
            3 => TractorBrakeStrokeAxle1Left2566746622::DraggingBrake,
            2 => TractorBrakeStrokeAxle1Left2566746622::Overstroke,
            1 => TractorBrakeStrokeAxle1Left2566746622::Nonfunctioning,
            0 => TractorBrakeStrokeAxle1Left2566746622::Ok,
            value => TractorBrakeStrokeAxle1Left2566746622::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AirCompressorStatus2566827774 {
    NotAvailable,
    ErrorIndicator,
    CompressorActive,
    CompressorNotActive,
    XValue(u64),
}

impl From<u64> for AirCompressorStatus2566827774 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AirCompressorStatus2566827774::NotAvailable,
            2 => AirCompressorStatus2566827774::ErrorIndicator,
            1 => AirCompressorStatus2566827774::CompressorActive,
            0 => AirCompressorStatus2566827774::CompressorNotActive,
            value => AirCompressorStatus2566827774::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RqedAccDistanceMode2566803966 {
    NotAvailable,
    ErrorCondition,
    NotDefined,
    RqedAccDistanceMode5,
    RqedAccDistanceMode4,
    RqedAccDistanceMode3,
    RqedAccDistanceMode2,
    RqedAccDistanceMode1,
    XValue(u64),
}

impl From<u64> for RqedAccDistanceMode2566803966 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => RqedAccDistanceMode2566803966::NotAvailable,
            6 => RqedAccDistanceMode2566803966::ErrorCondition,
            5 => RqedAccDistanceMode2566803966::NotDefined,
            4 => RqedAccDistanceMode2566803966::RqedAccDistanceMode5,
            3 => RqedAccDistanceMode2566803966::RqedAccDistanceMode4,
            2 => RqedAccDistanceMode2566803966::RqedAccDistanceMode3,
            1 => RqedAccDistanceMode2566803966::RqedAccDistanceMode2,
            0 => RqedAccDistanceMode2566803966::RqedAccDistanceMode1,
            value => RqedAccDistanceMode2566803966::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccDistanceAlertSignal2432593918 {
    TakeNoAction,
    Reserved,
    AccdasActive,
    AccdasNotActive,
    XValue(u64),
}

impl From<u64> for AccDistanceAlertSignal2432593918 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccDistanceAlertSignal2432593918::TakeNoAction,
            2 => AccDistanceAlertSignal2432593918::Reserved,
            1 => AccDistanceAlertSignal2432593918::AccdasActive,
            0 => AccDistanceAlertSignal2432593918::AccdasNotActive,
            value => AccDistanceAlertSignal2432593918::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccSystemShutoffWarning2432593918 {
    TakeNoAction,
    Reserved,
    AccssowActive,
    AccssowNotActive,
    XValue(u64),
}

impl From<u64> for AccSystemShutoffWarning2432593918 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccSystemShutoffWarning2432593918::TakeNoAction,
            2 => AccSystemShutoffWarning2432593918::Reserved,
            1 => AccSystemShutoffWarning2432593918::AccssowActive,
            0 => AccSystemShutoffWarning2432593918::AccssowNotActive,
            value => AccSystemShutoffWarning2432593918::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AccTargetDetected2432593918 {
    TakeNoAction,
    Reserved,
    TargetDetected,
    NoTargetsDetected,
    XValue(u64),
}

impl From<u64> for AccTargetDetected2432593918 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => AccTargetDetected2432593918::TakeNoAction,
            2 => AccTargetDetected2432593918::Reserved,
            1 => AccTargetDetected2432593918::TargetDetected,
            0 => AccTargetDetected2432593918::NoTargetsDetected,
            value => AccTargetDetected2432593918::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AdptveCruiseCtrlSetDistanceMode2432593918 {
    NotAvailableNotValid,
    ErrorCondition,
    ConventionalCruiseCtrlMode,
    AccDistanceMode5,
    AccDistanceMode4,
    AccDistanceMode3,
    AccDistanceMode2,
    AccDistanceMode1,
    XValue(u64),
}

impl From<u64> for AdptveCruiseCtrlSetDistanceMode2432593918 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => AdptveCruiseCtrlSetDistanceMode2432593918::NotAvailableNotValid,
            6 => AdptveCruiseCtrlSetDistanceMode2432593918::ErrorCondition,
            5 => AdptveCruiseCtrlSetDistanceMode2432593918::ConventionalCruiseCtrlMode,
            4 => AdptveCruiseCtrlSetDistanceMode2432593918::AccDistanceMode5,
            3 => AdptveCruiseCtrlSetDistanceMode2432593918::AccDistanceMode4,
            2 => AdptveCruiseCtrlSetDistanceMode2432593918::AccDistanceMode3,
            1 => AdptveCruiseCtrlSetDistanceMode2432593918::AccDistanceMode2,
            0 => AdptveCruiseCtrlSetDistanceMode2432593918::AccDistanceMode1,
            value => AdptveCruiseCtrlSetDistanceMode2432593918::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum AdaptiveCruiseCtrlMode2432593918 {
    NotAvailableNotValid,
    DsbldErrrCndtnUsdTIndctThtAccIs,
    FinishMode,
    HldMdUsdTIndctThtAccHsLstThPrvs,
    OvertakeMode,
    DstncCtrlActvUsdTIndctThtAccIsO,
    SpeedCtrlActive,
    OffUsdTIndctAccIsEnbldInClbCnfg,
    XValue(u64),
}

impl From<u64> for AdaptiveCruiseCtrlMode2432593918 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => AdaptiveCruiseCtrlMode2432593918::NotAvailableNotValid,
            6 => AdaptiveCruiseCtrlMode2432593918::DsbldErrrCndtnUsdTIndctThtAccIs,
            5 => AdaptiveCruiseCtrlMode2432593918::FinishMode,
            4 => AdaptiveCruiseCtrlMode2432593918::HldMdUsdTIndctThtAccHsLstThPrvs,
            3 => AdaptiveCruiseCtrlMode2432593918::OvertakeMode,
            2 => AdaptiveCruiseCtrlMode2432593918::DstncCtrlActvUsdTIndctThtAccIsO,
            1 => AdaptiveCruiseCtrlMode2432593918::SpeedCtrlActive,
            0 => AdaptiveCruiseCtrlMode2432593918::OffUsdTIndctAccIsEnbldInClbCnfg,
            value => AdaptiveCruiseCtrlMode2432593918::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum ControlByte2565406462 {
    CannotRespond,
    AccessDenied,
    Nack,
    Ack,
    XValue(u64),
}

impl From<u64> for ControlByte2565406462 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => ControlByte2565406462::CannotRespond,
            2 => ControlByte2565406462::AccessDenied,
            1 => ControlByte2565406462::Nack,
            0 => ControlByte2565406462::Ack,
            value => ControlByte2565406462::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Status2OfDoors2566803198 {
    NotAvailable,
    Error,
    AtLeast1BusDoorEnabled,
    AllBusDoorsAreDisabled,
    XValue(u64),
}

impl From<u64> for Status2OfDoors2566803198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => Status2OfDoors2566803198::NotAvailable,
            2 => Status2OfDoors2566803198::Error,
            1 => Status2OfDoors2566803198::AtLeast1BusDoorEnabled,
            0 => Status2OfDoors2566803198::AllBusDoorsAreDisabled,
            value => Status2OfDoors2566803198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RampWheelChairLiftPos2566803198 {
    NotAvailable,
    Error,
    OutsideBus,
    InsideBus,
    XValue(u64),
}

impl From<u64> for RampWheelChairLiftPos2566803198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => RampWheelChairLiftPos2566803198::NotAvailable,
            2 => RampWheelChairLiftPos2566803198::Error,
            1 => RampWheelChairLiftPos2566803198::OutsideBus,
            0 => RampWheelChairLiftPos2566803198::InsideBus,
            value => RampWheelChairLiftPos2566803198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PosOfDoors2566803198 {
    NotAvailable,
    Error,
    X1101notDefined,
    AllDoorsClosed,
    ClosingLastDoor,
    AtLeast1DoorIsOpen,
    XValue(u64),
}

impl From<u64> for PosOfDoors2566803198 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => PosOfDoors2566803198::NotAvailable,
            14 => PosOfDoors2566803198::Error,
            3 => PosOfDoors2566803198::X1101notDefined,
            2 => PosOfDoors2566803198::AllDoorsClosed,
            1 => PosOfDoors2566803198::ClosingLastDoor,
            0 => PosOfDoors2566803198::AtLeast1DoorIsOpen,
            value => PosOfDoors2566803198::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FifthWheelRollWarningIndicator2565870334 {
    NotAvailable,
    Error,
    LimitExceeded,
    LimitNotExceeded,
    XValue(u64),
}

impl From<u64> for FifthWheelRollWarningIndicator2565870334 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FifthWheelRollWarningIndicator2565870334::NotAvailable,
            2 => FifthWheelRollWarningIndicator2565870334::Error,
            1 => FifthWheelRollWarningIndicator2565870334::LimitExceeded,
            0 => FifthWheelRollWarningIndicator2565870334::LimitNotExceeded,
            value => FifthWheelRollWarningIndicator2565870334::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FifthWheelSliderLockIndicator2566762238 {
    NotAvailable,
    Error,
    Locked,
    NotLocked,
    XValue(u64),
}

impl From<u64> for FifthWheelSliderLockIndicator2566762238 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FifthWheelSliderLockIndicator2566762238::NotAvailable,
            2 => FifthWheelSliderLockIndicator2566762238::Error,
            1 => FifthWheelSliderLockIndicator2566762238::Locked,
            0 => FifthWheelSliderLockIndicator2566762238::NotLocked,
            value => FifthWheelSliderLockIndicator2566762238::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FfthWhlLckCoupleStatusIndicator2566762238 {
    NotAvailable,
    Error,
    SuccessfulCoupleDetected,
    IncmpltBdCplTrckShuldNotBeMoved,
    XValue(u64),
}

impl From<u64> for FfthWhlLckCoupleStatusIndicator2566762238 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FfthWhlLckCoupleStatusIndicator2566762238::NotAvailable,
            2 => FfthWhlLckCoupleStatusIndicator2566762238::Error,
            1 => FfthWhlLckCoupleStatusIndicator2566762238::SuccessfulCoupleDetected,
            0 => FfthWhlLckCoupleStatusIndicator2566762238::IncmpltBdCplTrckShuldNotBeMoved,
            value => FfthWhlLckCoupleStatusIndicator2566762238::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FfthWhlLckRadyToCoupleIndicator2566762238 {
    NotAvailable,
    Error,
    LockOpenReadyToCouple,
    LockNotOpenNotReadyToCouple,
    XValue(u64),
}

impl From<u64> for FfthWhlLckRadyToCoupleIndicator2566762238 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => FfthWhlLckRadyToCoupleIndicator2566762238::NotAvailable,
            2 => FfthWhlLckRadyToCoupleIndicator2566762238::Error,
            1 => FfthWhlLckRadyToCoupleIndicator2566762238::LockOpenReadyToCouple,
            0 => FfthWhlLckRadyToCoupleIndicator2566762238::LockNotOpenNotReadyToCouple,
            value => FfthWhlLckRadyToCoupleIndicator2566762238::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum FifthWheelErrorStatus2566762238 {
    NotAvailable,
    KingpinLockOpen,
    KingpinMissingMoreThan5Seconds,
    CouplingTimingError,
    CouplingSequenceErrorKingpin,
    CouplingSequenceError,
    NotUsed,
    KingpinLocksOpenAtStartup,
    LocksClosedNoKingpinAtStartup,
    ImproperCouple,
    XValue(u64),
}

impl From<u64> for FifthWheelErrorStatus2566762238 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => FifthWheelErrorStatus2566762238::NotAvailable,
            9 => FifthWheelErrorStatus2566762238::KingpinLockOpen,
            8 => FifthWheelErrorStatus2566762238::KingpinMissingMoreThan5Seconds,
            7 => FifthWheelErrorStatus2566762238::CouplingTimingError,
            6 => FifthWheelErrorStatus2566762238::CouplingSequenceErrorKingpin,
            5 => FifthWheelErrorStatus2566762238::CouplingSequenceError,
            14 => FifthWheelErrorStatus2566762238::NotUsed,
            2 => FifthWheelErrorStatus2566762238::KingpinLocksOpenAtStartup,
            1 => FifthWheelErrorStatus2566762238::LocksClosedNoKingpinAtStartup,
            0 => FifthWheelErrorStatus2566762238::ImproperCouple,
            value => FifthWheelErrorStatus2566762238::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PitchAndRollCompensated2364543998 {
    NotAvailable,
    CompensationOn,
    XValue(u64),
}

impl From<u64> for PitchAndRollCompensated2364543998 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => PitchAndRollCompensated2364543998::NotAvailable,
            0 => PitchAndRollCompensated2364543998::CompensationOn,
            value => PitchAndRollCompensated2364543998::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PitchRateFigureOfMerit2364543998 {
    NotAvailable,
    PtchRtDgrddDtIsSspctDtEnvrnmntl,
    XValue(u64),
}

impl From<u64> for PitchRateFigureOfMerit2364543998 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => PitchRateFigureOfMerit2364543998::NotAvailable,
            0 => PitchRateFigureOfMerit2364543998::PtchRtDgrddDtIsSspctDtEnvrnmntl,
            value => PitchRateFigureOfMerit2364543998::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum RollAngleFigureOfMerit2364543998 {
    NotAvailable,
    RllAnglDgrddDtIsSspctDtEnvrnmnt,
    XValue(u64),
}

impl From<u64> for RollAngleFigureOfMerit2364543998 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => RollAngleFigureOfMerit2364543998::NotAvailable,
            0 => RollAngleFigureOfMerit2364543998::RllAnglDgrddDtIsSspctDtEnvrnmnt,
            value => RollAngleFigureOfMerit2364543998::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum PitchAngleFigureOfMerit2364543998 {
    NotAvailable,
    PtchAnglDgrddDtIsSspctDtEnvrnmn,
    XValue(u64),
}

impl From<u64> for PitchAngleFigureOfMerit2364543998 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => PitchAngleFigureOfMerit2364543998::NotAvailable,
            0 => PitchAngleFigureOfMerit2364543998::PtchAnglDgrddDtIsSspctDtEnvrnmn,
            value => PitchAngleFigureOfMerit2364543998::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransOilLevelMeasurementStatus2566846718 {
    NotAvailable,
    Error,
    ConditionsNotValidOther,
    NotDefined,
    CndtionsNotValidEngSpeedTooHigh,
    CnditionsNotValidEngSpeedTooLow,
    CndtionsNotValidVehicleNotLevel,
    CndtnsNtVldVhclMvngOtptShftSpdT,
    CndtnsNtVldTrnsFluidTempTooHigh,
    CndtnsNtVldTransFluidTempTooLow,
    ConditionsNotValidTransInGear,
    CndtnsNtVldSttlngTmrStllCntngDw,
    CndtnsVldFrTrnsOlLvlMeasurement,
    XValue(u64),
}

impl From<u64> for TransOilLevelMeasurementStatus2566846718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TransOilLevelMeasurementStatus2566846718::NotAvailable,
            14 => TransOilLevelMeasurementStatus2566846718::Error,
            13 => TransOilLevelMeasurementStatus2566846718::ConditionsNotValidOther,
            12 => TransOilLevelMeasurementStatus2566846718::NotDefined,
            8 => TransOilLevelMeasurementStatus2566846718::CndtionsNotValidEngSpeedTooHigh,
            7 => TransOilLevelMeasurementStatus2566846718::CnditionsNotValidEngSpeedTooLow,
            6 => TransOilLevelMeasurementStatus2566846718::CndtionsNotValidVehicleNotLevel,
            5 => TransOilLevelMeasurementStatus2566846718::CndtnsNtVldVhclMvngOtptShftSpdT,
            4 => TransOilLevelMeasurementStatus2566846718::CndtnsNtVldTrnsFluidTempTooHigh,
            3 => TransOilLevelMeasurementStatus2566846718::CndtnsNtVldTransFluidTempTooLow,
            2 => TransOilLevelMeasurementStatus2566846718::ConditionsNotValidTransInGear,
            1 => TransOilLevelMeasurementStatus2566846718::CndtnsNtVldSttlngTmrStllCntngDw,
            0 => TransOilLevelMeasurementStatus2566846718::CndtnsVldFrTrnsOlLvlMeasurement,
            value => TransOilLevelMeasurementStatus2566846718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum TransOilLevelCountdownTimer2566846718 {
    NotAvailable,
    Error,
    ThirteenMinutes,
    TwelveMinutes,
    ElevenMinutes,
    TenMinutes,
    NineMinutes,
    EightMinutes,
    SevenMinutes,
    SixMinutes,
    FiveMinutes,
    FourMinutes,
    ThreeMinutes,
    TwoMinutes,
    OneMinute,
    LessThan1Minute,
    XValue(u64),
}

impl From<u64> for TransOilLevelCountdownTimer2566846718 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            15 => TransOilLevelCountdownTimer2566846718::NotAvailable,
            14 => TransOilLevelCountdownTimer2566846718::Error,
            13 => TransOilLevelCountdownTimer2566846718::ThirteenMinutes,
            12 => TransOilLevelCountdownTimer2566846718::TwelveMinutes,
            11 => TransOilLevelCountdownTimer2566846718::ElevenMinutes,
            10 => TransOilLevelCountdownTimer2566846718::TenMinutes,
            9 => TransOilLevelCountdownTimer2566846718::NineMinutes,
            8 => TransOilLevelCountdownTimer2566846718::EightMinutes,
            7 => TransOilLevelCountdownTimer2566846718::SevenMinutes,
            6 => TransOilLevelCountdownTimer2566846718::SixMinutes,
            5 => TransOilLevelCountdownTimer2566846718::FiveMinutes,
            4 => TransOilLevelCountdownTimer2566846718::FourMinutes,
            3 => TransOilLevelCountdownTimer2566846718::ThreeMinutes,
            2 => TransOilLevelCountdownTimer2566846718::TwoMinutes,
            1 => TransOilLevelCountdownTimer2566846718::OneMinute,
            0 => TransOilLevelCountdownTimer2566846718::LessThan1Minute,
            value => TransOilLevelCountdownTimer2566846718::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum WrlessCommunicationNetworkType22566760702 {
    SatelliteNetwork,
    WirelessLan2,
    WirelessLan1,
    CellularNetwork2,
    CellularNetwork1,
    XValue(u64),
}

impl From<u64> for WrlessCommunicationNetworkType22566760702 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => WrlessCommunicationNetworkType22566760702::SatelliteNetwork,
            3 => WrlessCommunicationNetworkType22566760702::WirelessLan2,
            2 => WrlessCommunicationNetworkType22566760702::WirelessLan1,
            1 => WrlessCommunicationNetworkType22566760702::CellularNetwork2,
            0 => WrlessCommunicationNetworkType22566760702::CellularNetwork1,
            value => WrlessCommunicationNetworkType22566760702::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NetworkAntennaStatus22566760702 {
    On,
    Off,
    XValue(u64),
}

impl From<u64> for NetworkAntennaStatus22566760702 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => NetworkAntennaStatus22566760702::On,
            0 => NetworkAntennaStatus22566760702::Off,
            value => NetworkAntennaStatus22566760702::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NetworkServiceStatus22566760702 {
    RoamingService,
    LocalService,
    XValue(u64),
}

impl From<u64> for NetworkServiceStatus22566760702 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => NetworkServiceStatus22566760702::RoamingService,
            0 => NetworkServiceStatus22566760702::LocalService,
            value => NetworkServiceStatus22566760702::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NetworkTransceiverStatus22566760702 {
    On,
    Off,
    XValue(u64),
}

impl From<u64> for NetworkTransceiverStatus22566760702 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => NetworkTransceiverStatus22566760702::On,
            0 => NetworkTransceiverStatus22566760702::Off,
            value => NetworkTransceiverStatus22566760702::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum WrlessCommunicationNetworkType12566760958 {
    SatelliteNetwork,
    CellularNetwork2,
    CellularNetwork1,
    WirelessLan2,
    WirelessLan1,
    XValue(u64),
}

impl From<u64> for WrlessCommunicationNetworkType12566760958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            4 => WrlessCommunicationNetworkType12566760958::SatelliteNetwork,
            1 => WrlessCommunicationNetworkType12566760958::CellularNetwork2,
            0 => WrlessCommunicationNetworkType12566760958::CellularNetwork1,
            3 => WrlessCommunicationNetworkType12566760958::WirelessLan2,
            2 => WrlessCommunicationNetworkType12566760958::WirelessLan1,
            value => WrlessCommunicationNetworkType12566760958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NetworkAntennaStatus12566760958 {
    On,
    Off,
    XValue(u64),
}

impl From<u64> for NetworkAntennaStatus12566760958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => NetworkAntennaStatus12566760958::On,
            0 => NetworkAntennaStatus12566760958::Off,
            value => NetworkAntennaStatus12566760958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NetworkServiceStatus12566760958 {
    RoamingService,
    LocalService,
    XValue(u64),
}

impl From<u64> for NetworkServiceStatus12566760958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => NetworkServiceStatus12566760958::RoamingService,
            0 => NetworkServiceStatus12566760958::LocalService,
            value => NetworkServiceStatus12566760958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum NetworkTransceiverStatus12566760958 {
    On,
    Off,
    XValue(u64),
}

impl From<u64> for NetworkTransceiverStatus12566760958 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            1 => NetworkTransceiverStatus12566760958::On,
            0 => NetworkTransceiverStatus12566760958::Off,
            value => NetworkTransceiverStatus12566760958::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VoltageRegulatorEnabled2633869310 {
    NotAvailable,
    Error,
    RegulatingVoltage,
    NtRegulatingVoltageUnitDisabled,
    XValue(u64),
}

impl From<u64> for VoltageRegulatorEnabled2633869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VoltageRegulatorEnabled2633869310::NotAvailable,
            2 => VoltageRegulatorEnabled2633869310::Error,
            1 => VoltageRegulatorEnabled2633869310::RegulatingVoltage,
            0 => VoltageRegulatorEnabled2633869310::NtRegulatingVoltageUnitDisabled,
            value => VoltageRegulatorEnabled2633869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VoltageRegulatorSoftStartState2633869310 {
    NotAvailable,
    Error,
    SoftStartIsActive,
    SoftStartIsInactive,
    XValue(u64),
}

impl From<u64> for VoltageRegulatorSoftStartState2633869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VoltageRegulatorSoftStartState2633869310::NotAvailable,
            2 => VoltageRegulatorSoftStartState2633869310::Error,
            1 => VoltageRegulatorSoftStartState2633869310::SoftStartIsActive,
            0 => VoltageRegulatorSoftStartState2633869310::SoftStartIsInactive,
            value => VoltageRegulatorSoftStartState2633869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VltgRgltrUndrfrqncyCmpnstnEnbld2633869310 {
    NotAvailable,
    Error,
    UndrfrquencyCompensationEnabled,
    UndrfrqencyCompensationDisabled,
    XValue(u64),
}

impl From<u64> for VltgRgltrUndrfrqncyCmpnstnEnbld2633869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            3 => VltgRgltrUndrfrqncyCmpnstnEnbld2633869310::NotAvailable,
            2 => VltgRgltrUndrfrqncyCmpnstnEnbld2633869310::Error,
            1 => VltgRgltrUndrfrqncyCmpnstnEnbld2633869310::UndrfrquencyCompensationEnabled,
            0 => VltgRgltrUndrfrqncyCmpnstnEnbld2633869310::UndrfrqencyCompensationDisabled,
            value => VltgRgltrUndrfrqncyCmpnstnEnbld2633869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VltgRgltrVArPwrFctrOprtingMode2633869310 {
    NotAvailable,
    Error,
    Reserved,
    VArRegulationEnabled,
    PowerFactorRegulationEnabled,
    VArPwrFactorRegulationDisabled,
    XValue(u64),
}

impl From<u64> for VltgRgltrVArPwrFctrOprtingMode2633869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => VltgRgltrVArPwrFctrOprtingMode2633869310::NotAvailable,
            6 => VltgRgltrVArPwrFctrOprtingMode2633869310::Error,
            5 => VltgRgltrVArPwrFctrOprtingMode2633869310::Reserved,
            2 => VltgRgltrVArPwrFctrOprtingMode2633869310::VArRegulationEnabled,
            1 => VltgRgltrVArPwrFctrOprtingMode2633869310::PowerFactorRegulationEnabled,
            0 => VltgRgltrVArPwrFctrOprtingMode2633869310::VArPwrFactorRegulationDisabled,
            value => VltgRgltrVArPwrFctrOprtingMode2633869310::XValue(value),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum VltgRglatorLoadCompensationMode2633869310 {
    NotAvailable,
    Error,
    Reserved,
    IrLineDropCompensationEnabled,
    VoltageDroopCompensationEnabled,
    LoadCompensationDisabled,
    XValue(u64),
}

impl From<u64> for VltgRglatorLoadCompensationMode2633869310 {
    #[allow(dead_code)]
    fn from(val: u64) -> Self {
        match val {
            7 => VltgRglatorLoadCompensationMode2633869310::NotAvailable,
            6 => VltgRglatorLoadCompensationMode2633869310::Error,
            5 => VltgRglatorLoadCompensationMode2633869310::Reserved,
            2 => VltgRglatorLoadCompensationMode2633869310::IrLineDropCompensationEnabled,
            1 => VltgRglatorLoadCompensationMode2633869310::VoltageDroopCompensationEnabled,
            0 => VltgRglatorLoadCompensationMode2633869310::LoadCompensationDisabled,
            value => VltgRglatorLoadCompensationMode2633869310::XValue(value),
        }
    }
}

/// Text Display
#[allow(dead_code)]
#[derive(Debug)]
pub struct Disp1 {
    frame_payload: Vec<u8>,
}

impl Disp1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Disp1 {
        frame_payload.resize(8, 0);
        Disp1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Disp1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(413728510);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Disp1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TextDisplayIndex signal from can frame
    #[allow(dead_code)]
    pub fn text_display_index_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// This parameter describes the status for the display how to show the information.
    #[allow(dead_code)]
    pub fn text_display_instructions_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn text_display_instructions(&self) -> TextDisplayInstructions2561212158 {
        TextDisplayInstructions2561212158::from(self.text_display_instructions_raw_value() as u64)
    }
}

/// Door ramp control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Drc {
    frame_payload: Vec<u8>,
}

impl Drc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Drc {
        frame_payload.resize(8, 0);
        Drc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Drc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419262718);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Drc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read MovementStatusOfRamp3 signal from can frame
    #[allow(dead_code)]
    pub fn movement_status_of_ramp3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn movement_status_of_ramp3(&self) -> MovementStatusOfRamp32566746366 {
        MovementStatusOfRamp32566746366::from(self.movement_status_of_ramp3_raw_value() as u64)
    }

    /// Read EnableStatusOfRamp3 signal from can frame
    #[allow(dead_code)]
    pub fn enable_status_of_ramp3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_ramp3(&self) -> EnableStatusOfRamp32566746366 {
        EnableStatusOfRamp32566746366::from(self.enable_status_of_ramp3_raw_value() as u64)
    }

    /// Read RetractStatusOfRamp3 signal from can frame
    #[allow(dead_code)]
    pub fn retract_status_of_ramp3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn retract_status_of_ramp3(&self) -> RetractStatusOfRamp32566746366 {
        RetractStatusOfRamp32566746366::from(self.retract_status_of_ramp3_raw_value() as u64)
    }

    /// Read MovementStatusOfRamp2 signal from can frame
    #[allow(dead_code)]
    pub fn movement_status_of_ramp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn movement_status_of_ramp2(&self) -> MovementStatusOfRamp22566746366 {
        MovementStatusOfRamp22566746366::from(self.movement_status_of_ramp2_raw_value() as u64)
    }

    /// Read EnableStatusOfRamp2 signal from can frame
    #[allow(dead_code)]
    pub fn enable_status_of_ramp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_ramp2(&self) -> EnableStatusOfRamp22566746366 {
        EnableStatusOfRamp22566746366::from(self.enable_status_of_ramp2_raw_value() as u64)
    }

    /// Read RetractStatusOfRamp2 signal from can frame
    #[allow(dead_code)]
    pub fn retract_status_of_ramp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn retract_status_of_ramp2(&self) -> RetractStatusOfRamp22566746366 {
        RetractStatusOfRamp22566746366::from(self.retract_status_of_ramp2_raw_value() as u64)
    }

    /// Read MovementStatusOfRamp1 signal from can frame
    #[allow(dead_code)]
    pub fn movement_status_of_ramp1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn movement_status_of_ramp1(&self) -> MovementStatusOfRamp12566746366 {
        MovementStatusOfRamp12566746366::from(self.movement_status_of_ramp1_raw_value() as u64)
    }

    /// Read EnableStatusOfRamp1 signal from can frame
    #[allow(dead_code)]
    pub fn enable_status_of_ramp1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_ramp1(&self) -> EnableStatusOfRamp12566746366 {
        EnableStatusOfRamp12566746366::from(self.enable_status_of_ramp1_raw_value() as u64)
    }

    /// Read RetractStatusOfRamp1 signal from can frame
    #[allow(dead_code)]
    pub fn retract_status_of_ramp1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn retract_status_of_ramp1(&self) -> RetractStatusOfRamp12566746366 {
        RetractStatusOfRamp12566746366::from(self.retract_status_of_ramp1_raw_value() as u64)
    }
}

/// Engine Configuration 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ec2 {
    frame_payload: Vec<u8>,
}

impl Ec2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ec2 {
        frame_payload.resize(8, 0);
        Ec2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ec2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419266558);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ec2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The number of cranking cycles that will be performed before ending the start attempt.
    #[allow(dead_code)]
    pub fn max_crank_attempts_per_start_attempt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Electronic Engine Controller 7
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec7 {
    frame_payload: Vec<u8>,
}

impl Eec7 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec7 {
        frame_payload.resize(8, 0);
        Eec7 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec7, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419271934);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec7::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The position of the second exhaust gas recirculation valve expressed as a percentage of full travel.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_exhst_gs_rcirculation_valve2_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// The position of the exhaust gas recirculation valve expressed as a percentage of full travel.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_exhst_gs_recirculation_valve_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.002500).round() as u16
    }
}

/// Electronic Engine Controller 8
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec8 {
    frame_payload: Vec<u8>,
}

impl Eec8 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec8 {
        frame_payload.resize(8, 0);
        Eec8 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec8, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419262462);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec8::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Desired percentage of maximum Exhaust Gas Recirculation (EGR) valve opening for valve 2.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_exhst_gs_rcrculation_valve2_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.002500).round() as u16
    }
}

/// Engine Fluid Level/Pressure 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP5 {
    frame_payload: Vec<u8>,
}

impl EflP5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP5 {
        frame_payload.resize(8, 0);
        EflP5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419268862);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #4.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #3.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Engine Fluid Level/Pressure 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP6 {
    frame_payload: Vec<u8>,
}

impl EflP6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP6 {
        frame_payload.resize(8, 0);
        EflP6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419268606);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #8.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl8_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #7.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl7_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #6.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl6_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #5.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Engine Fluid Level/Pressure 7
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP7 {
    frame_payload: Vec<u8>,
}

impl EflP7 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP7 {
        frame_payload.resize(8, 0);
        EflP7 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP7, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419268350);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP7::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #12.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl12_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #11.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl11_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #10.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl10_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #9.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actton_oil_press_for_cyl9_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Engine Fluid Level/Pressure 8
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP8 {
    frame_payload: Vec<u8>,
}

impl EflP8 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP8 {
        frame_payload.resize(8, 0);
        EflP8 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP8, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419268094);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP8::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #16.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl16_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #15.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl15_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #14.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl14_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #13.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl13_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Engine Fluid Level/Pressure 9
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP9 {
    frame_payload: Vec<u8>,
}

impl EflP9 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP9 {
        frame_payload.resize(8, 0);
        EflP9 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP9, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419267838);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP9::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #20.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl20_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #19.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl19_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #18.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl18_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The gage pressure of the oil in the hydraulic accumulator that powers the engine intake valve for cylinder #17.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttn_oil_press_for_cyl17_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// EGR Cooler Bypass
#[allow(dead_code)]
#[derive(Debug)]
pub struct Egrbv {
    frame_payload: Vec<u8>,
}

impl Egrbv {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Egrbv {
        frame_payload.resize(8, 0);
        Egrbv { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Egrbv, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(352158206);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Egrbv::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EGRCoolerBypassActuatorPostion signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn egr_cooler_bypass_actuator_postion_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Engine Spark Voltage 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esv1 {
    frame_payload: Vec<u8>,
}

impl Esv1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esv1 {
        frame_payload.resize(8, 0);
        Esv1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esv1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419264510);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esv1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngSparkPlug4 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug3 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug2 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug1 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Engine Spark Voltage 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esv2 {
    frame_payload: Vec<u8>,
}

impl Esv2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esv2 {
        frame_payload.resize(8, 0);
        Esv2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esv2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419264254);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esv2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngSparkPlug8 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug8_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug7 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug7_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug6 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug6_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug5 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Engine Spark Voltage 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esv3 {
    frame_payload: Vec<u8>,
}

impl Esv3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esv3 {
        frame_payload.resize(8, 0);
        Esv3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esv3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419263998);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esv3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngSparkPlug12 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug12_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug11 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug11_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug10 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug10_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug9 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug9_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Engine Spark Voltage 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esv4 {
    frame_payload: Vec<u8>,
}

impl Esv4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esv4 {
        frame_payload.resize(8, 0);
        Esv4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esv4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419263742);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esv4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngSparkPlug16 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug16_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug15 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug15_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug14 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug14_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug13 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug13_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Engine Spark Voltage 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esv5 {
    frame_payload: Vec<u8>,
}

impl Esv5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esv5 {
        frame_payload.resize(8, 0);
        Esv5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esv5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419263486);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esv5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngSparkPlug20 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug20_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug19 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug19_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug18 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug18_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug17 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug17_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Engine Spark Voltage 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esv6 {
    frame_payload: Vec<u8>,
}

impl Esv6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esv6 {
        frame_payload.resize(8, 0);
        Esv6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esv6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419263230);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esv6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngSparkPlug24 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug24_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug23 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug23_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug22 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug22_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read EngSparkPlug21 signal from can frame
    /// Unit: Volts
    #[allow(dead_code)]
    pub fn eng_spark_plug21_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Forward Lane Image Command
#[allow(dead_code)]
#[derive(Debug)]
pub struct Flic {
    frame_payload: Vec<u8>,
}

impl Flic {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Flic {
        frame_payload.resize(8, 0);
        Flic { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Flic, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(413794046);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Flic::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read LaneDepartureWarningEnableCmd signal from can frame
    #[allow(dead_code)]
    pub fn lane_departure_warning_enable_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lane_departure_warning_enable_cmd(&self) -> LaneDepartureWarningEnableCmd2561277694 {
        LaneDepartureWarningEnableCmd2561277694::from(self.lane_departure_warning_enable_cmd_raw_value() as u64)
    }
}

/// SAE J2012 DTC Display
#[allow(dead_code)]
#[derive(Debug)]
pub struct J2012 {
    frame_payload: Vec<u8>,
}

impl J2012 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> J2012 {
        frame_payload.resize(8, 0);
        J2012 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<J2012, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486378238);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| J2012::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Number of occurrences of the respective SAE J2012 DTC being conveyed.
    #[allow(dead_code)]
    pub fn j2012dtc_occurrence_count_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x7F)) as u8
    }

    /// Indicates if the respective SAE J2012 DTC is active or previously active.
    #[allow(dead_code)]
    pub fn j2012dtc_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn j2012dtc_status(&self) -> J2012dtcStatus2633861886 {
        J2012dtcStatus2633861886::from(self.j2012dtc_status_raw_value() as u64)
    }

    /// The number J2012 DTCs being conveyed in PGN 64906.
    #[allow(dead_code)]
    pub fn number_of_j2012dt_cs_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Particulate Trap Control 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ptc1 {
    frame_payload: Vec<u8>,
}

impl Ptc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ptc1 {
        frame_payload.resize(8, 0);
        Ptc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ptc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419265790);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ptc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read PrtcltTrpActvRgnrtnInhbtdDTVhclS signal from can frame
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_vhcl_s_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_vhcl_s(&self) -> PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtVhclS2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dt_vhcl_s_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition due to the transmission being out of neutral.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_ot_of_n_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_ot_of_n(&self) -> PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtOtOfN2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dt_ot_of_n_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition due to the accelerator pedal being off idle.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_accl_p_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_accl_p(&self) -> PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtAcclP2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dt_accl_p_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition due to the PTO being active.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dtpto_ac_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dtpto_ac(&self) -> PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtptoAc2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dtpto_ac_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition due to the service brake being active.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_srvc_b_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_srvc_b(&self) -> PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtSrvcB2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dt_srvc_b_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition due to the clutch being disengaged.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_cltch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_cltch(&self) -> PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtCltch2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dt_cltch_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition due to the Particulate Trap Regeneration Inhibit Switch.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_inhbt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_dt_inhbt(&self) -> PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438 {
        PrtcltTrpActvRgnrtnInhbtdDtInhbt2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_dt_inhbt_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration inhibition.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_rgnrtn_inhbtd_status(&self) -> PrtcltTrpActvRgnrtnInhbtdStatus2566749438 {
        PrtcltTrpActvRgnrtnInhbtdStatus2566749438::from(self.prtclt_trp_actv_rgnrtn_inhbtd_status_raw_value() as u64)
    }

    /// Indicates the state of the particulate trap regeneration need and urgency.
    #[allow(dead_code)]
    pub fn particulate_trap_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn particulate_trap_status(&self) -> ParticulateTrapStatus2566749438 {
        ParticulateTrapStatus2566749438::from(self.particulate_trap_status_raw_value() as u64)
    }

    /// Indicates the state of particulate trap active regeneration.
    #[allow(dead_code)]
    pub fn prtclt_trp_actv_regeneration_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_actv_regeneration_status(&self) -> PrtcltTrpActvRegenerationStatus2566749438 {
        PrtcltTrpActvRegenerationStatus2566749438::from(self.prtclt_trp_actv_regeneration_status_raw_value() as u64)
    }

    /// Indicates the state of particulate trap passive regeneration.
    #[allow(dead_code)]
    pub fn prtclt_trp_pssv_regeneration_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prtclt_trp_pssv_regeneration_status(&self) -> PrtcltTrpPssvRegenerationStatus2566749438 {
        PrtcltTrpPssvRegenerationStatus2566749438::from(self.prtclt_trp_pssv_regeneration_status_raw_value() as u64)
    }

    /// Command to control the particulate trap lamp.
    #[allow(dead_code)]
    pub fn particulate_trap_lamp_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn particulate_trap_lamp_cmd(&self) -> ParticulateTrapLampCmd2566749438 {
        ParticulateTrapLampCmd2566749438::from(self.particulate_trap_lamp_cmd_raw_value() as u64)
    }
}

/// Steering Angle Sensor Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Sas {
    frame_payload: Vec<u8>,
}

impl Sas {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Sas {
        frame_payload.resize(8, 0);
        Sas { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Sas, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418389502);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Sas::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The message checksum is used to verify the signal path from the demanding device to the steering controller .
    #[allow(dead_code)]
    pub fn message_checksum_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0xF)) as u8
    }

    /// The message counter is to verify the signal path from the demanding device to the steering controller.
    #[allow(dead_code)]
    pub fn message_counter_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    /// This signal indicates the calibration status of the steering angle sensor.
    #[allow(dead_code)]
    pub fn steer_angle_sensor_calibrated_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn steer_angle_sensor_calibrated(&self) -> SteerAngleSensorCalibrated2565873150 {
        SteerAngleSensorCalibrated2565873150::from(self.steer_angle_sensor_calibrated_raw_value() as u64)
    }

    /// This signal indicates the operational mode of the steering angle sensor.
    #[allow(dead_code)]
    pub fn steer_angle_sensor_active_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn steer_angle_sensor_active_mode(&self) -> SteerAngleSensorActiveMode2565873150 {
        SteerAngleSensorActiveMode2565873150::from(self.steer_angle_sensor_active_mode_raw_value() as u64)
    }

    /// The signal indicates the range of the steering wheel angle the sensor element is capable to measure.
    /// Unit: rad
    #[allow(dead_code)]
    pub fn steer_wheel_angle_range_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.000977).round() as u16
    }

    /// Read SteerWheelAngleRangeCounterType signal from can frame
    #[allow(dead_code)]
    pub fn steer_wheel_angle_range_counter_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn steer_wheel_angle_range_counter_type(&self) -> SteerWheelAngleRangeCounterType2565873150 {
        SteerWheelAngleRangeCounterType2565873150::from(self.steer_wheel_angle_range_counter_type_raw_value() as u64)
    }

    /// Read SteerWheelAngleRangeCounter signal from can frame
    /// Unit: ranges
    #[allow(dead_code)]
    pub fn steer_wheel_angle_range_counter_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3F)) as u8
    }

    /// The main operator`s steering wheel angle (on the steering column, not the actual wheel angle).
    /// Unit: rad
    #[allow(dead_code)]
    pub fn steer_wheel_angle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.000977).round() as u16
    }
}

/// Catalyst Use Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Scr1 {
    frame_payload: Vec<u8>,
}

impl Scr1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Scr1 {
        frame_payload.resize(8, 0);
        Scr1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Scr1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419262206);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Scr1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read CmdedCatalystReagentConsumption signal from can frame
    /// Unit: L/h
    #[allow(dead_code)]
    pub fn cmded_catalyst_reagent_consumption_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read AvrgeCatalystReagentConsumption signal from can frame
    /// Unit: L/h
    #[allow(dead_code)]
    pub fn avrge_catalyst_reagent_consumption_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Transfer Case Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci {
    frame_payload: Vec<u8>,
}

impl Tci {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci {
        frame_payload.resize(8, 0);
        Tci { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419267582);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter describes the feedback from the transfer case controller .
    #[allow(dead_code)]
    pub fn transfer_case_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn transfer_case_status(&self) -> TransferCaseStatus2566751230 {
        TransferCaseStatus2566751230::from(self.transfer_case_status_raw_value() as u64)
    }
}

/// Transmission Fluids 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Trf2 {
    frame_payload: Vec<u8>,
}

impl Trf2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Trf2 {
        frame_payload.resize(8, 0);
        Trf2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Trf2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419272190);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Trf2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This switch indicates whether transmission oil level is full or empty.
    #[allow(dead_code)]
    pub fn trans_oil_level_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_oil_level_switch(&self) -> TransOilLevelSwitch2566755838 {
        TransOilLevelSwitch2566755838::from(self.trans_oil_level_switch_raw_value() as u64)
    }

    /// This switch indicates whether the transmission oil filter is clogged.
    #[allow(dead_code)]
    pub fn trans_oil_filter_restriction_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_oil_filter_restriction_switch(&self) -> TransOilFilterRestrictionSwitch2566755838 {
        TransOilFilterRestrictionSwitch2566755838::from(self.trans_oil_filter_restriction_switch_raw_value() as u64)
    }
}

/// Vehicle Direction/Speed 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vds2 {
    frame_payload: Vec<u8>,
}

impl Vds2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vds2 {
        frame_payload.resize(8, 0);
        Vds2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vds2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419269118);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vds2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates the roll in degrees from level.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn vehicle_roll_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Engine Speed/Load Factor Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lf {
    frame_payload: Vec<u8>,
}

impl Lf {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lf {
        frame_payload.resize(8, 0);
        Lf { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lf, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486455294);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lf::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total time that the engine has operated in the cruise hold state, excluding time in accelerator override, over the life of the engine.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn total_eng_cruise_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Read TotalDriveAverageLoadFactor signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn total_drive_average_load_factor_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read TripDriveAverageLoadFactor signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn trip_drive_average_load_factor_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Average speed of the engine since the last trip reset.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn trip_average_eng_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Maximum engine speed achieved since the last trip reset.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn trip_max_eng_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.125000).round() as u16
    }
}

/// Lighting Data
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ld {
    frame_payload: Vec<u8>,
}

impl Ld {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ld {
        frame_payload.resize(8, 0);
        Ld { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ld, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419315966);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ld::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter provides measured data from the implement rear work lamps.
    #[allow(dead_code)]
    pub fn implement_rear_work_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_rear_work_light(&self) -> ImplementRearWorkLight2566799614 {
        ImplementRearWorkLight2566799614::from(self.implement_rear_work_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the forward facing work lights toward the left end of the implement.
    #[allow(dead_code)]
    pub fn implement_left_forward_work_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_left_forward_work_light(&self) -> ImplementLeftForwardWorkLight2566799614 {
        ImplementLeftForwardWorkLight2566799614::from(self.implement_left_forward_work_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the forward facing work lights toward the right end of the implement.
    #[allow(dead_code)]
    pub fn implement_right_forward_work_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_right_forward_work_light(&self) -> ImplementRightForwardWorkLight2566799614 {
        ImplementRightForwardWorkLight2566799614::from(self.implement_right_forward_work_light_raw_value() as u64)
    }

    /// Read ImplementLeftFacingWorkLight signal from can frame
    #[allow(dead_code)]
    pub fn implement_left_facing_work_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_left_facing_work_light(&self) -> ImplementLeftFacingWorkLight2566799614 {
        ImplementLeftFacingWorkLight2566799614::from(self.implement_left_facing_work_light_raw_value() as u64)
    }

    /// Read ImplementRightFacingWorkLight signal from can frame
    #[allow(dead_code)]
    pub fn implement_right_facing_work_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_right_facing_work_light(&self) -> ImplementRightFacingWorkLight2566799614 {
        ImplementRightFacingWorkLight2566799614::from(self.implement_right_facing_work_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the implement OEM option 1 light.
    #[allow(dead_code)]
    pub fn implement_oem_option1_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_oem_option1_light(&self) -> ImplementOemOption1Light2566799614 {
        ImplementOemOption1Light2566799614::from(self.implement_oem_option1_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the implement OEM option 2 light.
    #[allow(dead_code)]
    pub fn implement_oem_option2_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_oem_option2_light(&self) -> ImplementOemOption2Light2566799614 {
        ImplementOemOption2Light2566799614::from(self.implement_oem_option2_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor front high mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_front_high_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_front_high_mounted_work_lights(&self) -> TrctrFrontHighMountedWorkLights2566799614 {
        TrctrFrontHighMountedWorkLights2566799614::from(self.trctr_front_high_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor front low mounted work lights.
    #[allow(dead_code)]
    pub fn trctor_front_low_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctor_front_low_mounted_work_lights(&self) -> TrctorFrontLowMountedWorkLights2566799614 {
        TrctorFrontLowMountedWorkLights2566799614::from(self.trctor_front_low_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor side high mounted work lights.
    #[allow(dead_code)]
    pub fn trctor_side_high_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctor_side_high_mounted_work_lights(&self) -> TrctorSideHighMountedWorkLights2566799614 {
        TrctorSideHighMountedWorkLights2566799614::from(self.trctor_side_high_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor side low mounted work lights.
    #[allow(dead_code)]
    pub fn tractor_side_low_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_side_low_mounted_work_lights(&self) -> TractorSideLowMountedWorkLights2566799614 {
        TractorSideLowMountedWorkLights2566799614::from(self.tractor_side_low_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor rear high mounted work lights.
    #[allow(dead_code)]
    pub fn trctor_rear_high_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctor_rear_high_mounted_work_lights(&self) -> TrctorRearHighMountedWorkLights2566799614 {
        TrctorRearHighMountedWorkLights2566799614::from(self.trctor_rear_high_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor rear low mounted work lights.
    #[allow(dead_code)]
    pub fn tractor_rear_low_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_rear_low_mounted_work_lights(&self) -> TractorRearLowMountedWorkLights2566799614 {
        TractorRearLowMountedWorkLights2566799614::from(self.tractor_rear_low_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor underside mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_underside_mounted_work_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_underside_mounted_work_lights(&self) -> TrctrUndersideMountedWorkLights2566799614 {
        TrctrUndersideMountedWorkLights2566799614::from(self.trctr_underside_mounted_work_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor and/or implement rear fog lights.
    #[allow(dead_code)]
    pub fn rear_fog_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_fog_lights(&self) -> RearFogLights2566799614 {
        RearFogLights2566799614::from(self.rear_fog_lights_raw_value() as u64)
    }

    /// Read TractorMarkerLight signal from can frame
    #[allow(dead_code)]
    pub fn tractor_marker_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_marker_light(&self) -> TractorMarkerLight2566799614 {
        TractorMarkerLight2566799614::from(self.tractor_marker_light_raw_value() as u64)
    }

    /// Read ImplementMarkerLight signal from can frame
    #[allow(dead_code)]
    pub fn implement_marker_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_marker_light(&self) -> ImplementMarkerLight2566799614 {
        ImplementMarkerLight2566799614::from(self.implement_marker_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor high mounted clearance and center ID lights.
    #[allow(dead_code)]
    pub fn tractor_clearance_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_clearance_light(&self) -> TractorClearanceLight2566799614 {
        TractorClearanceLight2566799614::from(self.tractor_clearance_light_raw_value() as u64)
    }

    /// This parameter provides measured data from an attached implement high mounted clearance lights.
    #[allow(dead_code)]
    pub fn implement_clearance_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_clearance_light(&self) -> ImplementClearanceLight2566799614 {
        ImplementClearanceLight2566799614::from(self.implement_clearance_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor and attached implement left stop lights.
    #[allow(dead_code)]
    pub fn left_stop_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn left_stop_light(&self) -> LeftStopLight2566799614 {
        LeftStopLight2566799614::from(self.left_stop_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor and attached implement right stop lights.
    #[allow(dead_code)]
    pub fn right_stop_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn right_stop_light(&self) -> RightStopLight2566799614 {
        RightStopLight2566799614::from(self.right_stop_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor and attached implement center stop lights.
    #[allow(dead_code)]
    pub fn center_stop_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn center_stop_light(&self) -> CenterStopLight2566799614 {
        CenterStopLight2566799614::from(self.center_stop_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the back up lights and/ or associated alarm.
    #[allow(dead_code)]
    pub fn back_up_light_and_alarm_horn_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn back_up_light_and_alarm_horn(&self) -> BackUpLightAndAlarmHorn2566799614 {
        BackUpLightAndAlarmHorn2566799614::from(self.back_up_light_and_alarm_horn_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor and attached implement left turn signal lights.
    #[allow(dead_code)]
    pub fn left_turn_signal_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn left_turn_signal_lights(&self) -> LeftTurnSignalLights2566799614 {
        LeftTurnSignalLights2566799614::from(self.left_turn_signal_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor and attached implement right turn signal lights.
    #[allow(dead_code)]
    pub fn right_turn_signal_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn right_turn_signal_lights(&self) -> RightTurnSignalLights2566799614 {
        RightTurnSignalLights2566799614::from(self.right_turn_signal_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the beacon light on tractor or attached implements.
    #[allow(dead_code)]
    pub fn rotating_beacon_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rotating_beacon_light(&self) -> RotatingBeaconLight2566799614 {
        RotatingBeaconLight2566799614::from(self.rotating_beacon_light_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor front fog lights.
    #[allow(dead_code)]
    pub fn tractor_front_fog_lights_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_front_fog_lights(&self) -> TractorFrontFogLights2566799614 {
        TractorFrontFogLights2566799614::from(self.tractor_front_fog_lights_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor high beam head light lamps.
    #[allow(dead_code)]
    pub fn high_beam_head_light_data_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn high_beam_head_light_data(&self) -> HighBeamHeadLightData2566799614 {
        HighBeamHeadLightData2566799614::from(self.high_beam_head_light_data_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor low beam head light lamps.
    #[allow(dead_code)]
    pub fn low_beam_head_light_data_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn low_beam_head_light_data(&self) -> LowBeamHeadLightData2566799614 {
        LowBeamHeadLightData2566799614::from(self.low_beam_head_light_data_raw_value() as u64)
    }

    /// This parameter provides measured data from the tractor alternate beam head light lamps.
    #[allow(dead_code)]
    pub fn alt_beam_head_light_data_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn alt_beam_head_light_data(&self) -> AltBeamHeadLightData2566799614 {
        AltBeamHeadLightData2566799614::from(self.alt_beam_head_light_data_raw_value() as u64)
    }

    /// This parameter provides measured data from the vehicle�s running lights.
    #[allow(dead_code)]
    pub fn running_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn running_light(&self) -> RunningLight2566799614 {
        RunningLight2566799614::from(self.running_light_raw_value() as u64)
    }
}

/// Lighting Command
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lc {
    frame_payload: Vec<u8>,
}

impl Lc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lc {
        frame_payload.resize(8, 0);
        Lc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217989630);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Command to activate or de-activate implement rear work lights.
    #[allow(dead_code)]
    pub fn implement_rear_work_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_rear_work_light_cmd(&self) -> ImplementRearWorkLightCmd2365473278 {
        ImplementRearWorkLightCmd2365473278::from(self.implement_rear_work_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the forward facing work lights toward the left end of the implement.
    #[allow(dead_code)]
    pub fn implment_left_forward_work_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implment_left_forward_work_light_cmd(&self) -> ImplmentLeftForwardWorkLightCmd2365473278 {
        ImplmentLeftForwardWorkLightCmd2365473278::from(self.implment_left_forward_work_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the forward facing work lights toward the right end of the implement.
    #[allow(dead_code)]
    pub fn implmnt_right_forward_work_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implmnt_right_forward_work_light_cmd(&self) -> ImplmntRightForwardWorkLightCmd2365473278 {
        ImplmntRightForwardWorkLightCmd2365473278::from(self.implmnt_right_forward_work_light_cmd_raw_value() as u64)
    }

    /// Read LightingDataRqCmd signal from can frame
    #[allow(dead_code)]
    pub fn lighting_data_rq_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lighting_data_rq_cmd(&self) -> LightingDataRqCmd2365473278 {
        LightingDataRqCmd2365473278::from(self.lighting_data_rq_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate work lights mounted on an implement to illuminate beyond left end of the implement.
    #[allow(dead_code)]
    pub fn implement_left_facing_work_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_left_facing_work_light_cmd(&self) -> ImplementLeftFacingWorkLightCmd2365473278 {
        ImplementLeftFacingWorkLightCmd2365473278::from(self.implement_left_facing_work_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate work lights mounted on an implement to illuminate beyond right end of the implement.
    #[allow(dead_code)]
    pub fn implment_right_facing_work_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implment_right_facing_work_light_cmd(&self) -> ImplmentRightFacingWorkLightCmd2365473278 {
        ImplmentRightFacingWorkLightCmd2365473278::from(self.implment_right_facing_work_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate an implement OEM option 1 light.
    #[allow(dead_code)]
    pub fn implement_oem_option1_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_oem_option1_light_cmd(&self) -> ImplementOemOption1LightCmd2365473278 {
        ImplementOemOption1LightCmd2365473278::from(self.implement_oem_option1_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate an implement OEM option 2 light.
    #[allow(dead_code)]
    pub fn implement_oem_option2_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_oem_option2_light_cmd(&self) -> ImplementOemOption2LightCmd2365473278 {
        ImplementOemOption2LightCmd2365473278::from(self.implement_oem_option2_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor front high mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_frnt_hgh_munted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_frnt_hgh_munted_work_lights_cmd(&self) -> TrctrFrntHghMuntedWorkLightsCmd2365473278 {
        TrctrFrntHghMuntedWorkLightsCmd2365473278::from(self.trctr_frnt_hgh_munted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor front low mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_frnt_lw_mounted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_frnt_lw_mounted_work_lights_cmd(&self) -> TrctrFrntLwMountedWorkLightsCmd2365473278 {
        TrctrFrntLwMountedWorkLightsCmd2365473278::from(self.trctr_frnt_lw_mounted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor side high mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_sd_high_mounted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_sd_high_mounted_work_lights_cmd(&self) -> TrctrSdHighMountedWorkLightsCmd2365473278 {
        TrctrSdHighMountedWorkLightsCmd2365473278::from(self.trctr_sd_high_mounted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor side low mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_sde_low_mounted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_sde_low_mounted_work_lights_cmd(&self) -> TrctrSdeLowMountedWorkLightsCmd2365473278 {
        TrctrSdeLowMountedWorkLightsCmd2365473278::from(self.trctr_sde_low_mounted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor rear high mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_rr_high_mounted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_rr_high_mounted_work_lights_cmd(&self) -> TrctrRrHighMountedWorkLightsCmd2365473278 {
        TrctrRrHighMountedWorkLightsCmd2365473278::from(self.trctr_rr_high_mounted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor rear low mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_rar_low_mounted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_rar_low_mounted_work_lights_cmd(&self) -> TrctrRarLowMountedWorkLightsCmd2365473278 {
        TrctrRarLowMountedWorkLightsCmd2365473278::from(self.trctr_rar_low_mounted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor underside mounted work lights.
    #[allow(dead_code)]
    pub fn trctr_undrsd_mounted_work_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_undrsd_mounted_work_lights_cmd(&self) -> TrctrUndrsdMountedWorkLightsCmd2365473278 {
        TrctrUndrsdMountedWorkLightsCmd2365473278::from(self.trctr_undrsd_mounted_work_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate tractor or implement rear fog lights.
    #[allow(dead_code)]
    pub fn rear_fog_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_fog_light_cmd(&self) -> RearFogLightCmd2365473278 {
        RearFogLightCmd2365473278::from(self.rear_fog_light_cmd_raw_value() as u64)
    }

    /// Read TractorMarkerLightCmd signal from can frame
    #[allow(dead_code)]
    pub fn tractor_marker_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_marker_light_cmd(&self) -> TractorMarkerLightCmd2365473278 {
        TractorMarkerLightCmd2365473278::from(self.tractor_marker_light_cmd_raw_value() as u64)
    }

    /// Read ImplementMarkerLightCmd signal from can frame
    #[allow(dead_code)]
    pub fn implement_marker_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_marker_light_cmd(&self) -> ImplementMarkerLightCmd2365473278 {
        ImplementMarkerLightCmd2365473278::from(self.implement_marker_light_cmd_raw_value() as u64)
    }

    /// Read TractorClearanceLightCmd signal from can frame
    #[allow(dead_code)]
    pub fn tractor_clearance_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_clearance_light_cmd(&self) -> TractorClearanceLightCmd2365473278 {
        TractorClearanceLightCmd2365473278::from(self.tractor_clearance_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the implement high mounted clearance and lights.
    #[allow(dead_code)]
    pub fn implement_clearance_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn implement_clearance_light_cmd(&self) -> ImplementClearanceLightCmd2365473278 {
        ImplementClearanceLightCmd2365473278::from(self.implement_clearance_light_cmd_raw_value() as u64)
    }

    /// Read LeftStopLightCmd signal from can frame
    #[allow(dead_code)]
    pub fn left_stop_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn left_stop_light_cmd(&self) -> LeftStopLightCmd2365473278 {
        LeftStopLightCmd2365473278::from(self.left_stop_light_cmd_raw_value() as u64)
    }

    /// Read RightStopLightCmd signal from can frame
    #[allow(dead_code)]
    pub fn right_stop_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn right_stop_light_cmd(&self) -> RightStopLightCmd2365473278 {
        RightStopLightCmd2365473278::from(self.right_stop_light_cmd_raw_value() as u64)
    }

    /// Read CenterStopLightCmd signal from can frame
    #[allow(dead_code)]
    pub fn center_stop_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn center_stop_light_cmd(&self) -> CenterStopLightCmd2365473278 {
        CenterStopLightCmd2365473278::from(self.center_stop_light_cmd_raw_value() as u64)
    }

    /// Read BackUpLightAndAlarmHornCmd signal from can frame
    #[allow(dead_code)]
    pub fn back_up_light_and_alarm_horn_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn back_up_light_and_alarm_horn_cmd(&self) -> BackUpLightAndAlarmHornCmd2365473278 {
        BackUpLightAndAlarmHornCmd2365473278::from(self.back_up_light_and_alarm_horn_cmd_raw_value() as u64)
    }

    /// Read LeftTurnSignalLightsCmd signal from can frame
    #[allow(dead_code)]
    pub fn left_turn_signal_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn left_turn_signal_lights_cmd(&self) -> LeftTurnSignalLightsCmd2365473278 {
        LeftTurnSignalLightsCmd2365473278::from(self.left_turn_signal_lights_cmd_raw_value() as u64)
    }

    /// Read RightTurnSignalLightsCmd signal from can frame
    #[allow(dead_code)]
    pub fn right_turn_signal_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn right_turn_signal_lights_cmd(&self) -> RightTurnSignalLightsCmd2365473278 {
        RightTurnSignalLightsCmd2365473278::from(self.right_turn_signal_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate slow moving vehicle indicator lights on tractor and/or implements.
    #[allow(dead_code)]
    pub fn rotating_beacon_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rotating_beacon_light_cmd(&self) -> RotatingBeaconLightCmd2365473278 {
        RotatingBeaconLightCmd2365473278::from(self.rotating_beacon_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate tractor front fog lights.
    #[allow(dead_code)]
    pub fn tractor_front_fog_lights_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_front_fog_lights_cmd(&self) -> TractorFrontFogLightsCmd2365473278 {
        TractorFrontFogLightsCmd2365473278::from(self.tractor_front_fog_lights_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor high beam head light lamps.
    #[allow(dead_code)]
    pub fn high_beam_head_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn high_beam_head_light_cmd(&self) -> HighBeamHeadLightCmd2365473278 {
        HighBeamHeadLightCmd2365473278::from(self.high_beam_head_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor low beam head light lamps.
    #[allow(dead_code)]
    pub fn low_beam_head_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn low_beam_head_light_cmd(&self) -> LowBeamHeadLightCmd2365473278 {
        LowBeamHeadLightCmd2365473278::from(self.low_beam_head_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor alternate head lights (only low beam is available on alternate head lights).
    #[allow(dead_code)]
    pub fn alt_beam_head_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn alt_beam_head_light_cmd(&self) -> AltBeamHeadLightCmd2365473278 {
        AltBeamHeadLightCmd2365473278::from(self.alt_beam_head_light_cmd_raw_value() as u64)
    }

    /// Command to activate or de-activate the tractor or powered vehicle running lights.
    #[allow(dead_code)]
    pub fn running_light_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn running_light_cmd(&self) -> RunningLightCmd2365473278 {
        RunningLightCmd2365473278::from(self.running_light_cmd_raw_value() as u64)
    }
}

/// Laser Leveling System Blade Control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lbc {
    frame_payload: Vec<u8>,
}

impl Lbc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lbc {
        frame_payload.resize(8, 0);
        Lbc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lbc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218002174);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lbc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Allows the user to select the type of blade control for the land leveling system.
    #[allow(dead_code)]
    pub fn blade_ctrl_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn blade_ctrl_mode(&self) -> BladeCtrlMode2365485822 {
        BladeCtrlMode2365485822::from(self.blade_ctrl_mode_raw_value() as u64)
    }

    /// Used to indicate the duration and direction that the land leveling system blade moves.
    /// Unit: sec
    #[allow(dead_code)]
    pub fn blade_duration_and_direction_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Ignition Timing 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct It6 {
    frame_payload: Vec<u8>,
}

impl It6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> It6 {
        frame_payload.resize(8, 0);
        It6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<It6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486443006);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| It6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The actual ignition timing at the current engine conditions.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_actual_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// A programmable timing value specific to the engine�s application.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_desired_ignt_timing3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// A programmable timing value specific to the engine�s application.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_desired_ignt_timing2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// A programmable timing value specific to the engine�s application.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_desired_ignt_timing1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Ignition Timing 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct It5 {
    frame_payload: Vec<u8>,
}

impl It5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> It5 {
        frame_payload.resize(8, 0);
        It5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<It5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486442750);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| It5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl20_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl19_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl18_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl17_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Ignition Timing 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct It4 {
    frame_payload: Vec<u8>,
}

impl It4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> It4 {
        frame_payload.resize(8, 0);
        It4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<It4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486442494);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| It4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl16_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl15_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl14_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl13_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Ignition Timing 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct It3 {
    frame_payload: Vec<u8>,
}

impl It3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> It3 {
        frame_payload.resize(8, 0);
        It3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<It3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486442238);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| It3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl12_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl11_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl10_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl9_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Ignition Timing 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct It2 {
    frame_payload: Vec<u8>,
}

impl It2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> It2 {
        frame_payload.resize(8, 0);
        It2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<It2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486441982);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| It2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl8_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl7_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl6_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl5_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Ignition Timing 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct It1 {
    frame_payload: Vec<u8>,
}

impl It1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> It1 {
        frame_payload.resize(8, 0);
        It1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<It1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486441726);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| It1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl4_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl3_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl2_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The ignition timing of the cylinder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_cyl1_ignt_timing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Ignition Transformer Secondary Output 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Iso3 {
    frame_payload: Vec<u8>,
}

impl Iso3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Iso3 {
        frame_payload.resize(8, 0);
        Iso3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Iso3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486443774);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Iso3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl20_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl19_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl18_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl17_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Ignition Transformer Secondary Output 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Iso2 {
    frame_payload: Vec<u8>,
}

impl Iso2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Iso2 {
        frame_payload.resize(8, 0);
        Iso2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Iso2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486443518);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Iso2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl16_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl15_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl14_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl13_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl12_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl11_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl10_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl9_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Ignition Transformer Secondary Output 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Iso1 {
    frame_payload: Vec<u8>,
}

impl Iso1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Iso1 {
        frame_payload.resize(8, 0);
        Iso1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Iso1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486443262);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Iso1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl8_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl7_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl6_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl5_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl4_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl3_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl2_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// This parameter indicates the relative intensity of the secondary output voltage of the ignition transformer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl1_ignt_trans_second_output_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Operator Primary Intermediate Speed Control state
#[allow(dead_code)]
#[derive(Debug)]
pub struct Iscs {
    frame_payload: Vec<u8>,
}

impl Iscs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Iscs {
        frame_payload.resize(8, 0);
        Iscs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Iscs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419285246);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Iscs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// 13 preprogrammed intermediate speed control settings are availible for the contolling ECM to select.
    #[allow(dead_code)]
    pub fn eng_oprtr_prmry_intrmdt_spd_slct_stte_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_oprtr_prmry_intrmdt_spd_slct_stte(&self) -> EngOprtrPrmryIntrmdtSpdSlctStte2566768894 {
        EngOprtrPrmryIntrmdtSpdSlctStte2566768894::from(self.eng_oprtr_prmry_intrmdt_spd_slct_stte_raw_value() as u64)
    }
}

/// Intermediate Speed Control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Isc {
    frame_payload: Vec<u8>,
}

impl Isc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Isc {
        frame_payload.resize(8, 0);
        Isc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Isc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419285758);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Isc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Allows the operator to select one of 13 preprogrammed Intermediate Speed Control settings.
    #[allow(dead_code)]
    pub fn eng_oprtr_prmry_intrmdt_speed_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_oprtr_prmry_intrmdt_speed_select(&self) -> EngOprtrPrmryIntrmdtSpeedSelect2566769406 {
        EngOprtrPrmryIntrmdtSpeedSelect2566769406::from(self.eng_oprtr_prmry_intrmdt_speed_select_raw_value() as u64)
    }
}

/// Idle Operation
#[allow(dead_code)]
#[derive(Debug)]
pub struct Io {
    frame_payload: Vec<u8>,
}

impl Io {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Io {
        frame_payload.resize(8, 0);
        Io { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Io, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419355902);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Io::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Accumulated time of operation of the engine while under idle conditions.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn eng_total_idle_hours_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Accumulated amount of fuel used during vehicle operation while under idle conditions.
    /// Unit: L
    #[allow(dead_code)]
    pub fn eng_total_idle_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Intake Manifold Information 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Imt2 {
    frame_payload: Vec<u8>,
}

impl Imt2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Imt2 {
        frame_payload.resize(8, 0);
        Imt2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Imt2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486450686);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Imt2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of pre-combustion air found in intake manifold number 6 of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold6_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Temperature of pre-combustion air found in intake manifold number 5 of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold5_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Temperature of pre-combustion air found in intake manifold of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold4_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Temperature of pre-combustion air found in intake manifold of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold3_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Temperature of pre-combustion air found in intake manifold of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold2_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Intake Manifold Information 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Imt1 {
    frame_payload: Vec<u8>,
}

impl Imt1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Imt1 {
        frame_payload.resize(8, 0);
        Imt1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Imt1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419342078);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Imt1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Gage pressure of air measured downstream of the compressor discharge side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo4_boost_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Gage pressure of air measured downstream of the compressor discharge side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo3_boost_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Gage pressure of air measured downstream of the compressor discharge side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo2_boost_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Gage pressure of air measured downstream of the compressor discharge side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo1_boost_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.125000).round() as u16
    }
}

/// Inlet/Exhaust Conditions 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ic2 {
    frame_payload: Vec<u8>,
}

impl Ic2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ic2 {
        frame_payload.resize(8, 0);
        Ic2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ic2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419287294);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ic2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngAirFilter4DiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_filter4_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.050000).round() as u8
    }

    /// Read EngAirFilter3DiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_filter3_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.050000).round() as u8
    }

    /// Read EngAirFilter2DiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_filter2_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.050000).round() as u8
    }

    /// The gage pressure measurement of the air intake manifold for bank #2 or the second air intake manifold.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intake_manifold2_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// The absolute pressure measurement of the air intake manifold.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_intake_manifold1_abs_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 2.000000).round() as u8
    }
}

/// Inlet/Exhaust Conditions 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ic1 {
    frame_payload: Vec<u8>,
}

impl Ic1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ic1 {
        frame_payload.resize(8, 0);
        Ic1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ic1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419362558);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ic1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngCoolantFilterDiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_coolant_filter_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.500000).round() as u8
    }

    /// Temperature of combustion byproducts leaving the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngAirFilter1DiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_filter1_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.050000).round() as u8
    }

    /// Absolute air pressure at inlet to intake manifold or air box.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_inlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Temperature of pre-combustion air found in intake manifold of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold1_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Gage pressure of air measured downstream on the compressor discharge side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo_boost_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Exhaust back pressure as a result of particle accumulation on filter media placed in the exhaust stream.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_particulate_trap_inlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.500000).round() as u8
    }
}

/// Heater Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Htr {
    frame_payload: Vec<u8>,
}

impl Htr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Htr {
        frame_payload.resize(8, 0);
        Htr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Htr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419327486);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Htr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Parameter indicating whether the cab zone is being heated.
    #[allow(dead_code)]
    pub fn cab_heating_zone_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cab_heating_zone(&self) -> CabHeatingZone2566811134 {
        CabHeatingZone2566811134::from(self.cab_heating_zone_raw_value() as u64)
    }

    /// Parameter indicating whether the engine zone is being heated.
    #[allow(dead_code)]
    pub fn eng_heating_zone_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_heating_zone(&self) -> EngHeatingZone2566811134 {
        EngHeatingZone2566811134::from(self.eng_heating_zone_raw_value() as u64)
    }

    /// Indicates whether the cab is being ventilated or not.
    #[allow(dead_code)]
    pub fn cab_ventilation_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cab_ventilation(&self) -> CabVentilation2566811134 {
        CabVentilation2566811134::from(self.cab_ventilation_raw_value() as u64)
    }

    /// Read AuxilaryHeaterWaterPumpStatus signal from can frame
    #[allow(dead_code)]
    pub fn auxilary_heater_water_pump_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn auxilary_heater_water_pump_status(&self) -> AuxilaryHeaterWaterPumpStatus2566811134 {
        AuxilaryHeaterWaterPumpStatus2566811134::from(self.auxilary_heater_water_pump_status_raw_value() as u64)
    }

    /// Read AuxHeaterMode signal from can frame
    #[allow(dead_code)]
    pub fn aux_heater_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_heater_mode(&self) -> AuxHeaterMode2566811134 {
        AuxHeaterMode2566811134::from(self.aux_heater_mode_raw_value() as u64)
    }

    /// Current auxiliary heater output power, relative to the auxiliary heater maximum output power.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aux_heater_output_power_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Temperature of the input air in an auxiliary heater system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aux_heater_input_air_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Temperature of the auxiliary heater output coolant (I.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aux_heater_output_coolant_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// High Resolution Wheel Speed
#[allow(dead_code)]
#[derive(Debug)]
pub struct Hrw {
    frame_payload: Vec<u8>,
}

impl Hrw {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Hrw {
        frame_payload.resize(8, 0);
        Hrw { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Hrw, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(150892286);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Hrw::new(frame.data().to_vec())));
        Ok(f)
    }

    /// High resolution measurement of the speed of the right wheel on the rear axle.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn rear_axle_right_wheel_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// High resolution measurement of the speed of the left wheel on the rear axle.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn rear_axle_left_wheel_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// High resolution measurement of the speed of the right wheel on the front axle.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn front_axle_right_wheel_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// High resolution measurement of the speed of the left wheel on the front axle.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn front_axle_left_wheel_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.003906).round() as u16
    }
}

/// Hydraulic Pressure Governor Info
#[allow(dead_code)]
#[derive(Debug)]
pub struct Hpg {
    frame_payload: Vec<u8>,
}

impl Hpg {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Hpg {
        frame_payload.resize(8, 0);
        Hpg { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Hpg, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418384126);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Hpg::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read FireApparatusPumpEngagement signal from can frame
    #[allow(dead_code)]
    pub fn fire_apparatus_pump_engagement_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fire_apparatus_pump_engagement(&self) -> FireApparatusPumpEngagement2565867774 {
        FireApparatusPumpEngagement2565867774::from(self.fire_apparatus_pump_engagement_raw_value() as u64)
    }

    /// Read EngHydPressGovernorSwitch signal from can frame
    #[allow(dead_code)]
    pub fn eng_hyd_press_governor_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_hyd_press_governor_switch(&self) -> EngHydPressGovernorSwitch2565867774 {
        EngHydPressGovernorSwitch2565867774::from(self.eng_hyd_press_governor_switch_raw_value() as u64)
    }

    /// Mode for governor operation is hydraulic pressure control.
    #[allow(dead_code)]
    pub fn eng_hyd_prss_governor_mode_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_hyd_prss_governor_mode_indicator(&self) -> EngHydPrssGovernorModeIndicator2565867774 {
        EngHydPrssGovernorModeIndicator2565867774::from(self.eng_hyd_prss_governor_mode_indicator_raw_value() as u64)
    }

    /// Hydraulic pressure measured at the output of the hydraulic pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn hyd_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 2.000000).round() as u16
    }
}

/// Engine Hours, Revolutions
#[allow(dead_code)]
#[derive(Debug)]
pub struct Hours {
    frame_payload: Vec<u8>,
}

impl Hours {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Hours {
        frame_payload.resize(8, 0);
        Hours { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Hours, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419358206);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Hours::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Accumulated number of revolutions of engine crankshaft during its operation.
    /// Unit: r
    #[allow(dead_code)]
    pub fn eng_total_revolutions_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 1000.000000).round() as u32
    }

    /// Accumulated time of operation of engine.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn eng_total_hours_of_operation_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }
}

/// Hydraulic Braking System
#[allow(dead_code)]
#[derive(Debug)]
pub struct Hbs {
    frame_payload: Vec<u8>,
}

impl Hbs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Hbs {
        frame_payload.resize(8, 0);
        Hbs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Hbs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217966334);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Hbs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates whether the hydraulic fluid level in the reservoir(s) is sufficient.
    #[allow(dead_code)]
    pub fn hyd_brake_fluid_level_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_brake_fluid_level_switch(&self) -> HydBrakeFluidLevelSwitch2365449982 {
        HydBrakeFluidLevelSwitch2365449982::from(self.hyd_brake_fluid_level_switch_raw_value() as u64)
    }

    /// Signal which commands an audible warning by the hydraulic braking system.
    #[allow(dead_code)]
    pub fn hyd_brake_system_audible_warning_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_brake_system_audible_warning_cmd(&self) -> HydBrakeSystemAudibleWarningCmd2365449982 {
        HydBrakeSystemAudibleWarningCmd2365449982::from(self.hyd_brake_system_audible_warning_cmd_raw_value() as u64)
    }

    /// Read HydBrkePressSupplyStateCircuit2 signal from can frame
    #[allow(dead_code)]
    pub fn hyd_brke_press_supply_state_circuit2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_brke_press_supply_state_circuit2(&self) -> HydBrkePressSupplyStateCircuit22365449982 {
        HydBrkePressSupplyStateCircuit22365449982::from(self.hyd_brke_press_supply_state_circuit2_raw_value() as u64)
    }

    /// Read HydBrkePressSupplyStateCircuit1 signal from can frame
    #[allow(dead_code)]
    pub fn hyd_brke_press_supply_state_circuit1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_brke_press_supply_state_circuit1(&self) -> HydBrkePressSupplyStateCircuit12365449982 {
        HydBrkePressSupplyStateCircuit12365449982::from(self.hyd_brke_press_supply_state_circuit1_raw_value() as u64)
    }

    /// Read HydBrkPressWarningStateCircuit2 signal from can frame
    #[allow(dead_code)]
    pub fn hyd_brk_press_warning_state_circuit2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_brk_press_warning_state_circuit2(&self) -> HydBrkPressWarningStateCircuit22365449982 {
        HydBrkPressWarningStateCircuit22365449982::from(self.hyd_brk_press_warning_state_circuit2_raw_value() as u64)
    }

    /// Read HydBrkPressWarningStateCircuit1 signal from can frame
    #[allow(dead_code)]
    pub fn hyd_brk_press_warning_state_circuit1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_brk_press_warning_state_circuit1(&self) -> HydBrkPressWarningStateCircuit12365449982 {
        HydBrkPressWarningStateCircuit12365449982::from(self.hyd_brk_press_warning_state_circuit1_raw_value() as u64)
    }

    /// Read HydBrakePressCircuit2 signal from can frame
    /// Unit: MPa
    #[allow(dead_code)]
    pub fn hyd_brake_press_circuit2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 100.000000).round() as u8
    }

    /// Read HydBrakePressCircuit1 signal from can frame
    /// Unit: MPa
    #[allow(dead_code)]
    pub fn hyd_brake_press_circuit1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 100.000000).round() as u8
    }
}

/// Trip Fuel Information (Gaseous)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gtfi {
    frame_payload: Vec<u8>,
}

impl Gtfi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gtfi {
        frame_payload.resize(8, 0);
        Gtfi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gtfi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486455550);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gtfi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TripDriveFuelEconomy signal from can frame
    /// Unit: km/L
    #[allow(dead_code)]
    pub fn trip_drive_fuel_economy_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0xFFFF) as f64 * 0.001953).round() as u16
    }

    /// Total fuel consumed while the engine is in the cruise hold state since the last trip reset.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_cruise_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripVehicleIdleFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_vehicle_idle_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripPTONonmovingFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_pto_nonmoving_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripPTOMovingFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_pto_moving_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripDriveFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_drive_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Gaseous Fuel Pressure
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gfp {
    frame_payload: Vec<u8>,
}

impl Gfp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gfp {
        frame_payload.resize(8, 0);
        Gfp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gfp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486444030);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gfp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Absolute Pressure of gas on outlet side of the first or only fuel system control valve.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_valve1_outlet_abs_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The differential pressure between the gaseous fuel and the air intake manifold.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_to_fuel_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The differential pressure between the inlet and the outlet of a gaseous fuel valve.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_valve_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The absolute pressure at the inlet of the gaseous fuel valve.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_valve_inlet_abs_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Fuel Information 2 (Gaseous)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gfi2 {
    frame_payload: Vec<u8>,
}

impl Gfi2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gfi2 {
        frame_payload.resize(8, 0);
        Gfi2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gfi2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486441470);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gfi2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The rate at which the fuel is flowing through a fuel valve.
    /// Unit: m�/h
    #[allow(dead_code)]
    pub fn eng_fuel_flow_rate2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The rate at which the fuel is flowing through a fuel valve.
    /// Unit: m�/h
    #[allow(dead_code)]
    pub fn eng_fuel_flow_rate1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read EngRqedFuelValve2Pos signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_rqed_fuel_valve2_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The requested position of a gaseous fuel valve 1 that is metering the fuel flow to the engine.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_rqed_fuel_valve1_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The position of a gaseous fuel valve that is metering the fuel flow to the engine.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_fuel_valve2_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The position of a gaseous fuel valve that is metering the fuel flow to the engine.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_fuel_valve1_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Fuel Information 1 (Gaseous)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gfi1 {
    frame_payload: Vec<u8>,
}

impl Gfi1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gfi1 {
        frame_payload.resize(8, 0);
        Gfi1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gfi1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486454014);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gfi1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter conveys the specific gravity of the gaseous fuel being used by the engine.
    #[allow(dead_code)]
    pub fn eng_fuel_specific_gravity_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.000100).round() as u16
    }

    /// Average fuel rate, equal to trip fuel divided by trip time while the engine speed is above zero, since the last trip reset.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn trip_average_fuel_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Total fuel used while the PTO or remote PTO is in the hold state and engine speed is above zero, over the life of the engine.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn total_eng_pto_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Gaseous Fuel Properties
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gfd {
    frame_payload: Vec<u8>,
}

impl Gfd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gfd {
        frame_payload.resize(8, 0);
        Gfd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gfd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419321342);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gfd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The specific heat ratio of the fuel.
    #[allow(dead_code)]
    pub fn specific_heat_ratio_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.001000).round() as u16
    }
}

/// Fuel Consumption (Gaseous)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gfc {
    frame_payload: Vec<u8>,
}

impl Gfc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gfc {
        frame_payload.resize(8, 0);
        Gfc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gfc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486453246);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gfc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total fuel consumed (trip drive fuel + trip PTO moving fuel + trip PTO non-moving fuel + trip idle fuel) over the life of the engine.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn total_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Total fuel consumed (trip drive fuel + trip PTO moving fuel + trip PTO non-moving fuel + trip idle fuel) since the last trip reset.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_fuel_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Sensor Electrical Power #2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Sep2 {
    frame_payload: Vec<u8>,
}

impl Sep2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Sep2 {
        frame_payload.resize(8, 0);
        Sep2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Sep2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419273982);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Sep2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read SensorSupplyVoltage6 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn sensor_supply_voltage6_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read SensorSupplyVoltage5 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn sensor_supply_voltage5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Sensor Electrical Power #1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Sep1 {
    frame_payload: Vec<u8>,
}

impl Sep1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Sep1 {
        frame_payload.resize(8, 0);
        Sep1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Sep1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419274238);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Sep1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read SensorSupplyVoltage4 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn sensor_supply_voltage4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read SensorSupplyVoltage3 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn sensor_supply_voltage3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read SensorSupplyVoltage2 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn sensor_supply_voltage2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read SensorSupplyVoltage1 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn sensor_supply_voltage1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// PTO Drive Engagement
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ptode {
    frame_payload: Vec<u8>,
}

impl Ptode {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ptode {
        frame_payload.resize(8, 0);
        Ptode { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ptode, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419276030);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ptode::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports if this specific PTO drive is engaged.
    #[allow(dead_code)]
    pub fn enggmnt_sttus_trans_input_shaft_pto1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_sttus_trans_input_shaft_pto1(&self) -> EnggmntSttusTransInputShaftPto12566759678 {
        EnggmntSttusTransInputShaftPto12566759678::from(self.enggmnt_sttus_trans_input_shaft_pto1_raw_value() as u64)
    }

    /// Reports if this specific PTO drive is engaged.
    #[allow(dead_code)]
    pub fn enggmnt_sttus_trans_input_shaft_pto2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_sttus_trans_input_shaft_pto2(&self) -> EnggmntSttusTransInputShaftPto22566759678 {
        EnggmntSttusTransInputShaftPto22566759678::from(self.enggmnt_sttus_trans_input_shaft_pto2_raw_value() as u64)
    }

    /// Reports if this specific PTO drive is engaged.
    #[allow(dead_code)]
    pub fn enggmnt_sttus_trans_output_shaft_pto_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_sttus_trans_output_shaft_pto(&self) -> EnggmntSttusTransOutputShaftPto2566759678 {
        EnggmntSttusTransOutputShaftPto2566759678::from(self.enggmnt_sttus_trans_output_shaft_pto_raw_value() as u64)
    }

    /// Reports if this specific PTO drive is engaged.
    #[allow(dead_code)]
    pub fn enggmnt_stts_trnsfr_cs_otpt_shaft_pto_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_stts_trnsfr_cs_otpt_shaft_pto(&self) -> EnggmntSttsTrnsfrCsOtptShaftPto2566759678 {
        EnggmntSttsTrnsfrCsOtptShaftPto2566759678::from(self.enggmnt_stts_trnsfr_cs_otpt_shaft_pto_raw_value() as u64)
    }

    /// Status of the transmission controller�s consent to engage the first or sole PTO drive mounted on the transmission case.
    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trans_input_shaft_pto1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trans_input_shaft_pto1(&self) -> EnggmntCnsntTransInputShaftPto12566759678 {
        EnggmntCnsntTransInputShaftPto12566759678::from(self.enggmnt_cnsnt_trans_input_shaft_pto1_raw_value() as u64)
    }

    /// Status of the transmission controller�s consent to engage the second PTO drive mounted on the transmission case.
    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trans_input_shaft_pto2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trans_input_shaft_pto2(&self) -> EnggmntCnsntTransInputShaftPto22566759678 {
        EnggmntCnsntTransInputShaftPto22566759678::from(self.enggmnt_cnsnt_trans_input_shaft_pto2_raw_value() as u64)
    }

    /// Status of the transmission controller�s consent to engage the PTO drive connected to the transmission output shaft.
    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trans_output_shaft_pto_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trans_output_shaft_pto(&self) -> EnggmntCnsntTransOutputShaftPto2566759678 {
        EnggmntCnsntTransOutputShaftPto2566759678::from(self.enggmnt_cnsnt_trans_output_shaft_pto_raw_value() as u64)
    }

    /// Status of the transmission controller�s consent to engage the PTO drive connected to the transfer case output shaft.
    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trnsfr_cs_otpt_shft_pto_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enggmnt_cnsnt_trnsfr_cs_otpt_shft_pto(&self) -> EnggmntCnsntTrnsfrCsOtptShftPto2566759678 {
        EnggmntCnsntTrnsfrCsOtptShftPto2566759678::from(self.enggmnt_cnsnt_trnsfr_cs_otpt_shft_pto_raw_value() as u64)
    }

    /// Read EnableSwitchTransInputShaftPTO1 signal from can frame
    #[allow(dead_code)]
    pub fn enable_switch_trans_input_shaft_pto1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_switch_trans_input_shaft_pto1(&self) -> EnableSwitchTransInputShaftPto12566759678 {
        EnableSwitchTransInputShaftPto12566759678::from(self.enable_switch_trans_input_shaft_pto1_raw_value() as u64)
    }

    /// Read EnableSwitchTransInputShaftPTO2 signal from can frame
    #[allow(dead_code)]
    pub fn enable_switch_trans_input_shaft_pto2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_switch_trans_input_shaft_pto2(&self) -> EnableSwitchTransInputShaftPto22566759678 {
        EnableSwitchTransInputShaftPto22566759678::from(self.enable_switch_trans_input_shaft_pto2_raw_value() as u64)
    }

    /// Read EnableSwitchTransOutputShaftPTO signal from can frame
    #[allow(dead_code)]
    pub fn enable_switch_trans_output_shaft_pto_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_switch_trans_output_shaft_pto(&self) -> EnableSwitchTransOutputShaftPto2566759678 {
        EnableSwitchTransOutputShaftPto2566759678::from(self.enable_switch_trans_output_shaft_pto_raw_value() as u64)
    }

    /// Read EnblSwtchTrnsfrCsOutputShaftPTO signal from can frame
    #[allow(dead_code)]
    pub fn enbl_swtch_trnsfr_cs_output_shaft_pto_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enbl_swtch_trnsfr_cs_output_shaft_pto(&self) -> EnblSwtchTrnsfrCsOutputShaftPto2566759678 {
        EnblSwtchTrnsfrCsOutputShaftPto2566759678::from(self.enbl_swtch_trnsfr_cs_output_shaft_pto_raw_value() as u64)
    }
}

/// Fuel Information 3 (Gaseous)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gfi3 {
    frame_payload: Vec<u8>,
}

impl Gfi3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gfi3 {
        frame_payload.resize(8, 0);
        Gfi3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gfi3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(285057790);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gfi3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Absolute pressure of gas on outlet side of the second fuel system control valve.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_valve2_outlet_abs_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Temperature 2 of fuel (or gas).
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_fuel_temp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Read EngGasMassFlowRate2 signal from can frame
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn eng_gas_mass_flow_rate2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read EngFuelValve2InletAbsPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_valve2_inlet_abs_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Engine Fluid Level/Pressure 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP4 {
    frame_payload: Vec<u8>,
}

impl EflP4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP4 {
        frame_payload.resize(8, 0);
        EflP4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419277566);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The speed of a rotating (centrifugal) engine oil filter.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_centrifugal_oil_filter_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 4.000000).round() as u16
    }

    /// The differential pressure measured across the input and output of the engine coolant pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_coolant_pump_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 1.640000).round() as u8
    }

    /// Read EngChargeAirCooler2InletPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_charge_air_cooler2_inlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Read EngChargeAirCooler1InletPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_charge_air_cooler1_inlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Ratio of volume of liquid found in an engine intercooler cooling system to total engine intercooler cooling system volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_intercooler_coolant_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read EngChargeAirCoolerOutletPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_charge_air_cooler_outlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Ratio of aftercooler coolant system volume of liquid to total cooling system volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_aftercooler_coolant_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Electronic Engine Controller 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec6 {
    frame_payload: Vec<u8>,
}

impl Eec6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec6 {
        frame_payload.resize(8, 0);
        Eec6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(285058046);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Actuator that controls the variable geometry turbocharger geometry.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_vrable_geometry_turbo_actuator1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read EngTrbCmprssorBypassActuatorPos signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_trb_cmprssor_bypass_actuator_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read EngTurboCompressorCtrl signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_turbo_compressor_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    #[allow(dead_code)]
    pub fn eng_turbo_compressor_ctrl(&self) -> EngTurboCompressorCtrl2432541694 {
        EngTurboCompressorCtrl2432541694::from(self.eng_turbo_compressor_ctrl_raw_value() as u64)
    }
}

/// Door Control 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dc2 {
    frame_payload: Vec<u8>,
}

impl Dc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dc2 {
        frame_payload.resize(8, 0);
        Dc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419276286);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Enable status of bus door 10.
    #[allow(dead_code)]
    pub fn enable_status_of_door10_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door10(&self) -> EnableStatusOfDoor102566759934 {
        EnableStatusOfDoor102566759934::from(self.enable_status_of_door10_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor10 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door10_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door10(&self) -> OpenStatusOfDoor102566759934 {
        OpenStatusOfDoor102566759934::from(self.open_status_of_door10_raw_value() as u64)
    }

    /// Read LockStatusOfDoor10 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door10_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door10(&self) -> LockStatusOfDoor102566759934 {
        LockStatusOfDoor102566759934::from(self.lock_status_of_door10_raw_value() as u64)
    }

    /// Enable status of bus door 9.
    #[allow(dead_code)]
    pub fn enable_status_of_door9_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door9(&self) -> EnableStatusOfDoor92566759934 {
        EnableStatusOfDoor92566759934::from(self.enable_status_of_door9_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor9 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door9_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door9(&self) -> OpenStatusOfDoor92566759934 {
        OpenStatusOfDoor92566759934::from(self.open_status_of_door9_raw_value() as u64)
    }

    /// Read LockStatusOfDoor9 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door9_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door9(&self) -> LockStatusOfDoor92566759934 {
        LockStatusOfDoor92566759934::from(self.lock_status_of_door9_raw_value() as u64)
    }

    /// Enable status of bus door 8.
    #[allow(dead_code)]
    pub fn enable_status_of_door8_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door8(&self) -> EnableStatusOfDoor82566759934 {
        EnableStatusOfDoor82566759934::from(self.enable_status_of_door8_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor8 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door8_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door8(&self) -> OpenStatusOfDoor82566759934 {
        OpenStatusOfDoor82566759934::from(self.open_status_of_door8_raw_value() as u64)
    }

    /// Read LockStatusOfDoor8 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door8_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door8(&self) -> LockStatusOfDoor82566759934 {
        LockStatusOfDoor82566759934::from(self.lock_status_of_door8_raw_value() as u64)
    }

    /// Enable status of bus door 7.
    #[allow(dead_code)]
    pub fn enable_status_of_door7_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door7(&self) -> EnableStatusOfDoor72566759934 {
        EnableStatusOfDoor72566759934::from(self.enable_status_of_door7_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor7 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door7_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door7(&self) -> OpenStatusOfDoor72566759934 {
        OpenStatusOfDoor72566759934::from(self.open_status_of_door7_raw_value() as u64)
    }

    /// Read LockStatusOfDoor7 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door7_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door7(&self) -> LockStatusOfDoor72566759934 {
        LockStatusOfDoor72566759934::from(self.lock_status_of_door7_raw_value() as u64)
    }

    /// Enable status of bus door 6.
    #[allow(dead_code)]
    pub fn enable_status_of_door6_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door6(&self) -> EnableStatusOfDoor62566759934 {
        EnableStatusOfDoor62566759934::from(self.enable_status_of_door6_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor6 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door6_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door6(&self) -> OpenStatusOfDoor62566759934 {
        OpenStatusOfDoor62566759934::from(self.open_status_of_door6_raw_value() as u64)
    }

    /// Read LockStatusOfDoor6 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door6_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door6(&self) -> LockStatusOfDoor62566759934 {
        LockStatusOfDoor62566759934::from(self.lock_status_of_door6_raw_value() as u64)
    }

    /// Enable status of bus door 5.
    #[allow(dead_code)]
    pub fn enable_status_of_door5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door5(&self) -> EnableStatusOfDoor52566759934 {
        EnableStatusOfDoor52566759934::from(self.enable_status_of_door5_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor5 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door5(&self) -> OpenStatusOfDoor52566759934 {
        OpenStatusOfDoor52566759934::from(self.open_status_of_door5_raw_value() as u64)
    }

    /// Read LockStatusOfDoor5 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door5(&self) -> LockStatusOfDoor52566759934 {
        LockStatusOfDoor52566759934::from(self.lock_status_of_door5_raw_value() as u64)
    }

    /// Enable status of bus door 4.
    #[allow(dead_code)]
    pub fn enable_status_of_door4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door4(&self) -> EnableStatusOfDoor42566759934 {
        EnableStatusOfDoor42566759934::from(self.enable_status_of_door4_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor4 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door4(&self) -> OpenStatusOfDoor42566759934 {
        OpenStatusOfDoor42566759934::from(self.open_status_of_door4_raw_value() as u64)
    }

    /// Read LockStatusOfDoor4 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door4(&self) -> LockStatusOfDoor42566759934 {
        LockStatusOfDoor42566759934::from(self.lock_status_of_door4_raw_value() as u64)
    }

    /// Enable status of bus door 3.
    #[allow(dead_code)]
    pub fn enable_status_of_door3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door3(&self) -> EnableStatusOfDoor32566759934 {
        EnableStatusOfDoor32566759934::from(self.enable_status_of_door3_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor3 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door3(&self) -> OpenStatusOfDoor32566759934 {
        OpenStatusOfDoor32566759934::from(self.open_status_of_door3_raw_value() as u64)
    }

    /// Read LockStatusOfDoor3 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door3(&self) -> LockStatusOfDoor32566759934 {
        LockStatusOfDoor32566759934::from(self.lock_status_of_door3_raw_value() as u64)
    }

    /// Enable status of bus door 2.
    #[allow(dead_code)]
    pub fn enable_status_of_door2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door2(&self) -> EnableStatusOfDoor22566759934 {
        EnableStatusOfDoor22566759934::from(self.enable_status_of_door2_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor2 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door2(&self) -> OpenStatusOfDoor22566759934 {
        OpenStatusOfDoor22566759934::from(self.open_status_of_door2_raw_value() as u64)
    }

    /// Read LockStatusOfDoor2 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door2(&self) -> LockStatusOfDoor22566759934 {
        LockStatusOfDoor22566759934::from(self.lock_status_of_door2_raw_value() as u64)
    }

    /// Enable status of bus door 1.
    #[allow(dead_code)]
    pub fn enable_status_of_door1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn enable_status_of_door1(&self) -> EnableStatusOfDoor12566759934 {
        EnableStatusOfDoor12566759934::from(self.enable_status_of_door1_raw_value() as u64)
    }

    /// Read OpenStatusOfDoor1 signal from can frame
    #[allow(dead_code)]
    pub fn open_status_of_door1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn open_status_of_door1(&self) -> OpenStatusOfDoor12566759934 {
        OpenStatusOfDoor12566759934::from(self.open_status_of_door1_raw_value() as u64)
    }

    /// Read LockStatusOfDoor1 signal from can frame
    #[allow(dead_code)]
    pub fn lock_status_of_door1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lock_status_of_door1(&self) -> LockStatusOfDoor12566759934 {
        LockStatusOfDoor12566759934::from(self.lock_status_of_door1_raw_value() as u64)
    }
}

/// Catalyst Reagent Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cri1 {
    frame_payload: Vec<u8>,
}

impl Cri1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cri1 {
        frame_payload.resize(8, 0);
        Cri1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cri1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419273726);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cri1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates what reagent is in the tank.
    #[allow(dead_code)]
    pub fn catalyst_reagent_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn catalyst_reagent_type(&self) -> CatalystReagentType2566757374 {
        CatalystReagentType2566757374::from(self.catalyst_reagent_type_raw_value() as u64)
    }

    /// Used to identify the applicable J1939-73 FMI that applies to the most significant failure of the catalyst reagent properties sensor.
    #[allow(dead_code)]
    pub fn ctlyst_rgnt_prprtes_preliminary_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    /// Used to identify the applicable J1939-73 FMI that applies to the most significant failure of the catalyst temperature sensor.
    #[allow(dead_code)]
    pub fn ctlyst_ragent_temp2_preliminary_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x1F)) as u8
    }

    /// A measure of the conductivity of the reagent or fluid at the sensor.
    /// Unit: microSiemens/mm
    #[allow(dead_code)]
    pub fn catalyst_reagent_conductivity_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// A measure of the concentration of urea in water.
    /// Unit: %
    #[allow(dead_code)]
    pub fn catalyst_reagent_concentration_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.250000).round() as u8
    }

    /// Read CatalystReagentTemp2 signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn catalyst_reagent_temp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// After Treatment Historical Information #2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ahi2 {
    frame_payload: Vec<u8>,
}

impl Ahi2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ahi2 {
        frame_payload.resize(8, 0);
        Ahi2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ahi2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419273214);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ahi2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total amount of time that Aftertreatment device 2 has been in passive regeneration over the lifetime of the device.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_ttl_pssv_rgnration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF)) as u32
    }

    /// Total number of passive regenerations by Aftertreatment device 2 over the lifetime of the device.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_ttl_nmbr_of_pssv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0xFFFFFFFF)) as u32
    }

    /// Total number of Aftertreatment device 2 active regeneration manual requests by the operator over the lifetime of the device.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_ttl_nmbr_of_actv_rgnrtn_mn_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 224) & 0xFFFFFFFF)) as u32
    }

    /// Total number of Aftertreatment device 2 active regeneration inhibit requests by the operator over the lifetime of the device.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_ttl_nmbr_of_actv_rgnrtn_in_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 192) & 0xFFFFFFFF)) as u32
    }

    /// Total number of active regenerations by after treatment device 2 over the lifetime of the device.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftr_trtmnt2_ttl_nmbr_of_actv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of time that after treatment 2 regeneration has been manually disabled.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftr_treatment2_total_disabled_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of time that after treatment device 2 has been regenerating over the lifetime of the device.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftr_trtmnt2_ttal_regeneration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of fuel used by after treatment device 2 over the lifetime of the device.
    /// Unit: L
    #[allow(dead_code)]
    pub fn after_treatment2_total_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// After Treatment Fuel Control #2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Afc2 {
    frame_payload: Vec<u8>,
}

impl Afc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Afc2 {
        frame_payload.resize(8, 0);
        Afc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Afc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419275006);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Afc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtratment2FuelEnableActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftrtratment2_fuel_enable_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtratment2_fuel_enable_actuator(&self) -> Aftrtratment2FuelEnableActuator2566758654 {
        Aftrtratment2FuelEnableActuator2566758654::from(self.aftrtratment2_fuel_enable_actuator_raw_value() as u64)
    }

    /// Read Aftrtratment2RegenerationStatus signal from can frame
    #[allow(dead_code)]
    pub fn aftrtratment2_regeneration_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtratment2_regeneration_status(&self) -> Aftrtratment2RegenerationStatus2566758654 {
        Aftrtratment2RegenerationStatus2566758654::from(self.aftrtratment2_regeneration_status_raw_value() as u64)
    }

    /// Indicates whether aftertreatment #2 ignition circuit is energized by the ECM.
    #[allow(dead_code)]
    pub fn aftertreatment2_ignt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftertreatment2_ignt(&self) -> Aftertreatment2Ignt2566758654 {
        Aftertreatment2Ignt2566758654::from(self.aftertreatment2_ignt_raw_value() as u64)
    }

    /// Position that the controller is commanding the aftertreatment #2 fuel pressure control to maintain.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment2_fuel_press_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read Aftertreatment2FuelRate signal from can frame
    /// Unit: L/h
    #[allow(dead_code)]
    pub fn aftertreatment2_fuel_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Pressure of the fuel for Aftertreatment #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment2_fuel_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// After Treatment Fuel Control #1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Afc1 {
    frame_payload: Vec<u8>,
}

impl Afc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Afc1 {
        frame_payload.resize(8, 0);
        Afc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Afc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419275262);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Afc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtratment1FuelEnableActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftrtratment1_fuel_enable_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtratment1_fuel_enable_actuator(&self) -> Aftrtratment1FuelEnableActuator2566758910 {
        Aftrtratment1FuelEnableActuator2566758910::from(self.aftrtratment1_fuel_enable_actuator_raw_value() as u64)
    }

    /// Read Aftrtratment1RegenerationStatus signal from can frame
    #[allow(dead_code)]
    pub fn aftrtratment1_regeneration_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtratment1_regeneration_status(&self) -> Aftrtratment1RegenerationStatus2566758910 {
        Aftrtratment1RegenerationStatus2566758910::from(self.aftrtratment1_regeneration_status_raw_value() as u64)
    }

    /// Indicates whether aftertreatment #1 ignition circuit is energized by the ECM.
    #[allow(dead_code)]
    pub fn aftertreatment1_ignt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftertreatment1_ignt(&self) -> Aftertreatment1Ignt2566758910 {
        Aftertreatment1Ignt2566758910::from(self.aftertreatment1_ignt_raw_value() as u64)
    }

    /// Position that the controller is commanding the aftertreatment #1 fuel pressure control to maintain.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment1_fuel_press_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read Aftertreatment1FuelRate signal from can frame
    /// Unit: L/h
    #[allow(dead_code)]
    pub fn aftertreatment1_fuel_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Pressure of the fuel for Aftertreatment #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment1_fuel_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// After Treatment Air Control #2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Aac2 {
    frame_payload: Vec<u8>,
}

impl Aac2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Aac2 {
        frame_payload.resize(8, 0);
        Aac2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Aac2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419274494);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Aac2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtreatment2AirEnableActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftrtreatment2_air_enable_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtreatment2_air_enable_actuator(&self) -> Aftrtreatment2AirEnableActuator2566758142 {
        Aftrtreatment2AirEnableActuator2566758142::from(self.aftrtreatment2_air_enable_actuator_raw_value() as u64)
    }

    /// Read Aftertreatment2PurgeAirActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftertreatment2_purge_air_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftertreatment2_purge_air_actuator(&self) -> Aftertreatment2PurgeAirActuator2566758142 {
        Aftertreatment2PurgeAirActuator2566758142::from(self.aftertreatment2_purge_air_actuator_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2AtmzationAirActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_atmzation_air_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_atmzation_air_actuator(&self) -> Aftrtrtmnt2AtmzationAirActuator2566758142 {
        Aftrtrtmnt2AtmzationAirActuator2566758142::from(self.aftrtrtmnt2_atmzation_air_actuator_raw_value() as u64)
    }

    /// Read Aftertreatment2AirSystemRelay signal from can frame
    #[allow(dead_code)]
    pub fn aftertreatment2_air_system_relay_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftertreatment2_air_system_relay(&self) -> Aftertreatment2AirSystemRelay2566758142 {
        Aftertreatment2AirSystemRelay2566758142::from(self.aftertreatment2_air_system_relay_raw_value() as u64)
    }

    /// Position of the #2 aftertreatment air pressure actuator as measured by a position feedback sensor.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftrtrtment2_air_press_actuator_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Position that the controller is commanding the aftertreatment #2 air pressure control to maintain.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment2_air_press_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read Aftertreatment2PurgeAirPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment2_purge_air_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read Aftertreatment2SupplyAirPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment2_supply_air_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// After Treatment Air Control #1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Aac1 {
    frame_payload: Vec<u8>,
}

impl Aac1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Aac1 {
        frame_payload.resize(8, 0);
        Aac1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Aac1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419274750);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Aac1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtreatment1AirEnableActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftrtreatment1_air_enable_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtreatment1_air_enable_actuator(&self) -> Aftrtreatment1AirEnableActuator2566758398 {
        Aftrtreatment1AirEnableActuator2566758398::from(self.aftrtreatment1_air_enable_actuator_raw_value() as u64)
    }

    /// Read Aftertreatment1PurgeAirActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftertreatment1_purge_air_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftertreatment1_purge_air_actuator(&self) -> Aftertreatment1PurgeAirActuator2566758398 {
        Aftertreatment1PurgeAirActuator2566758398::from(self.aftertreatment1_purge_air_actuator_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1AtmzationAirActuator signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_atmzation_air_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_atmzation_air_actuator(&self) -> Aftrtrtmnt1AtmzationAirActuator2566758398 {
        Aftrtrtmnt1AtmzationAirActuator2566758398::from(self.aftrtrtmnt1_atmzation_air_actuator_raw_value() as u64)
    }

    /// Read Aftertreatment1AirSystemRelay signal from can frame
    #[allow(dead_code)]
    pub fn aftertreatment1_air_system_relay_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftertreatment1_air_system_relay(&self) -> Aftertreatment1AirSystemRelay2566758398 {
        Aftertreatment1AirSystemRelay2566758398::from(self.aftertreatment1_air_system_relay_raw_value() as u64)
    }

    /// Position of the #1 aftertreatment air pressure actuator as measured by a position feedback sensor.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftrtrtment1_air_press_actuator_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Position that the controller is commanding the aftertreatment #1 air pressure control to maintain.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment1_air_press_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read Aftertreatment1PurgeAirPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment1_purge_air_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read Aftertreatment1SupplyAirPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment1_supply_air_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// After Treatment Historical Information #1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ahi1 {
    frame_payload: Vec<u8>,
}

impl Ahi1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ahi1 {
        frame_payload.resize(8, 0);
        Ahi1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ahi1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419272958);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ahi1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total number of active regenerations by after treatment device 1 over the lifetime of the device.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftr_trtmnt1_ttl_nmbr_of_actv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of time that after treatment device 1 has been regenerating over the lifetime of the device.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftr_trtmnt1_ttal_regeneration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of time that after treatment 1 regeneration has been manually disabled.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftr_treatment1_total_disabled_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of fuel used by after treatment device 1 over the lifetime of the device.
    /// Unit: L
    #[allow(dead_code)]
    pub fn after_treatment1_total_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Requested Generator Average Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rgaaq {
    frame_payload: Vec<u8>,
}

impl Rgaaq {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rgaaq {
        frame_payload.resize(8, 0);
        Rgaaq { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rgaaq, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217062654);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rgaaq::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The requested average AC RMS voltage to be delivered by the generator.
    /// Unit: V
    #[allow(dead_code)]
    pub fn rqd_gnrtr_avrg_lne_line_acrms_voltage_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.007812).round() as u32
    }
}

/// Engine Throttle / Fuel Actuator Control Command
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tfac {
    frame_payload: Vec<u8>,
}

impl Tfac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tfac {
        frame_payload.resize(8, 0);
        Tfac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tfac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(284171006);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tfac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngThrottleActuator2CtrlCmd signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_throttle_actuator2_ctrl_cmd_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read EngThrottleActuator1CtrlCmd signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_throttle_actuator1_ctrl_cmd_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read EngFuelActuator2CtrlCmd signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_fuel_actuator2_ctrl_cmd_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read EngFuelActuator1CtrlCmd signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_fuel_actuator1_ctrl_cmd_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }
}

/// Engine Knock Level #3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Kl3 {
    frame_payload: Vec<u8>,
}

impl Kl3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Kl3 {
        frame_payload.resize(8, 0);
        Kl3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Kl3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217061886);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Kl3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Used to indicate the level of knock for engine cylinder 24.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl24_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 23.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl23_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 22.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl22_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 21.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl21_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 20.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl20_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 19.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl19_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 18.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl18_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 17.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl17_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Engine Knock Level #2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Kl2 {
    frame_payload: Vec<u8>,
}

impl Kl2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Kl2 {
        frame_payload.resize(8, 0);
        Kl2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Kl2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217061630);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Kl2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Used to indicate the level of knock for engine cylinder 15.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl15_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 14.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl14_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 13.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl13_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 12.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl12_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 11.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl11_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 10.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl10_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 9.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl9_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 16.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl16_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }
}

/// Engine Knock Level #1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Kl1 {
    frame_payload: Vec<u8>,
}

impl Kl1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Kl1 {
        frame_payload.resize(8, 0);
        Kl1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Kl1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217061374);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Kl1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Used to indicate the level of knock for engine cylinder 8.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl8_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 7.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl7_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 6.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl6_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 5.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl5_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 4.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl4_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 3.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl3_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 2.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl2_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Used to indicate the level of knock for engine cylinder 1.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_cyl1_knock_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Cylinder Combustion Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ccs {
    frame_payload: Vec<u8>,
}

impl Ccs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ccs {
        frame_payload.resize(8, 0);
        Ccs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ccs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217061118);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ccs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngCyl9CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl9_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl9_combustion_status(&self) -> EngCyl9CombustionStatus2364544766 {
        EngCyl9CombustionStatus2364544766::from(self.eng_cyl9_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl8CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl8_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl8_combustion_status(&self) -> EngCyl8CombustionStatus2364544766 {
        EngCyl8CombustionStatus2364544766::from(self.eng_cyl8_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl7CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl7_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl7_combustion_status(&self) -> EngCyl7CombustionStatus2364544766 {
        EngCyl7CombustionStatus2364544766::from(self.eng_cyl7_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl6CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl6_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl6_combustion_status(&self) -> EngCyl6CombustionStatus2364544766 {
        EngCyl6CombustionStatus2364544766::from(self.eng_cyl6_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl5CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl5_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl5_combustion_status(&self) -> EngCyl5CombustionStatus2364544766 {
        EngCyl5CombustionStatus2364544766::from(self.eng_cyl5_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl4CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl4_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl4_combustion_status(&self) -> EngCyl4CombustionStatus2364544766 {
        EngCyl4CombustionStatus2364544766::from(self.eng_cyl4_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl3CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl3_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl3_combustion_status(&self) -> EngCyl3CombustionStatus2364544766 {
        EngCyl3CombustionStatus2364544766::from(self.eng_cyl3_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl2CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl2_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl2_combustion_status(&self) -> EngCyl2CombustionStatus2364544766 {
        EngCyl2CombustionStatus2364544766::from(self.eng_cyl2_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl24CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl24_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl24_combustion_status(&self) -> EngCyl24CombustionStatus2364544766 {
        EngCyl24CombustionStatus2364544766::from(self.eng_cyl24_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl23CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl23_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl23_combustion_status(&self) -> EngCyl23CombustionStatus2364544766 {
        EngCyl23CombustionStatus2364544766::from(self.eng_cyl23_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl22CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl22_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl22_combustion_status(&self) -> EngCyl22CombustionStatus2364544766 {
        EngCyl22CombustionStatus2364544766::from(self.eng_cyl22_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl21CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl21_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl21_combustion_status(&self) -> EngCyl21CombustionStatus2364544766 {
        EngCyl21CombustionStatus2364544766::from(self.eng_cyl21_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl20CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl20_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl20_combustion_status(&self) -> EngCyl20CombustionStatus2364544766 {
        EngCyl20CombustionStatus2364544766::from(self.eng_cyl20_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl1CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl1_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl1_combustion_status(&self) -> EngCyl1CombustionStatus2364544766 {
        EngCyl1CombustionStatus2364544766::from(self.eng_cyl1_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl19CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl19_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl19_combustion_status(&self) -> EngCyl19CombustionStatus2364544766 {
        EngCyl19CombustionStatus2364544766::from(self.eng_cyl19_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl18CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl18_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl18_combustion_status(&self) -> EngCyl18CombustionStatus2364544766 {
        EngCyl18CombustionStatus2364544766::from(self.eng_cyl18_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl17CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl17_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl17_combustion_status(&self) -> EngCyl17CombustionStatus2364544766 {
        EngCyl17CombustionStatus2364544766::from(self.eng_cyl17_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl16CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl16_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl16_combustion_status(&self) -> EngCyl16CombustionStatus2364544766 {
        EngCyl16CombustionStatus2364544766::from(self.eng_cyl16_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl15CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl15_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl15_combustion_status(&self) -> EngCyl15CombustionStatus2364544766 {
        EngCyl15CombustionStatus2364544766::from(self.eng_cyl15_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl14CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl14_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl14_combustion_status(&self) -> EngCyl14CombustionStatus2364544766 {
        EngCyl14CombustionStatus2364544766::from(self.eng_cyl14_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl13CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl13_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl13_combustion_status(&self) -> EngCyl13CombustionStatus2364544766 {
        EngCyl13CombustionStatus2364544766::from(self.eng_cyl13_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl12CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl12_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl12_combustion_status(&self) -> EngCyl12CombustionStatus2364544766 {
        EngCyl12CombustionStatus2364544766::from(self.eng_cyl12_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl11CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl11_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl11_combustion_status(&self) -> EngCyl11CombustionStatus2364544766 {
        EngCyl11CombustionStatus2364544766::from(self.eng_cyl11_combustion_status_raw_value() as u64)
    }

    /// Read EngCyl10CombustionStatus signal from can frame
    #[allow(dead_code)]
    pub fn eng_cyl10_combustion_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_cyl10_combustion_status(&self) -> EngCyl10CombustionStatus2364544766 {
        EngCyl10CombustionStatus2364544766::from(self.eng_cyl10_combustion_status_raw_value() as u64)
    }
}

/// Requested Generator Total AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rgtarp {
    frame_payload: Vec<u8>,
}

impl Rgtarp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rgtarp {
        frame_payload.resize(8, 0);
        Rgtarp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rgtarp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217060862);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rgtarp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The requested lead/lag status for the generator average AC power factor
    #[allow(dead_code)]
    pub fn rq_gen_overall_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rq_gen_overall_power_factor_lagging(&self) -> RqGenOverallPowerFactorLagging2364544510 {
        RqGenOverallPowerFactorLagging2364544510::from(self.rq_gen_overall_power_factor_lagging_raw_value() as u64)
    }

    /// The requested average power factor of the generator.
    #[allow(dead_code)]
    pub fn rq_generator_overall_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.000061).round() as u16
    }

    /// The total reactive power requested to be delivered by the generator
    /// Unit: VA
    #[allow(dead_code)]
    pub fn rq_generator_total_ac_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Blade Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bi {
    frame_payload: Vec<u8>,
}

impl Bi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bi {
        frame_payload.resize(8, 0);
        Bi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217060606);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Figure of merit for blade rotation measurement.
    #[allow(dead_code)]
    pub fn blade_rotation_angle_figure_of_merit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn blade_rotation_angle_figure_of_merit(&self) -> BladeRotationAngleFigureOfMerit2364544254 {
        BladeRotationAngleFigureOfMerit2364544254::from(self.blade_rotation_angle_figure_of_merit_raw_value() as u64)
    }

    /// Figure of merit for blade height measurement.
    #[allow(dead_code)]
    pub fn rel_blade_height_figure_of_merit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rel_blade_height_figure_of_merit(&self) -> RelBladeHeightFigureOfMerit2364544254 {
        RelBladeHeightFigureOfMerit2364544254::from(self.rel_blade_height_figure_of_merit_raw_value() as u64)
    }

    /// The estimated measurement latency of the measurement.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn rel_blade_measurement_latency_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.500000).round() as u8
    }

    /// The blade rotation angle measurement around the yaw (z-axis).
    /// Unit: deg
    #[allow(dead_code)]
    pub fn blade_rotation_angle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// The measured vertical distance from a fixed location on the machine blade to a ground-based reference.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn relative_blade_height_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// ISO 11992: Towing vehicle message, electronic brake system #1/1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebs11 {
    frame_payload: Vec<u8>,
}

impl Ebs11 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebs11 {
        frame_payload.resize(8, 0);
        Ebs11 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebs11, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(201522942);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebs11::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The demanded value of the retarder on the towed vehicle(s) as a percentage of the absolute peak torque of retarder.
    /// Unit: %
    #[allow(dead_code)]
    pub fn retarder_demand_value_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// The requested brake pressure value of the parking brake as a percentage of maximum.
    /// Unit: %
    #[allow(dead_code)]
    pub fn park_brake_demand_value_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The requested brake pressure value of the service brake demanded by the driver.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn service_brake_demand_value_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.019531).round() as u16
    }

    /// Information to identify a dolly axle within the road train.
    #[allow(dead_code)]
    pub fn vehicle_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_type(&self) -> VehicleType2349006590 {
        VehicleType2349006590::from(self.vehicle_type_raw_value() as u64)
    }

    /// Signal which indicates that the brake pedal is being pressed.
    #[allow(dead_code)]
    pub fn brake_light_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn brake_light_switch(&self) -> BrakeLightSwitch2349006590 {
        BrakeLightSwitch2349006590::from(self.brake_light_switch_raw_value() as u64)
    }

    /// Signal which indicates that ASR engine control is active/passive.
    #[allow(dead_code)]
    pub fn asr_engine_control_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn asr_engine_control_active(&self) -> AsrEngineControlActive2349006590 {
        AsrEngineControlActive2349006590::from(self.asr_engine_control_active_raw_value() as u64)
    }

    /// Signal which indicates that ASR brake control is active/passive.
    #[allow(dead_code)]
    pub fn asr_break_control_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn asr_break_control_active(&self) -> AsrBreakControlActive2349006590 {
        AsrBreakControlActive2349006590::from(self.asr_break_control_active_raw_value() as u64)
    }

    /// This signal indicates the active/passive state in all cases when the installed retarder is applied by the driver�s demand or by other systems (brakes).
    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active(&self) -> VehicleRetarderCtrlActive2349006590 {
        VehicleRetarderCtrlActive2349006590::from(self.vehicle_retarder_ctrl_active_raw_value() as u64)
    }

    /// Signal indicating the ABS is active/passive.
    #[allow(dead_code)]
    pub fn vehicle_abs_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_abs_active(&self) -> VehicleAbsActive2349006590 {
        VehicleAbsActive2349006590::from(self.vehicle_abs_active_raw_value() as u64)
    }
}

/// ISO 11992: Towing vehicle message, electronic brake system #1/2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebs12 {
    frame_payload: Vec<u8>,
}

impl Ebs12 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebs12 {
        frame_payload.resize(8, 0);
        Ebs12 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebs12, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419351038);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebs12::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Estimated value of the current road curvature for use by the adaptive cruise control system.
    /// Unit: 1/km
    #[allow(dead_code)]
    pub fn road_curvature_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Signal which indicates that the towing vehicle has a pneumatic control line for the towed vehicle service braking system
    #[allow(dead_code)]
    pub fn pneumatic_control_line_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pneumatic_control_line(&self) -> PneumaticControlLine2566834686 {
        PneumaticControlLine2566834686::from(self.pneumatic_control_line_raw_value() as u64)
    }

    /// Request to activate the ABS off-road function. The switch signal is independent of an actual ABS control situation.
    #[allow(dead_code)]
    pub fn abs_offroad_request_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn abs_offroad_request(&self) -> AbsOffroadRequest2566834686 {
        AbsOffroadRequest2566834686::from(self.abs_offroad_request_raw_value() as u64)
    }

    /// Signal which indicates that the service brake demand value sent by the towing vehicle can be generated by one or two independent electrical braking circuit(s).
    #[allow(dead_code)]
    pub fn two_el_circuits_brake_demand_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn two_el_circuits_brake_demand(&self) -> TwoElCircuitsBrakeDemand2566834686 {
        TwoElCircuitsBrakeDemand2566834686::from(self.two_el_circuits_brake_demand_raw_value() as u64)
    }

    /// This signal indicates the active/passive state in all cases when the installed retarder is applied by the driver�s demand or by other systems (brakes).
    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active(&self) -> VehicleRetarderCtrlActive2566834686 {
        VehicleRetarderCtrlActive2566834686::from(self.vehicle_retarder_ctrl_active_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, electronic brake system #2/1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebs21 {
    frame_payload: Vec<u8>,
}

impl Ebs21 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebs21 {
        frame_payload.resize(8, 0);
        Ebs21 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebs21, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(402915070);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebs21::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Difference between the wheel speed at the right side and and the left side of the main axle.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn wheel_speed_diff_main_axle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// Actual torque of the retarder as negative percentage of maximum.
    /// Unit: %
    #[allow(dead_code)]
    pub fn actual_retarder_perc_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Actual speed of the vehicle (positive value for forward and backward speed) calculated as the average of the wheel speeds of one axle influenced by slip and filtered by a frequency range of 5 Hz to 20 Hz.
    /// Unit: km/
    #[allow(dead_code)]
    pub fn wheel_based_vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// Signal indicating the trailer is requesting to be braked by the commercial vehicle by means of bleeding the pneumatic supply line.
    #[allow(dead_code)]
    pub fn supply_line_braking_request_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn supply_line_braking_request(&self) -> SupplyLineBrakingRequest2550398718 {
        SupplyLineBrakingRequest2550398718::from(self.supply_line_braking_request_raw_value() as u64)
    }

    /// Signal which indicates that Vehicle Dynamic Control (VDC) is active/passive.
    #[allow(dead_code)]
    pub fn vdc_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vdc_active(&self) -> VdcActive2550398718 {
        VdcActive2550398718::from(self.vdc_active_raw_value() as u64)
    }

    /// Signal indicating the automatic towed vehicle braking is active/passive.
    #[allow(dead_code)]
    pub fn autom_towed_veh_break_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn autom_towed_veh_break_active(&self) -> AutomTowedVehBreakActive2550398718 {
        AutomTowedVehBreakActive2550398718::from(self.autom_towed_veh_break_active_raw_value() as u64)
    }

    /// Signal indicating the service brake of the towed vehicle is active/passive, by observing the brake pressure.
    #[allow(dead_code)]
    pub fn vehicle_service_brake_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_service_brake_active(&self) -> VehicleServiceBrakeActive2550398718 {
        VehicleServiceBrakeActive2550398718::from(self.vehicle_service_brake_active_raw_value() as u64)
    }

    /// This signal indicates the active/passive state in all cases when the installed retarder is applied by the driver�s demand or by other systems (brakes).
    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active(&self) -> VehicleRetarderCtrlActive2550398718 {
        VehicleRetarderCtrlActive2550398718::from(self.vehicle_retarder_ctrl_active_raw_value() as u64)
    }

    /// Signal indicating the ABS is active/passive.
    #[allow(dead_code)]
    pub fn vehicle_abs_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_abs_active(&self) -> VehicleAbsActive2550398718 {
        VehicleAbsActive2550398718::from(self.vehicle_abs_active_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, electronic brake system #2/2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebs22 {
    frame_payload: Vec<u8>,
}

impl Ebs22 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebs22 {
        frame_payload.resize(8, 0);
        Ebs22 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebs22, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419349758);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebs22::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter is the 100% reference value for all defined indicated retarder torque parameters.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn reference_retarder_torque_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Sum of the static vertical loads of the vehicle axles.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn axle_load_sum_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// Signal indicating the trailer is requesting to be braked by the commercial vehicle by means of bleeding the pneumatic supply line.
    #[allow(dead_code)]
    pub fn supply_line_braking_request_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn supply_line_braking_request(&self) -> SupplyLineBrakingRequest2566833406 {
        SupplyLineBrakingRequest2566833406::from(self.supply_line_braking_request_raw_value() as u64)
    }

    /// The parameter indicates whether the loading ramp approach assistance is activated.
    #[allow(dead_code)]
    pub fn loading_ramp_approach_assist_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn loading_ramp_approach_assist(&self) -> LoadingRampApproachAssist2566833406 {
        LoadingRampApproachAssist2566833406::from(self.loading_ramp_approach_assist_raw_value() as u64)
    }

    /// Signal indicating the vehicle spring brake is engaged.
    #[allow(dead_code)]
    pub fn spring_brake_engaged_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn spring_brake_engaged(&self) -> SpringBrakeEngaged2566833406 {
        SpringBrakeEngaged2566833406::from(self.spring_brake_engaged_raw_value() as u64)
    }

    /// Signal indicating the vehicle is equipped with an electrical load proportional function.
    #[allow(dead_code)]
    pub fn electr_load_prop_func_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn electr_load_prop_func(&self) -> ElectrLoadPropFunc2566833406 {
        ElectrLoadPropFunc2566833406::from(self.electr_load_prop_func_raw_value() as u64)
    }

    /// Signal indicating the vehicle has one or more axle(s) fitted with spring brakes.
    #[allow(dead_code)]
    pub fn spring_brake_installed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn spring_brake_installed(&self) -> SpringBrakeInstalled2566833406 {
        SpringBrakeInstalled2566833406::from(self.spring_brake_installed_raw_value() as u64)
    }

    /// Information to identify a dolly axle within the road train.
    #[allow(dead_code)]
    pub fn vehicle_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_type(&self) -> VehicleType2566833406 {
        VehicleType2566833406::from(self.vehicle_type_raw_value() as u64)
    }

    /// Signal which indicates the status of the supply of non-braking systems.
    #[allow(dead_code)]
    pub fn elec_supply_of_non_braking_sys_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn elec_supply_of_non_braking_sys(&self) -> ElecSupplyOfNonBrakingSys2566833406 {
        ElecSupplyOfNonBrakingSys2566833406::from(self.elec_supply_of_non_braking_sys_raw_value() as u64)
    }

    /// Request from the towed vehicle to the commercial vehicle to activate the amber warning signal on the commercial vehicle.
    #[allow(dead_code)]
    pub fn amber_warning_signal_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_signal_req(&self) -> AmberWarningSignalReq2566833406 {
        AmberWarningSignalReq2566833406::from(self.amber_warning_signal_req_raw_value() as u64)
    }

    /// Request from the towed vehicle to the commercial vehicle to activate the red warning signal on the commercial vehicle, which indicates certain specified failures within the braking equipment of the towed vehicles.
    #[allow(dead_code)]
    pub fn red_warning_signal_request_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_warning_signal_request(&self) -> RedWarningSignalRequest2566833406 {
        RedWarningSignalRequest2566833406::from(self.red_warning_signal_request_raw_value() as u64)
    }

    /// Signal indicating the actual supply voltage is sufficient/insufficient for proper brake function (including over voltage).
    #[allow(dead_code)]
    pub fn vehicle_electr_supply_suff_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_electr_supply_suff(&self) -> VehicleElectrSupplySuff2566833406 {
        VehicleElectrSupplySuff2566833406::from(self.vehicle_electr_supply_suff_raw_value() as u64)
    }

    /// Signal indicating the automatic towed vehicle braking is active/passive.
    #[allow(dead_code)]
    pub fn autom_towed_veh_break_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn autom_towed_veh_break_active(&self) -> AutomTowedVehBreakActive2566833406 {
        AutomTowedVehBreakActive2566833406::from(self.autom_towed_veh_break_active_raw_value() as u64)
    }

    /// Signal indicating the service brake of the towed vehicle is active/passive, by observing the brake pressure.
    #[allow(dead_code)]
    pub fn vehicle_service_brake_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_service_brake_active(&self) -> VehicleServiceBrakeActive2566833406 {
        VehicleServiceBrakeActive2566833406::from(self.vehicle_service_brake_active_raw_value() as u64)
    }

    /// This signal indicates the active/passive state in all cases when the installed retarder is applied by the driver�s demand or by other systems (brakes).
    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_retarder_ctrl_active(&self) -> VehicleRetarderCtrlActive2566833406 {
        VehicleRetarderCtrlActive2566833406::from(self.vehicle_retarder_ctrl_active_raw_value() as u64)
    }

    /// Signal indicating the ABS is active/passive.
    #[allow(dead_code)]
    pub fn vehicle_abs_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_abs_active(&self) -> VehicleAbsActive2566833406 {
        VehicleAbsActive2566833406::from(self.vehicle_abs_active_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, electronic brake system #2/3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebs23 {
    frame_payload: Vec<u8>,
}

impl Ebs23 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebs23 {
        frame_payload.resize(8, 0);
        Ebs23 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebs23, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218023678);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebs23::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Actual supply pressure of the reservoir of the braking system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn pneumatic_supply_pressure_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// Actual brake temperature.
    /// Unit: �C
    #[allow(dead_code)]
    pub fn brake_temperature_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 10.000000).round() as u8
    }

    /// Actual relative value of brake lining of a specific brake.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brake_lining_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Actual tyre pressure without corrections.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn tyre_pressure_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 10.000000).round() as u8
    }

    /// Second part of identification number of the tyre or wheel (the number of axles).
    #[allow(dead_code)]
    pub fn tyre_wheel_ident_temp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_ident_temp2(&self) -> TyreWheelIdentTemp22365507326 {
        TyreWheelIdentTemp22365507326::from(self.tyre_wheel_ident_temp2_raw_value() as u64)
    }

    /// First part of identification number of the tyre or wheel (position on each axle).
    #[allow(dead_code)]
    pub fn tyre_wheel_ident_temp1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_ident_temp1(&self) -> TyreWheelIdentTemp12365507326 {
        TyreWheelIdentTemp12365507326::from(self.tyre_wheel_ident_temp1_raw_value() as u64)
    }

    /// Second part of identification number of the tyre or wheel (the number of axles).
    #[allow(dead_code)]
    pub fn tyre_wheel_ident_pressure2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_ident_pressure2(&self) -> TyreWheelIdentPressure22365507326 {
        TyreWheelIdentPressure22365507326::from(self.tyre_wheel_ident_pressure2_raw_value() as u64)
    }

    /// First part of identification number of the tyre or wheel (position on each axle).
    #[allow(dead_code)]
    pub fn tyre_wheel_ident_pressure1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_ident_pressure1(&self) -> TyreWheelIdentPressure12365507326 {
        TyreWheelIdentPressure12365507326::from(self.tyre_wheel_ident_pressure1_raw_value() as u64)
    }

    /// Second part of identification number of the tyre or wheel (the number of axles).
    #[allow(dead_code)]
    pub fn tyre_wheel_ident_lining2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_ident_lining2(&self) -> TyreWheelIdentLining22365507326 {
        TyreWheelIdentLining22365507326::from(self.tyre_wheel_ident_lining2_raw_value() as u64)
    }

    /// First part of identification number of the tyre or wheel (position on each axle).
    #[allow(dead_code)]
    pub fn tyre_wheel_ident_lining1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_ident_lining1(&self) -> TyreWheelIdentLining12365507326 {
        TyreWheelIdentLining12365507326::from(self.tyre_wheel_ident_lining1_raw_value() as u64)
    }

    /// Signal indicating the actual supply pressure of the reservoir of the braking system is insufficient or sufficient.
    #[allow(dead_code)]
    pub fn vehicle_pneum_supply_suff_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_pneum_supply_suff(&self) -> VehiclePneumSupplySuff2365507326 {
        VehiclePneumSupplySuff2365507326::from(self.vehicle_pneum_supply_suff_raw_value() as u64)
    }

    /// Signal which indicates that the brake temperature is higher than a specific level.
    #[allow(dead_code)]
    pub fn brake_temperature_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn brake_temperature_status(&self) -> BrakeTemperatureStatus2365507326 {
        BrakeTemperatureStatus2365507326::from(self.brake_temperature_status_raw_value() as u64)
    }

    /// Signal which indicates that the brake lining is sufficient/insufficient.
    #[allow(dead_code)]
    pub fn brake_lining_sufficient_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn brake_lining_sufficient(&self) -> BrakeLiningSufficient2365507326 {
        BrakeLiningSufficient2365507326::from(self.brake_lining_sufficient_raw_value() as u64)
    }

    /// Signal which indicates that the tyre pressure is insufficient
    #[allow(dead_code)]
    pub fn tyre_pressure_sufficient_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_pressure_sufficient(&self) -> TyrePressureSufficient2365507326 {
        TyrePressureSufficient2365507326::from(self.tyre_pressure_sufficient_raw_value() as u64)
    }
}

/// ISO 11992: Towing vehicle message, general purpose message #1/1
/// 
/// GPM 11 replaces GFM 11 in ISO 11992:1998 part 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm11 {
    frame_payload: Vec<u8>,
}

impl Gpm11 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm11 {
        frame_payload.resize(8, 0);
        Gpm11 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm11, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417529598);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm11::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Command signal to switch on or off the obstacle detection device (ODD).
    #[allow(dead_code)]
    pub fn odd_request_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn odd_request(&self) -> OddRequest2565013246 {
        OddRequest2565013246::from(self.odd_request_raw_value() as u64)
    }

    /// Command signal to activate the anti-theft device.
    #[allow(dead_code)]
    pub fn anti_theft_device_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn anti_theft_device_req(&self) -> AntiTheftDeviceReq2565013246 {
        AntiTheftDeviceReq2565013246::from(self.anti_theft_device_req_raw_value() as u64)
    }

    /// Information to identify a dolly axle within the road train.
    #[allow(dead_code)]
    pub fn vehicle_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_type(&self) -> VehicleType2565013246 {
        VehicleType2565013246::from(self.vehicle_type_raw_value() as u64)
    }
}

/// ISO 11992: Towing vehicle message, general purpose message #1/2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm12 {
    frame_payload: Vec<u8>,
}

impl Gpm12 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm12 {
        frame_payload.resize(8, 0);
        Gpm12 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm12, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419323390);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm12::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Maximum vehicle velocity allowed.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// The engine speed which cannot be exceeded.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn engine_speed_upper_limit_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The minimum engine speed which the engine is allowed to reach.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn engine_speed_lower_limit_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }
}

/// ISO 11992: Towing vehicle message, general purpose message #1/3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm13 {
    frame_payload: Vec<u8>,
}

impl Gpm13 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm13 {
        frame_payload.resize(8, 0);
        Gpm13 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm13, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217997310);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm13::new(frame.data().to_vec())));
        Ok(f)
    }

    /// State signal which indicates which engine torque mode is currently generating, limiting, or controlling the torque
    #[allow(dead_code)]
    pub fn engine_torque_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_torque_mode(&self) -> EngineTorqueMode2365480958 {
        EngineTorqueMode2365480958::from(self.engine_torque_mode_raw_value() as u64)
    }

    /// Read VehicleSpeed signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// The ratio of actual engine percent torque to maximum indicated torque available at the current engine speed, clipped to zero torque during engine braking.
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_load_at_current_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Actual engine speed which is calculated over a minimum crankshaft angle of 720 degrees divided by
    /// the number of cylinders.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn engine_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The calculated output torque of the engine.
    /// Unit: %
    #[allow(dead_code)]
    pub fn actual_engine_perc_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// The torque output of the engine requested by the driver.
    /// Unit: %
    #[allow(dead_code)]
    pub fn drivers_demand_engine_perc_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Signal which indicates whether the engine is running.
    #[allow(dead_code)]
    pub fn engine_running_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_running(&self) -> EngineRunning2365480958 {
        EngineRunning2365480958::from(self.engine_running_raw_value() as u64)
    }

    /// Switch signal which indicates that engine control is allowed.
    #[allow(dead_code)]
    pub fn engine_control_allowed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_control_allowed(&self) -> EngineControlAllowed2365480958 {
        EngineControlAllowed2365480958::from(self.engine_control_allowed_raw_value() as u64)
    }
}

/// ISO 11992: Towing vehicle message, general purpose message #1/4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm14 {
    frame_payload: Vec<u8>,
}

impl Gpm14 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm14 {
        frame_payload.resize(8, 0);
        Gpm14 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm14, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419324414);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm14::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates the current state of the clutch independent power take off.
    #[allow(dead_code)]
    pub fn clutch_indptd_pto_feedback_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn clutch_indptd_pto_feedback(&self) -> ClutchIndptdPtoFeedback2566808062 {
        ClutchIndptdPtoFeedback2566808062::from(self.clutch_indptd_pto_feedback_raw_value() as u64)
    }

    /// The ratio of actual accelerator pedal position to maximum pedal position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn accel_pedal_position_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Switch signal which indicates whether the accelerator pedal low idle switch is opened or closed.
    #[allow(dead_code)]
    pub fn accel_pedal_low_idle_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn accel_pedal_low_idle_switch(&self) -> AccelPedalLowIdleSwitch2566808062 {
        AccelPedalLowIdleSwitch2566808062::from(self.accel_pedal_low_idle_switch_raw_value() as u64)
    }

    /// Signal which indicates whether the starter is in use.
    #[allow(dead_code)]
    pub fn starter_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn starter_active(&self) -> StarterActive2566808062 {
        StarterActive2566808062::from(self.starter_active_raw_value() as u64)
    }

    /// Temperature of the torque converter lubricant.
    /// Unit: �C
    #[allow(dead_code)]
    pub fn torque_conv_oil_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Signal which indicates that the torque converter oil temperature has reached its warning level.
    #[allow(dead_code)]
    pub fn torque_convt_oil_temp_warning_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn torque_convt_oil_temp_warning(&self) -> TorqueConvtOilTempWarning2566808062 {
        TorqueConvtOilTempWarning2566808062::from(self.torque_convt_oil_temp_warning_raw_value() as u64)
    }

    /// Switch signal which indicates that PTO control is allowed.
    #[allow(dead_code)]
    pub fn pto_control_allowed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pto_control_allowed(&self) -> PtoControlAllowed2566808062 {
        PtoControlAllowed2566808062::from(self.pto_control_allowed_raw_value() as u64)
    }

    /// Signal which indicates the current state of the second engine mounted power take off.
    #[allow(dead_code)]
    pub fn sec_engine_mtd_pto_feedback_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sec_engine_mtd_pto_feedback(&self) -> SecEngineMtdPtoFeedback2566808062 {
        SecEngineMtdPtoFeedback2566808062::from(self.sec_engine_mtd_pto_feedback_raw_value() as u64)
    }

    /// Signal which indicates the current state of the first engine mounted power take off.
    #[allow(dead_code)]
    pub fn first_engine_mtd_pto_feedback_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn first_engine_mtd_pto_feedback(&self) -> FirstEngineMtdPtoFeedback2566808062 {
        FirstEngineMtdPtoFeedback2566808062::from(self.first_engine_mtd_pto_feedback_raw_value() as u64)
    }

    /// Signal which indicates the current state of the second clutch dependent power take off.
    #[allow(dead_code)]
    pub fn sec_clutch_dptd_pto_feedback_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sec_clutch_dptd_pto_feedback(&self) -> SecClutchDptdPtoFeedback2566808062 {
        SecClutchDptdPtoFeedback2566808062::from(self.sec_clutch_dptd_pto_feedback_raw_value() as u64)
    }

    /// Signal which indicates the current state of the first clutch dependent power take off.
    #[allow(dead_code)]
    pub fn first_clutch_dpdt_pto_feedback_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn first_clutch_dpdt_pto_feedback(&self) -> FirstClutchDpdtPtoFeedback2566808062 {
        FirstClutchDpdtPtoFeedback2566808062::from(self.first_clutch_dpdt_pto_feedback_raw_value() as u64)
    }

    /// The gear currently engaged in the transmission or the last gear engaged while the transmission is in process of shifting to the new or selected gear.
    #[allow(dead_code)]
    pub fn current_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Parameter which represents the ratio of input shaft speed to current engine speed (in percent).
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_clutch_slip_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// ISO 11992: Towing vehicle message, general purpose message #1/5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm15 {
    frame_payload: Vec<u8>,
}

impl Gpm15 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm15 {
        frame_payload.resize(8, 0);
        Gpm15 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm15, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419324926);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm15::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The 100 % reference value for all defined indicated engine torque parameters.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn reference_engine_torque_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF)) as u16
    }

    /// This signal indicates the decrease of the fuel level to a certain minimum.
    #[allow(dead_code)]
    pub fn fuel_level_warning_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fuel_level_warning(&self) -> FuelLevelWarning2566808574 {
        FuelLevelWarning2566808574::from(self.fuel_level_warning_raw_value() as u64)
    }

    /// Signal which indicates that the engine oil pressure has reached its warning level.
    #[allow(dead_code)]
    pub fn engine_oil_pressure_warning_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_oil_pressure_warning(&self) -> EngineOilPressureWarning2566808574 {
        EngineOilPressureWarning2566808574::from(self.engine_oil_pressure_warning_raw_value() as u64)
    }

    /// Signal which indicates that the engine coolant temperature has reached its warning level.
    #[allow(dead_code)]
    pub fn engine_coolant_temp_warning_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_coolant_temp_warning(&self) -> EngineCoolantTempWarning2566808574 {
        EngineCoolantTempWarning2566808574::from(self.engine_coolant_temp_warning_raw_value() as u64)
    }

    /// Gauge pressure of the oil in the engine lubrication system as provided by the oil pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn engine_oil_pressure_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Read EngineCoolantTemperature signal from can frame
    /// Unit: �C
    #[allow(dead_code)]
    pub fn engine_coolant_temperature_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Temperature of the engine lubricant.
    /// Unit: �C
    #[allow(dead_code)]
    pub fn engine_oil_temperature_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// ISO 11992: Towing vehicle message, general purpose message #1/6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm16 {
    frame_payload: Vec<u8>,
}

impl Gpm16 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm16 {
        frame_payload.resize(8, 0);
        Gpm16 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm16, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419325438);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm16::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of air surrounding vehicle.
    /// Unit: �C
    #[allow(dead_code)]
    pub fn ambient_air_temperature_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// ISO 11992: Towed vehicle message, general purpose message #2/1
/// 
/// GPM 21 replaces GFM 21 in ISO 11992:1998 part 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm21 {
    frame_payload: Vec<u8>,
}

impl Gpm21 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm21 {
        frame_payload.resize(8, 0);
        Gpm21 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm21, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417464062);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm21::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Information to identify a dolly axle within the road train.
    #[allow(dead_code)]
    pub fn vehicle_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_type(&self) -> VehicleType2564947710 {
        VehicleType2564947710::from(self.vehicle_type_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, general purpose message #2/2
/// 
/// GPM22 replaces GFM 24 in ISO 11992:1998 part 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm22 {
    frame_payload: Vec<u8>,
}

impl Gpm22 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm22 {
        frame_payload.resize(8, 0);
        Gpm22 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm22, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419350782);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm22::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The actual pressure in a body on the towed vehicle.
    /// Unit: bar
    #[allow(dead_code)]
    pub fn body_pressure_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.100000).round() as u8
    }

    /// The actual fluid level in a body on the towed vehicle.
    /// Unit: l
    #[allow(dead_code)]
    pub fn body_fluid_level_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// The actual temperature in a thermal body on the towed vehicle.
    /// Unit: �C
    #[allow(dead_code)]
    pub fn thermal_body_temperature_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// The actual distance between the back of the towed vehicle and any obstacle.
    /// Unit: cm
    #[allow(dead_code)]
    pub fn rear_obstacle_distance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Signal which indicates that the anti-theft device is switched on or off.
    #[allow(dead_code)]
    pub fn anti_theft_device_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn anti_theft_device_status(&self) -> AntiTheftDeviceStatus2566834430 {
        AntiTheftDeviceStatus2566834430::from(self.anti_theft_device_status_raw_value() as u64)
    }

    /// Signal which indicates that an obstacle detection device (ODD) is active/inactive.
    #[allow(dead_code)]
    pub fn odd_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn odd_status(&self) -> OddStatus2566834430 {
        OddStatus2566834430::from(self.odd_status_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, general purpose message #2/3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm23 {
    frame_payload: Vec<u8>,
}

impl Gpm23 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm23 {
        frame_payload.resize(8, 0);
        Gpm23 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm23, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217997566);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm23::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The requested engine speed which is not to be exceeded.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn req_engine_speed_upper_lim_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The requested minimum engine speed which the engine is to allow.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn req_engine_speed_lower_lim_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The requested engine torque that the engine is not allowed to exceed, indicated as a ratio of the reference engine torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn req_engine_torque_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// The requested vehicle speed which the vehicle is not allowed to exceed.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn req_engine_speed_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// This is the engine speed which the engine is expected to operate at.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn req_engine_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.125000).round() as u16
    }
}

/// ISO 11992: Towed vehicle message, general purpose message #2/4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm24 {
    frame_payload: Vec<u8>,
}

impl Gpm24 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm24 {
        frame_payload.resize(8, 0);
        Gpm24 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm24, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419324670);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm24::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates the state of the second engine mounted power take off switch.
    #[allow(dead_code)]
    pub fn sec_engine_mtd_pto_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sec_engine_mtd_pto_switch(&self) -> SecEngineMtdPtoSwitch2566808318 {
        SecEngineMtdPtoSwitch2566808318::from(self.sec_engine_mtd_pto_switch_raw_value() as u64)
    }

    /// Signal which indicates the state of the second clutch dependent power take off switch.
    #[allow(dead_code)]
    pub fn sec_clutch_dpdt_pto_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sec_clutch_dpdt_pto_switch(&self) -> SecClutchDpdtPtoSwitch2566808318 {
        SecClutchDpdtPtoSwitch2566808318::from(self.sec_clutch_dpdt_pto_switch_raw_value() as u64)
    }

    /// Signal which indicates the state of the first clutch dependent power take off switch.
    #[allow(dead_code)]
    pub fn first_clutch_dpdt_pto_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn first_clutch_dpdt_pto_switch(&self) -> FirstClutchDpdtPtoSwitch2566808318 {
        FirstClutchDpdtPtoSwitch2566808318::from(self.first_clutch_dpdt_pto_switch_raw_value() as u64)
    }

    /// Signal which indicates that the operating panel is active.
    #[allow(dead_code)]
    pub fn operating_panel_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn operating_panel_active(&self) -> OperatingPanelActive2566808318 {
        OperatingPanelActive2566808318::from(self.operating_panel_active_raw_value() as u64)
    }

    /// Signal which indicates the state of the refuse packer step switch.
    #[allow(dead_code)]
    pub fn refuse_packer_step_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn refuse_packer_step_switch(&self) -> RefusePackerStepSwitch2566808318 {
        RefusePackerStepSwitch2566808318::from(self.refuse_packer_step_switch_raw_value() as u64)
    }

    /// Signal which indicates the state of the engine stop switch.
    #[allow(dead_code)]
    pub fn engine_stop_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_stop_switch(&self) -> EngineStopSwitch2566808318 {
        EngineStopSwitch2566808318::from(self.engine_stop_switch_raw_value() as u64)
    }

    /// Signal which indicates the state of the engine start switch.
    #[allow(dead_code)]
    pub fn engine_start_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn engine_start_switch(&self) -> EngineStartSwitch2566808318 {
        EngineStartSwitch2566808318::from(self.engine_start_switch_raw_value() as u64)
    }

    /// Signal which indicates the state of the starter lockout switch.
    #[allow(dead_code)]
    pub fn starter_lockout_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn starter_lockout_switch(&self) -> StarterLockoutSwitch2566808318 {
        StarterLockoutSwitch2566808318::from(self.starter_lockout_switch_raw_value() as u64)
    }

    /// Command signal to influence the clutch.
    /// Unit: %
    #[allow(dead_code)]
    pub fn rqsted_percent_clutch_slip_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Signal which indicates the state of the first engine mounted power take off switch.
    #[allow(dead_code)]
    pub fn first_engine_mtd_pto_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn first_engine_mtd_pto_switch(&self) -> FirstEngineMtdPtoSwitch2566808318 {
        FirstEngineMtdPtoSwitch2566808318::from(self.first_engine_mtd_pto_switch_raw_value() as u64)
    }

    /// Signal which indicates the state of the clutch independent power take off switch.
    #[allow(dead_code)]
    pub fn clutch_indpdt_pto_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn clutch_indpdt_pto_switch(&self) -> ClutchIndpdtPtoSwitch2566808318 {
        ClutchIndpdtPtoSwitch2566808318::from(self.clutch_indpdt_pto_switch_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, general purpose message #2/5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpm25 {
    frame_payload: Vec<u8>,
}

impl Gpm25 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpm25 {
        frame_payload.resize(8, 0);
        Gpm25 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpm25, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419325182);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpm25::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This signal indicates the state of the trailer left-hand side marker light(s).
    #[allow(dead_code)]
    pub fn trailer_left_side_marker_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_side_marker_light(&self) -> TrailerLeftSideMarkerLight2566808830 {
        TrailerLeftSideMarkerLight2566808830::from(self.trailer_left_side_marker_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand reversing light(s).
    #[allow(dead_code)]
    pub fn trailer_left_reversing_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_reversing_light(&self) -> TrailerLeftReversingLight2566808830 {
        TrailerLeftReversingLight2566808830::from(self.trailer_left_reversing_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand rear width indicator light(s).
    #[allow(dead_code)]
    pub fn trailer_left_rear_wid_ind_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_rear_wid_ind_light(&self) -> TrailerLeftRearWidIndLight2566808830 {
        TrailerLeftRearWidIndLight2566808830::from(self.trailer_left_rear_wid_ind_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand rear registration-plate light(s).
    #[allow(dead_code)]
    pub fn trailer_left_rear_reg_plt_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_rear_reg_plt_light(&self) -> TrailerLeftRearRegPltLight2566808830 {
        TrailerLeftRearRegPltLight2566808830::from(self.trailer_left_rear_reg_plt_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand rear light(s).
    #[allow(dead_code)]
    pub fn trailer_left_rear_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_rear_light(&self) -> TrailerLeftRearLight2566808830 {
        TrailerLeftRearLight2566808830::from(self.trailer_left_rear_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand rear fog light(s).
    #[allow(dead_code)]
    pub fn trailer_left_rear_fog_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_rear_fog_light(&self) -> TrailerLeftRearFogLight2566808830 {
        TrailerLeftRearFogLight2566808830::from(self.trailer_left_rear_fog_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand direction indicator light(s).
    #[allow(dead_code)]
    pub fn trailer_left_dir_ind_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_dir_ind_light(&self) -> TrailerLeftDirIndLight2566808830 {
        TrailerLeftDirIndLight2566808830::from(self.trailer_left_dir_ind_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand corner marker light(s).
    #[allow(dead_code)]
    pub fn trailer_left_crn_marker_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_crn_marker_light(&self) -> TrailerLeftCrnMarkerLight2566808830 {
        TrailerLeftCrnMarkerLight2566808830::from(self.trailer_left_crn_marker_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer interior light(s).
    #[allow(dead_code)]
    pub fn trailer_interior_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_interior_light(&self) -> TrailerInteriorLight2566808830 {
        TrailerInteriorLight2566808830::from(self.trailer_interior_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer work lamp(s).
    #[allow(dead_code)]
    pub fn trailer_work_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_work_lamp(&self) -> TrailerWorkLamp2566808830 {
        TrailerWorkLamp2566808830::from(self.trailer_work_lamp_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer rotating identification light(s).
    #[allow(dead_code)]
    pub fn trailer_rotating_ident_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_rotating_ident_light(&self) -> TrailerRotatingIdentLight2566808830 {
        TrailerRotatingIdentLight2566808830::from(self.trailer_rotating_ident_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand stop light(s).
    #[allow(dead_code)]
    pub fn trailer_right_stop_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_stop_light(&self) -> TrailerRightStopLight2566808830 {
        TrailerRightStopLight2566808830::from(self.trailer_right_stop_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand side marker light(s).
    #[allow(dead_code)]
    pub fn trailer_right_side_mrk_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_side_mrk_light(&self) -> TrailerRightSideMrkLight2566808830 {
        TrailerRightSideMrkLight2566808830::from(self.trailer_right_side_mrk_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand reversing light(s).
    #[allow(dead_code)]
    pub fn trailer_right_reversing_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_reversing_light(&self) -> TrailerRightReversingLight2566808830 {
        TrailerRightReversingLight2566808830::from(self.trailer_right_reversing_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand rear width indicator light(s).
    #[allow(dead_code)]
    pub fn trail_right_rear_wid_ind_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trail_right_rear_wid_ind_light(&self) -> TrailRightRearWidIndLight2566808830 {
        TrailRightRearWidIndLight2566808830::from(self.trail_right_rear_wid_ind_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand rear registration-plate light(s).
    #[allow(dead_code)]
    pub fn trailer_right_rear_reg_plt_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_rear_reg_plt_light(&self) -> TrailerRightRearRegPltLight2566808830 {
        TrailerRightRearRegPltLight2566808830::from(self.trailer_right_rear_reg_plt_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand rear light(s).
    #[allow(dead_code)]
    pub fn trailer_right_rear_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_rear_light(&self) -> TrailerRightRearLight2566808830 {
        TrailerRightRearLight2566808830::from(self.trailer_right_rear_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand rear fog light(s).
    #[allow(dead_code)]
    pub fn trailer_right_rear_fog_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_rear_fog_light(&self) -> TrailerRightRearFogLight2566808830 {
        TrailerRightRearFogLight2566808830::from(self.trailer_right_rear_fog_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand direction indicator light(s).
    #[allow(dead_code)]
    pub fn trailer_right_dir_ind_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_dir_ind_light(&self) -> TrailerRightDirIndLight2566808830 {
        TrailerRightDirIndLight2566808830::from(self.trailer_right_dir_ind_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer right-hand corner marker light(s).
    #[allow(dead_code)]
    pub fn trailer_right_crn_marker_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_right_crn_marker_light(&self) -> TrailerRightCrnMarkerLight2566808830 {
        TrailerRightCrnMarkerLight2566808830::from(self.trailer_right_crn_marker_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer rear warning light(s).
    #[allow(dead_code)]
    pub fn trailer_rear_warning_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_rear_warning_light(&self) -> TrailerRearWarningLight2566808830 {
        TrailerRearWarningLight2566808830::from(self.trailer_rear_warning_light_raw_value() as u64)
    }

    /// This signal indicates the state of the trailer left-hand stop light(s).
    #[allow(dead_code)]
    pub fn trailer_left_stop_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_left_stop_light(&self) -> TrailerLeftStopLight2566808830 {
        TrailerLeftStopLight2566808830::from(self.trailer_left_stop_light_raw_value() as u64)
    }
}

/// Reserved for ISO 15765
#[allow(dead_code)]
#[derive(Debug)]
pub struct Iso15765Funct {
    frame_payload: Vec<u8>,
}

impl Iso15765Funct {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Iso15765Funct {
        frame_payload.resize(8, 0);
        Iso15765Funct { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Iso15765Funct, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417070846);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Iso15765Funct::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Reserved for ISO 15765
#[allow(dead_code)]
#[derive(Debug)]
pub struct Iso15765Phys {
    frame_payload: Vec<u8>,
}

impl Iso15765Phys {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Iso15765Phys {
        frame_payload.resize(8, 0);
        Iso15765Phys { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Iso15765Phys, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417005310);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Iso15765Phys::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Used to access network interconnection ECU parametrics and database
#[allow(dead_code)]
#[derive(Debug)]
pub struct Network {
    frame_payload: Vec<u8>,
}

impl Network {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Network {
        frame_payload.resize(8, 0);
        Network { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Network, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418250494);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Network::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ControlByte signal from can frame
    #[allow(dead_code)]
    pub fn control_byte_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn control_byte(&self) -> ControlByte2565734142 {
        ControlByte2565734142::from(self.control_byte_raw_value() as u64)
    }

    /// Filter mode for Network PG
    #[allow(dead_code)]
    pub fn filter_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn filter_mode(&self) -> FilterMode2565734142 {
        FilterMode2565734142::from(self.filter_mode_raw_value() as u64)
    }

    /// Destination port for network PG
    #[allow(dead_code)]
    pub fn to_port_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    /// Source port for Network PG
    #[allow(dead_code)]
    pub fn from_port_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }
}

/// ISO 11992: Towing vehicle message, running gear equipment #1/1
/// 
/// RGE11 replaces GFM 12 in ISO 11992:1998 part 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rge11 {
    frame_payload: Vec<u8>,
}

impl Rge11 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rge11 {
        frame_payload.resize(8, 0);
        Rge11 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rge11, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417660670);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rge11::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The pneumatic pressure in the circuit or reservoir for the parking brake and the trailer supply.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn parking_and_trailer_air_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Actual static vertical load on driven axle of the commercial vehicle. In case of more than one driven axle the value of the axle with the highest vertical load is transmitted.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn driven_axle_load_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// The pneumatic pressure in the auxiliary circuit.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_equip_supply_pressure_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Command signal to stop immediately any change of the actual body height level.
    #[allow(dead_code)]
    pub fn stop_level_change_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn stop_level_change_req(&self) -> StopLevelChangeReq2565144318 {
        StopLevelChangeReq2565144318::from(self.stop_level_change_req_raw_value() as u64)
    }

    /// Command signal to store the actual body height level as new programmed and memorised ramp levels 1 or 2 in the ECU
    #[allow(dead_code)]
    pub fn ramp_level_storage_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ramp_level_storage_req(&self) -> RampLevelStorageReq2565144318 {
        RampLevelStorageReq2565144318::from(self.ramp_level_storage_req_raw_value() as u64)
    }

    /// Command signal to enable or disable the automatic level control.
    #[allow(dead_code)]
    pub fn level_control_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_control_req(&self) -> LevelControlReq2565144318 {
        LevelControlReq2565144318::from(self.level_control_req_raw_value() as u64)
    }

    /// Command signal to control the body height to a level programmed and memorised in the ECU.
    #[allow(dead_code)]
    pub fn ramp_level_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ramp_level_req(&self) -> RampLevelReq2565144318 {
        RampLevelReq2565144318::from(self.ramp_level_req_raw_value() as u64)
    }

    /// Command signal to lock the steering axle.
    #[allow(dead_code)]
    pub fn steering_axle_locking_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn steering_axle_locking_req(&self) -> SteeringAxleLockingReq2565144318 {
        SteeringAxleLockingReq2565144318::from(self.steering_axle_locking_req_raw_value() as u64)
    }

    /// Command signal to control the lift axle position / tag axle load condition.
    #[allow(dead_code)]
    pub fn lift_axle2_position_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle2_position_req(&self) -> LiftAxle2PositionReq2565144318 {
        LiftAxle2PositionReq2565144318::from(self.lift_axle2_position_req_raw_value() as u64)
    }

    /// Command signal to control the lift axle position / tag axle load condition.
    #[allow(dead_code)]
    pub fn lift_axle1_position_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle1_position_req(&self) -> LiftAxle1PositionReq2565144318 {
        LiftAxle1PositionReq2565144318::from(self.lift_axle1_position_req_raw_value() as u64)
    }

    /// Command signal to control the lift axle position / tag axle load condition to transfer more load on the driven axle of the commercial vehicle.
    #[allow(dead_code)]
    pub fn traction_help_req_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn traction_help_req(&self) -> TractionHelpReq2565144318 {
        TractionHelpReq2565144318::from(self.traction_help_req_raw_value() as u64)
    }

    /// Command signal to control the body height [up (lifting)/down (lowering)] for the rear axle.
    #[allow(dead_code)]
    pub fn level_change_req_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_change_req_rear_axle(&self) -> LevelChangeReqRearAxle2565144318 {
        LevelChangeReqRearAxle2565144318::from(self.level_change_req_rear_axle_raw_value() as u64)
    }

    /// Command signal to control the body height [up (lifting)/down (lowering)] for the front axle.
    #[allow(dead_code)]
    pub fn level_change_req_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_change_req_front_axle(&self) -> LevelChangeReqFrontAxle2565144318 {
        LevelChangeReqFrontAxle2565144318::from(self.level_change_req_front_axle_raw_value() as u64)
    }

    /// Command signal to activate a normal ride body height. The normal levels 1 and 2 are trailer specific body heights.
    #[allow(dead_code)]
    pub fn ride_height_request_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ride_height_request(&self) -> RideHeightRequest2565144318 {
        RideHeightRequest2565144318::from(self.ride_height_request_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, running gear equipment #2/1
/// 
/// RGE21 replaces GFM 22 in ISO 11992:1998 part 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rge21 {
    frame_payload: Vec<u8>,
}

impl Rge21 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rge21 {
        frame_payload.resize(8, 0);
        Rge21 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rge21, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417726206);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rge21::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates that the automatic level control is enabled or disabled.
    #[allow(dead_code)]
    pub fn level_control_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_control(&self) -> LevelControl2565209854 {
        LevelControl2565209854::from(self.level_control_raw_value() as u64)
    }

    /// Actual nominal vehicle body height.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn nominal_veh_body_level_rear_axle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Actual nominal vehicle body height.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn nominal_veh_body_level_front_axle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Signal which indicates the level of the body height as an anser to 'ramp level request'.
    #[allow(dead_code)]
    pub fn ramp_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ramp_level(&self) -> RampLevel2565209854 {
        RampLevel2565209854::from(self.ramp_level_raw_value() as u64)
    }

    /// Signal which indicates the normal levels of the vehicle independently of a specific request.
    #[allow(dead_code)]
    pub fn normal_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn normal_level(&self) -> NormalLevel2565209854 {
        NormalLevel2565209854::from(self.normal_level_raw_value() as u64)
    }

    /// Signal which indicates the stop of any level change due to a 'stop request'.
    #[allow(dead_code)]
    pub fn stop_level_change_acknowledge_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn stop_level_change_acknowledge(&self) -> StopLevelChangeAcknowledge2565209854 {
        StopLevelChangeAcknowledge2565209854::from(self.stop_level_change_acknowledge_raw_value() as u64)
    }

    /// Signal which indicates the level change of the body height at the rear axle due to any external requests.
    #[allow(dead_code)]
    pub fn level_change_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_change_rear_axle(&self) -> LevelChangeRearAxle2565209854 {
        LevelChangeRearAxle2565209854::from(self.level_change_rear_axle_raw_value() as u64)
    }

    /// Signal which indicates the level change of the body height at the front axle due to any external requests.
    #[allow(dead_code)]
    pub fn level_change_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_change_front_axle(&self) -> LevelChangeFrontAxle2565209854 {
        LevelChangeFrontAxle2565209854::from(self.level_change_front_axle_raw_value() as u64)
    }

    /// Signal which indicates the storage of a new ramp level in the ECU.
    #[allow(dead_code)]
    pub fn ramp_level_storage_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ramp_level_storage(&self) -> RampLevelStorage2565209854 {
        RampLevelStorage2565209854::from(self.ramp_level_storage_raw_value() as u64)
    }

    /// Signal which indicates the actual steering axle locking status.
    #[allow(dead_code)]
    pub fn steering_axle_locking_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn steering_axle_locking(&self) -> SteeringAxleLocking2565209854 {
        SteeringAxleLocking2565209854::from(self.steering_axle_locking_raw_value() as u64)
    }

    /// Signal which indicates the position / load condition of lift axle / tag axle #2.
    #[allow(dead_code)]
    pub fn lift_axle2_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle2_pos(&self) -> LiftAxle2Pos2565209854 {
        LiftAxle2Pos2565209854::from(self.lift_axle2_pos_raw_value() as u64)
    }

    /// Signal which indicates the position / load condition of lift axle / tag axle #1.
    #[allow(dead_code)]
    pub fn lift_axle1_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle1_pos(&self) -> LiftAxle1Pos2565209854 {
        LiftAxle1Pos2565209854::from(self.lift_axle1_pos_raw_value() as u64)
    }

    /// Signal which indicates the ramp level positions of the vehicle independently of a specific request.
    #[allow(dead_code)]
    pub fn ramp_level_position_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ramp_level_position(&self) -> RampLevelPosition2565209854 {
        RampLevelPosition2565209854::from(self.ramp_level_position_raw_value() as u64)
    }

    /// Signal which indicates that a load transfer is active.
    #[allow(dead_code)]
    pub fn traction_help_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn traction_help(&self) -> TractionHelp2565209854 {
        TractionHelp2565209854::from(self.traction_help_raw_value() as u64)
    }

    /// Signal which indicates the body height position of the vehicle as an answer to 'ride height request'.
    #[allow(dead_code)]
    pub fn level_ctrl_sys_ride_height_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn level_ctrl_sys_ride_height_level(&self) -> LevelCtrlSysRideHeightLevel2565209854 {
        LevelCtrlSysRideHeightLevel2565209854::from(self.level_ctrl_sys_ride_height_level_raw_value() as u64)
    }
}

/// ISO 11992: Towed vehicle message, running gear equipment #2/2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rge22 {
    frame_payload: Vec<u8>,
}

impl Rge22 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rge22 {
        frame_payload.resize(8, 0);
        Rge22 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rge22, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419323134);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rge22::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Actual relative vehicle body height.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn rel_veh_body_level_rear_axle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Actual relative vehicle body height.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn rel_veh_body_level_front_axle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// ISO 11992: Towed vehicle message, running gear equipment #2/3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rge23 {
    frame_payload: Vec<u8>,
}

impl Rge23 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rge23 {
        frame_payload.resize(8, 0);
        Rge23 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rge23, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419323646);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rge23::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal indicating the pressure level of the tyre.
    #[allow(dead_code)]
    pub fn tyre_press_threshold_detect_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_press_threshold_detect(&self) -> TyrePressThresholdDetect2566807294 {
        TyrePressThresholdDetect2566807294::from(self.tyre_press_threshold_detect_raw_value() as u64)
    }

    /// Signal indicating the power supply of the tyre module is sufficient to achieve the specified performance of the module.
    #[allow(dead_code)]
    pub fn tyre_module_power_supply_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 43) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_module_power_supply(&self) -> TyreModulePowerSupply2566807294 {
        TyreModulePowerSupply2566807294::from(self.tyre_module_power_supply_raw_value() as u64)
    }

    /// The temperature measured by the tyre module.
    /// Unit: �C
    #[allow(dead_code)]
    pub fn tyre_temperature_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// The pressure loss of a tyre.
    /// Unit: Pa/s
    #[allow(dead_code)]
    pub fn air_leakage_detection_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// First part of the identification number of the tyre or whee (number of axles).
    #[allow(dead_code)]
    pub fn tyre_wheel_identification2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_identification2(&self) -> TyreWheelIdentification22566807294 {
        TyreWheelIdentification22566807294::from(self.tyre_wheel_identification2_raw_value() as u64)
    }

    /// First part of the identification number of the tyre or whee (position on each axle).
    #[allow(dead_code)]
    pub fn tyre_wheel_identification1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn tyre_wheel_identification1(&self) -> TyreWheelIdentification12566807294 {
        TyreWheelIdentification12566807294::from(self.tyre_wheel_identification1_raw_value() as u64)
    }
}

/// Diagnostic readiness 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm26 {
    frame_payload: Vec<u8>,
}

impl Dm26 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm26 {
        frame_payload.resize(8, 0);
        Dm26 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm26, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419281150);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm26::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read MisfireMonitoringComplete signal from can frame
    #[allow(dead_code)]
    pub fn misfire_monitoring_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn misfire_monitoring_complete(&self) -> MisfireMonitoringComplete2566764798 {
        MisfireMonitoringComplete2566764798::from(self.misfire_monitoring_complete_raw_value() as u64)
    }

    /// Read MisfireMonitoringEnabled signal from can frame
    #[allow(dead_code)]
    pub fn misfire_monitoring_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn misfire_monitoring_enabled(&self) -> MisfireMonitoringEnabled2566764798 {
        MisfireMonitoringEnabled2566764798::from(self.misfire_monitoring_enabled_raw_value() as u64)
    }

    /// Read FuelSystemMonitoringEnabled signal from can frame
    #[allow(dead_code)]
    pub fn fuel_system_monitoring_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 25) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn fuel_system_monitoring_enabled(&self) -> FuelSystemMonitoringEnabled2566764798 {
        FuelSystemMonitoringEnabled2566764798::from(self.fuel_system_monitoring_enabled_raw_value() as u64)
    }

    /// Read ComprehensiveComptMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn comprehensive_compt_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn comprehensive_compt_mon_complete(&self) -> ComprehensiveComptMonComplete2566764798 {
        ComprehensiveComptMonComplete2566764798::from(self.comprehensive_compt_mon_complete_raw_value() as u64)
    }

    /// Read ComprehensiveCompMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn comprehensive_comp_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn comprehensive_comp_mon_enabled(&self) -> ComprehensiveCompMonEnabled2566764798 {
        ComprehensiveCompMonEnabled2566764798::from(self.comprehensive_comp_mon_enabled_raw_value() as u64)
    }

    /// Read SecondAirSystemMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn second_air_system_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 51) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn second_air_system_mon_complete(&self) -> SecondAirSystemMonComplete2566764798 {
        SecondAirSystemMonComplete2566764798::from(self.second_air_system_mon_complete_raw_value() as u64)
    }

    /// Read SecondAirSystemMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn second_air_system_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn second_air_system_mon_enabled(&self) -> SecondAirSystemMonEnabled2566764798 {
        SecondAirSystemMonEnabled2566764798::from(self.second_air_system_mon_enabled_raw_value() as u64)
    }

    /// Read OxygenSensorMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_complete(&self) -> OxygenSensorMonComplete2566764798 {
        OxygenSensorMonComplete2566764798::from(self.oxygen_sensor_mon_complete_raw_value() as u64)
    }

    /// Read OxygenSensorMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_enabled(&self) -> OxygenSensorMonEnabled2566764798 {
        OxygenSensorMonEnabled2566764798::from(self.oxygen_sensor_mon_enabled_raw_value() as u64)
    }

    /// Read OxygenSensorHeaterMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_complete(&self) -> OxygenSensorHeaterMonComplete2566764798 {
        OxygenSensorHeaterMonComplete2566764798::from(self.oxygen_sensor_heater_mon_complete_raw_value() as u64)
    }

    /// Read OxygenSensorHeaterMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_enabled(&self) -> OxygenSensorHeaterMonEnabled2566764798 {
        OxygenSensorHeaterMonEnabled2566764798::from(self.oxygen_sensor_heater_mon_enabled_raw_value() as u64)
    }

    /// Read HeatedCatalystMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn heated_catalyst_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn heated_catalyst_mon_complete(&self) -> HeatedCatalystMonComplete2566764798 {
        HeatedCatalystMonComplete2566764798::from(self.heated_catalyst_mon_complete_raw_value() as u64)
    }

    /// Read HeatedCatalystMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn heated_catalyst_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 33) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn heated_catalyst_mon_enabled(&self) -> HeatedCatalystMonEnabled2566764798 {
        HeatedCatalystMonEnabled2566764798::from(self.heated_catalyst_mon_enabled_raw_value() as u64)
    }

    /// Read EvaporativeSystemMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn evaporative_system_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn evaporative_system_mon_complete(&self) -> EvaporativeSystemMonComplete2566764798 {
        EvaporativeSystemMonComplete2566764798::from(self.evaporative_system_mon_complete_raw_value() as u64)
    }

    /// Read EvaporativeSystemMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn evaporative_system_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn evaporative_system_mon_enabled(&self) -> EvaporativeSystemMonEnabled2566764798 {
        EvaporativeSystemMonEnabled2566764798::from(self.evaporative_system_mon_enabled_raw_value() as u64)
    }

    /// Read EGRSystemMonitoringComplete signal from can frame
    #[allow(dead_code)]
    pub fn egr_system_monitoring_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 55) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn egr_system_monitoring_complete(&self) -> EgrSystemMonitoringComplete2566764798 {
        EgrSystemMonitoringComplete2566764798::from(self.egr_system_monitoring_complete_raw_value() as u64)
    }

    /// Read EGRSystemMonitoringEnabled signal from can frame
    #[allow(dead_code)]
    pub fn egr_system_monitoring_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 39) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn egr_system_monitoring_enabled(&self) -> EgrSystemMonitoringEnabled2566764798 {
        EgrSystemMonitoringEnabled2566764798::from(self.egr_system_monitoring_enabled_raw_value() as u64)
    }

    /// Read ColdStartAidSystemMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_complete(&self) -> ColdStartAidSystemMonComplete2566764798 {
        ColdStartAidSystemMonComplete2566764798::from(self.cold_start_aid_system_mon_complete_raw_value() as u64)
    }

    /// Read ColdStartAidSystemMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_enabled(&self) -> ColdStartAidSystemMonEnabled2566764798 {
        ColdStartAidSystemMonEnabled2566764798::from(self.cold_start_aid_system_mon_enabled_raw_value() as u64)
    }

    /// Read CatalystMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn catalyst_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn catalyst_mon_complete(&self) -> CatalystMonComplete2566764798 {
        CatalystMonComplete2566764798::from(self.catalyst_mon_complete_raw_value() as u64)
    }

    /// Read CatalystMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn catalyst_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn catalyst_mon_enabled(&self) -> CatalystMonEnabled2566764798 {
        CatalystMonEnabled2566764798::from(self.catalyst_mon_enabled_raw_value() as u64)
    }

    /// Read ACSystemRefrigerantMonComplete signal from can frame
    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_complete(&self) -> AcSystemRefrigerantMonComplete2566764798 {
        AcSystemRefrigerantMonComplete2566764798::from(self.ac_system_refrigerant_mon_complete_raw_value() as u64)
    }

    /// Read ACSystemRefrigerantMonEnabled signal from can frame
    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_enabled_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_enabled(&self) -> AcSystemRefrigerantMonEnabled2566764798 {
        AcSystemRefrigerantMonEnabled2566764798::from(self.ac_system_refrigerant_mon_enabled_raw_value() as u64)
    }

    /// Read FuelSystemMonitoringComplete signal from can frame
    #[allow(dead_code)]
    pub fn fuel_system_monitoring_complete_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 29) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn fuel_system_monitoring_complete(&self) -> FuelSystemMonitoringComplete2566764798 {
        FuelSystemMonitoringComplete2566764798::from(self.fuel_system_monitoring_complete_raw_value() as u64)
    }

    /// Read NumOfWarmUpsSinceDTCsCleared signal from can frame
    #[allow(dead_code)]
    pub fn num_of_warm_ups_since_dt_cs_cleared_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read TimeSinceEngineStart signal from can frame
    /// Unit: seconds
    #[allow(dead_code)]
    pub fn time_since_engine_start_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Data security
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm18 {
    frame_payload: Vec<u8>,
}

impl Dm18 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm18 {
        frame_payload.resize(8, 0);
        Dm18 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm18, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416612094);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm18::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read SecurityEntityLengthHigh signal from can frame
    /// Unit: Byte
    #[allow(dead_code)]
    pub fn security_entity_length_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    /// Read SecurityEntityType signal from can frame
    #[allow(dead_code)]
    pub fn security_entity_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn security_entity_type(&self) -> SecurityEntityType2564095742 {
        SecurityEntityType2564095742::from(self.security_entity_type_raw_value() as u64)
    }

    /// Read SecurityEntityLength signal from can frame
    /// Unit: Byte
    #[allow(dead_code)]
    pub fn security_entity_length_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// External Brake Request
#[allow(dead_code)]
#[derive(Debug)]
pub struct Xbr {
    frame_payload: Vec<u8>,
}

impl Xbr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Xbr {
        frame_payload.resize(8, 0);
        Xbr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Xbr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(201654014);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Xbr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read XBRMessageChecksum signal from can frame
    #[allow(dead_code)]
    pub fn xbr_message_checksum_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0xF)) as u8
    }

    /// Read XBRMessageCounter signal from can frame
    #[allow(dead_code)]
    pub fn xbr_message_counter_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    /// Read XBRCtrlMode signal from can frame
    #[allow(dead_code)]
    pub fn xbr_ctrl_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn xbr_ctrl_mode(&self) -> XbrCtrlMode2349137662 {
        XbrCtrlMode2349137662::from(self.xbr_ctrl_mode_raw_value() as u64)
    }

    /// The XBR Priority is used as an input to the brake system to manage the priority of overlapping external and internal requests.
    #[allow(dead_code)]
    pub fn xbr_priority_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn xbr_priority(&self) -> XbrPriority2349137662 {
        XbrPriority2349137662::from(self.xbr_priority_raw_value() as u64)
    }

    /// Read XBREBIMode signal from can frame
    #[allow(dead_code)]
    pub fn xbrebi_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn xbrebi_mode(&self) -> XbrebiMode2349137662 {
        XbrebiMode2349137662::from(self.xbrebi_mode_raw_value() as u64)
    }

    /// Parameter provided to the brake system from external sources.
    /// Unit: m/s�
    #[allow(dead_code)]
    pub fn extl_acceleration_demand_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.000488).round() as u16
    }
}

/// Water in Fuel Indicator
#[allow(dead_code)]
#[derive(Debug)]
pub struct Wfi {
    frame_payload: Vec<u8>,
}

impl Wfi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Wfi {
        frame_payload.resize(8, 0);
        Wfi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Wfi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419364862);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Wfi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates the presence of water in the fuel.
    #[allow(dead_code)]
    pub fn water_in_fuel_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn water_in_fuel_indicator(&self) -> WaterInFuelIndicator2566848510 {
        WaterInFuelIndicator2566848510::from(self.water_in_fuel_indicator_raw_value() as u64)
    }
}

/// Vehicle Weight
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vw {
    frame_payload: Vec<u8>,
}

impl Vw {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vw {
        frame_payload.resize(8, 0);
        Vw { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vw, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419359486);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vw::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The mass of freight carried.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn cargo_weight_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// Total mass of freight-carrying vehicle designed to be pulled by truck, including the weight of the contents.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trailer_weight_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// Total mass imposed by the tires on the road surface at the specified axle.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn axle_weight_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// To identify to which of several similar devices (such as tires or fuel tanks) the information applies.
    #[allow(dead_code)]
    pub fn axle_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Vehicle Electrical Power 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vep3 {
    frame_payload: Vec<u8>,
}

impl Vep3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vep3 {
        frame_payload.resize(8, 0);
        Vep3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vep3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419320574);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vep3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Net flow of electrical current into/out-of the battery or batteries.
    /// Unit: A
    #[allow(dead_code)]
    pub fn net_battery_current_hi_res_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// This parameter indicates the amount of electrical current output from the alternator of the main vehicle.
    /// Unit: A
    #[allow(dead_code)]
    pub fn alt_current_hi_res_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Vehicle Electrical Power 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vep2 {
    frame_payload: Vec<u8>,
}

impl Vep2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vep2 {
        frame_payload.resize(8, 0);
        Vep2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vep2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486444542);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vep2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The voltage for isolated battery #2.
    /// Unit: V
    #[allow(dead_code)]
    pub fn battery2_potential_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// The third power output from an ECM.
    /// Unit: V
    #[allow(dead_code)]
    pub fn ecu_power_output_supply_voltage3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// The second power output from an ECM.
    /// Unit: V
    #[allow(dead_code)]
    pub fn ecu_power_output_supply_voltage2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read ECUPowerOutputSupplyVoltage1 signal from can frame
    /// Unit: V
    #[allow(dead_code)]
    pub fn ecu_power_output_supply_voltage1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// This parameter measures the second source of battery potential as measured at the input of the ECM/actuator etc.
    /// Unit: V
    #[allow(dead_code)]
    pub fn battery_potential_power_input2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Vehicle Position
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vp {
    frame_payload: Vec<u8>,
}

impl Vp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vp {
        frame_payload.resize(8, 0);
        Vp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419361790);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Longitude position of the vehicle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn longitude_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.000000).round() as u32
    }

    /// Latitude position of the vehicle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn latitude_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.000000).round() as u32
    }
}

/// Vehicle Identification
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vi {
    frame_payload: Vec<u8>,
}

impl Vi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vi {
        frame_payload.resize(8, 0);
        Vi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419359998);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vi::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Vehicle Hours
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vh {
    frame_payload: Vec<u8>,
}

impl Vh {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vh {
        frame_payload.resize(8, 0);
        Vh { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vh, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419358718);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vh::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Accumulated time of operation of power takeoff device.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn total_power_takeoff_hours_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Accumulated time of operation of vehicle.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn total_vehicle_hours_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }
}

/// Vehicle Fluids
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vf {
    frame_payload: Vec<u8>,
}

impl Vf {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vf {
        frame_payload.resize(8, 0);
        Vf { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vf, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419326206);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vf::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read WinchOilPressSwitch signal from can frame
    #[allow(dead_code)]
    pub fn winch_oil_press_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn winch_oil_press_switch(&self) -> WinchOilPressSwitch2566809854 {
        WinchOilPressSwitch2566809854::from(self.winch_oil_press_switch_raw_value() as u64)
    }

    /// This parameter indicates the level of the hydraulic fluid in tank as a ratio of current volume to total tank volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn hyd_oil_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// This switch indicates whether hydraulic oil filter is clogged.
    #[allow(dead_code)]
    pub fn hyd_oil_filter_restriction_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hyd_oil_filter_restriction_switch(&self) -> HydOilFilterRestrictionSwitch2566809854 {
        HydOilFilterRestrictionSwitch2566809854::from(self.hyd_oil_filter_restriction_switch_raw_value() as u64)
    }

    /// Temperature of hydraulic fluid.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn hyd_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Vehicle Direction/Speed
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vds {
    frame_payload: Vec<u8>,
}

impl Vds {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vds {
        frame_payload.resize(8, 0);
        Vds { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vds, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419358974);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vds::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Altitude of the vehicle referenced to sea level at standard atmospheric pressure and temperature.
    /// Unit: m
    #[allow(dead_code)]
    pub fn altitude_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Pitch of the vehicle as calculated by the navigation device(s).
    /// Unit: deg
    #[allow(dead_code)]
    pub fn pitch_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Speed of the vehicle as calculated from a device such as a Global Positioning System (GPS).
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn navigation_based_vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// Present compass bearing of vehicle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn compass_bearing_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// High Resolution Vehicle Distance
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vdhr {
    frame_payload: Vec<u8>,
}

impl Vdhr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vdhr {
        frame_payload.resize(8, 0);
        Vdhr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vdhr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419348990);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vdhr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Distance traveled during all or part of a journey.
    /// Unit: km
    #[allow(dead_code)]
    pub fn high_resolution_trip_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.005000).round() as u32
    }

    /// Accumulated distance traveled by the vehicle during its operation.
    /// Unit: km
    #[allow(dead_code)]
    pub fn hgh_rslution_total_vehicle_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.005000).round() as u32
    }
}

/// Vehicle Dynamic Stability Control 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vdc2 {
    frame_payload: Vec<u8>,
}

impl Vdc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vdc2 {
        frame_payload.resize(8, 0);
        Vdc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vdc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418384382);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vdc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates the longitudinal acceleration of the vehicle.
    /// Unit: m/s�
    #[allow(dead_code)]
    pub fn longitudinal_acceleration_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.100000).round() as u8
    }

    /// Indicates a lateral acceleration of the vehicle.
    /// Unit: m/s�
    #[allow(dead_code)]
    pub fn lateral_acceleration_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.000488).round() as u16
    }

    /// Indicates the rotation about the vertical axis.
    /// Unit: rad/s
    #[allow(dead_code)]
    pub fn yaw_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.000122).round() as u16
    }

    /// Read SteerWheelAngleSensorType signal from can frame
    #[allow(dead_code)]
    pub fn steer_wheel_angle_sensor_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn steer_wheel_angle_sensor_type(&self) -> SteerWheelAngleSensorType2565868030 {
        SteerWheelAngleSensorType2565868030::from(self.steer_wheel_angle_sensor_type_raw_value() as u64)
    }

    /// Indicates number of steering wheel turns, absolute position or relative position at ignition on.
    /// Unit: turns
    #[allow(dead_code)]
    pub fn steer_wheel_turn_counter_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3F)) as u8
    }

    /// The main operator`s steering wheel angle (on the steering column, not the actual wheel angle).
    /// Unit: rad
    #[allow(dead_code)]
    pub fn steer_wheel_angle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.000977).round() as u16
    }
}

/// Vehicle Dynamic Stability Control 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vdc1 {
    frame_payload: Vec<u8>,
}

impl Vdc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vdc1 {
        frame_payload.resize(8, 0);
        Vdc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vdc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419319806);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vdc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// State signal which indicates that Yaw Control (YC) has activated brake control.
    #[allow(dead_code)]
    pub fn yc_brake_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn yc_brake_ctrl_active(&self) -> YcBrakeCtrlActive2566803454 {
        YcBrakeCtrlActive2566803454::from(self.yc_brake_ctrl_active_raw_value() as u64)
    }

    /// State Signal which indicates that the Yaw Control (YC) has commanded engine control to be active.
    #[allow(dead_code)]
    pub fn yc_eng_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn yc_eng_ctrl_active(&self) -> YcEngCtrlActive2566803454 {
        YcEngCtrlActive2566803454::from(self.yc_eng_ctrl_active_raw_value() as u64)
    }

    /// State signal which indicates that Roll over Prevention (ROP) has activated brake control.
    #[allow(dead_code)]
    pub fn rop_brake_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rop_brake_ctrl_active(&self) -> RopBrakeCtrlActive2566803454 {
        RopBrakeCtrlActive2566803454::from(self.rop_brake_ctrl_active_raw_value() as u64)
    }

    /// State Signal which indicates that the Roll Over Prevention (ROP) has commanded engine control to be active.
    #[allow(dead_code)]
    pub fn rop_eng_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rop_eng_ctrl_active(&self) -> RopEngCtrlActive2566803454 {
        RopEngCtrlActive2566803454::from(self.rop_eng_ctrl_active_raw_value() as u64)
    }

    /// Read VDCBrakeLightRq signal from can frame
    #[allow(dead_code)]
    pub fn vdc_brake_light_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vdc_brake_light_rq(&self) -> VdcBrakeLightRq2566803454 {
        VdcBrakeLightRq2566803454::from(self.vdc_brake_light_rq_raw_value() as u64)
    }

    /// Signal that indicates whether VDC is fully operational or whether its functionality is reduced by a permanent or temporary (e.
    #[allow(dead_code)]
    pub fn vdc_fully_operational_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vdc_fully_operational(&self) -> VdcFullyOperational2566803454 {
        VdcFullyOperational2566803454::from(self.vdc_fully_operational_raw_value() as u64)
    }

    /// This parameter commands the VDC information signal, for example a dash lamp.
    #[allow(dead_code)]
    pub fn vdc_information_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vdc_information_signal(&self) -> VdcInformationSignal2566803454 {
        VdcInformationSignal2566803454::from(self.vdc_information_signal_raw_value() as u64)
    }
}

/// Vehicle Distance
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vd {
    frame_payload: Vec<u8>,
}

impl Vd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vd {
        frame_payload.resize(8, 0);
        Vd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419356926);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Accumulated distance traveled by vehicle during its operation.
    /// Unit: km
    #[allow(dead_code)]
    pub fn total_vehicle_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }

    /// Distance traveled during all or part of a journey.
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }
}

/// Trip Vehicle Speed/Cruise Distance Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tvi {
    frame_payload: Vec<u8>,
}

impl Tvi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tvi {
        frame_payload.resize(8, 0);
        Tvi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tvi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486455038);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tvi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TripCruiseDistance signal from can frame
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_cruise_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }

    /// Read TripMaxVehicleSpeed signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn trip_max_vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.003906).round() as u16
    }
}

/// Trip Time Information 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tti2 {
    frame_payload: Vec<u8>,
}

impl Tti2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tti2 {
        frame_payload.resize(8, 0);
        Tti2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tti2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486453502);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tti2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total time that the air compressor is on and compressing air since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_air_compressor_on_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Read TripIdleTime signal from can frame
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_idle_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time accumulated while the engine speed is greater than zero since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_eng_running_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time accumulated while the engine is in the PTO or remote PTO hold state since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_pto_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time accumulated while the engine is in the cruise hold state, excluding time in accelerator override, since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_cruise_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }
}

/// Trip Time Information 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tti1 {
    frame_payload: Vec<u8>,
}

impl Tti1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tti1 {
        frame_payload.resize(8, 0);
        Tti1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tti1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486454526);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tti1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total time accumulated when the engine final fueling has been derated due to an engine protection algorithm, since the last reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_time_in_derate_by_eng_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Read TripTimeInGearDown signal from can frame
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_time_in_gear_down_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time accumulated when the vehicle has operated in top gear for a calibrated minimum time, since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_time_in_top_gear_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Read TripTimeInVSL signal from can frame
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_time_in_vsl_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }
}

/// Trip Shutdown Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tsi {
    frame_payload: Vec<u8>,
}

impl Tsi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tsi {
        frame_payload.resize(8, 0);
        Tsi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tsi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486454782);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tsi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TripSuddenDecelerations signal from can frame
    /// Unit: counts
    #[allow(dead_code)]
    pub fn trip_sudden_decelerations_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Total number of times an operator disables idle shutdown to prevent an engine shutdown, since the last trip reset.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn trp_nmber_of_idle_shutdown_overrides_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Total number of times the engine has been shutdown due to idling too long (at normal idle or fast idle) since the last trip reset.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn trip_number_of_idle_shutdowns_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Total number of hot shutdowns since the last trip reset.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn trip_number_of_hot_shutdowns_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Torque/Speed Control 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tsc1 {
    frame_payload: Vec<u8>,
}

impl Tsc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tsc1 {
        frame_payload.resize(8, 0);
        Tsc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tsc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(201391870);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tsc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// State signal which indicates which control mode the sending device is using to generate the TSC1 command.
    #[allow(dead_code)]
    pub fn control_purpose_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn control_purpose(&self) -> ControlPurpose2348875518 {
        ControlPurpose2348875518::from(self.control_purpose_raw_value() as u64)
    }

    /// This parameter indicates the transmission rate at which the sending device will transmit the TSC1 message.
    #[allow(dead_code)]
    pub fn transmission_rate_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn transmission_rate(&self) -> TransmissionRate2348875518 {
        TransmissionRate2348875518::from(self.transmission_rate_raw_value() as u64)
    }

    /// Parameter provided to the engine or retarder in the torque/speed control message for controlling or limiting the output torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_rqed_torque_torque_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Parameter provided to the engine from external sources in the torque/speed control message.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_rqed_speed_speed_limit_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read OverrideCtrlModePriority signal from can frame
    #[allow(dead_code)]
    pub fn override_ctrl_mode_priority_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn override_ctrl_mode_priority(&self) -> OverrideCtrlModePriority2348875518 {
        OverrideCtrlModePriority2348875518::from(self.override_ctrl_mode_priority_raw_value() as u64)
    }

    /// This mode tells the engine control system the governor characteristics that are desired during speed control.
    #[allow(dead_code)]
    pub fn eng_rqed_speed_ctrl_conditions_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_rqed_speed_ctrl_conditions(&self) -> EngRqedSpeedCtrlConditions2348875518 {
        EngRqedSpeedCtrlConditions2348875518::from(self.eng_rqed_speed_ctrl_conditions_raw_value() as u64)
    }

    /// Read EngOverrideCtrlMode signal from can frame
    #[allow(dead_code)]
    pub fn eng_override_ctrl_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_override_ctrl_mode(&self) -> EngOverrideCtrlMode2348875518 {
        EngOverrideCtrlMode2348875518::from(self.eng_override_ctrl_mode_raw_value() as u64)
    }
}

/// Passenger Counter
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr7 {
    frame_payload: Vec<u8>,
}

impl Tr7 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr7 {
        frame_payload.resize(8, 0);
        Tr7 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr7, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419283198);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr7::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Status of the run switch for the vehicle.
    #[allow(dead_code)]
    pub fn transit_run_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn transit_run_status(&self) -> TransitRunStatus2566766846 {
        TransitRunStatus2566766846::from(self.transit_run_status_raw_value() as u64)
    }

    /// Used to indicate the proper or unauthorized use of the vehicle.
    #[allow(dead_code)]
    pub fn vehicle_use_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_use_status(&self) -> VehicleUseStatus2566766846 {
        VehicleUseStatus2566766846::from(self.vehicle_use_status_raw_value() as u64)
    }

    /// Used to report silent alarm push button status.
    #[allow(dead_code)]
    pub fn silent_alarm_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn silent_alarm_status(&self) -> SilentAlarmStatus2566766846 {
        SilentAlarmStatus2566766846::from(self.silent_alarm_status_raw_value() as u64)
    }

    /// Count of the number of passengers on a transit vehicle.
    #[allow(dead_code)]
    pub fn patron_count_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Used to notify transit link devices of the type of passenger counting system used in the vehicle.
    #[allow(dead_code)]
    pub fn type_of_passenger_count_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn type_of_passenger_count(&self) -> TypeOfPassengerCount2566766846 {
        TypeOfPassengerCount2566766846::from(self.type_of_passenger_count_raw_value() as u64)
    }
}

/// Farebox Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr6 {
    frame_payload: Vec<u8>,
}

impl Tr6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr6 {
        frame_payload.resize(8, 0);
        Tr6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419281662);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates the nature of the farebox alarm condition.
    #[allow(dead_code)]
    pub fn farebox_alarm_identifier_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x7F)) as u8
    }

    #[allow(dead_code)]
    pub fn farebox_alarm_identifier(&self) -> FareboxAlarmIdentifier2566765310 {
        FareboxAlarmIdentifier2566765310::from(self.farebox_alarm_identifier_raw_value() as u64)
    }

    /// Indicates if a farebox emergency condition exists.
    #[allow(dead_code)]
    pub fn farebox_emergency_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn farebox_emergency_status(&self) -> FareboxEmergencyStatus2566765310 {
        FareboxEmergencyStatus2566765310::from(self.farebox_emergency_status_raw_value() as u64)
    }
}

/// Farebox Point of Sale
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr5 {
    frame_payload: Vec<u8>,
}

impl Tr5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr5 {
        frame_payload.resize(8, 0);
        Tr5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419281918);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates that a transfer was sold or issued on this transaction including its type and/or restrictions.
    #[allow(dead_code)]
    pub fn transfer_sold_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// The route number issuing the transfer.
    #[allow(dead_code)]
    pub fn route_number_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFF)) as u16
    }

    /// Read TransferType signal from can frame
    #[allow(dead_code)]
    pub fn transfer_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn transfer_type(&self) -> TransferType2566765566 {
        TransferType2566765566::from(self.transfer_type_raw_value() as u64)
    }

    /// Read TypeOfService signal from can frame
    #[allow(dead_code)]
    pub fn type_of_service_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn type_of_service(&self) -> TypeOfService2566765566 {
        TypeOfService2566765566::from(self.type_of_service_raw_value() as u64)
    }

    /// Read InitialFareAgency signal from can frame
    #[allow(dead_code)]
    pub fn initial_fare_agency_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x1F)) as u8
    }

    /// Read PassCategory signal from can frame
    #[allow(dead_code)]
    pub fn pass_category_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    /// Read FareValidity signal from can frame
    #[allow(dead_code)]
    pub fn fare_validity_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    /// Payment details.
    #[allow(dead_code)]
    pub fn payment_details_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn payment_details(&self) -> PaymentDetails2566765566 {
        PaymentDetails2566765566::from(self.payment_details_raw_value() as u64)
    }

    /// Read TypeOfFare signal from can frame
    #[allow(dead_code)]
    pub fn type_of_fare_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn type_of_fare(&self) -> TypeOfFare2566765566 {
        TypeOfFare2566765566::from(self.type_of_fare_raw_value() as u64)
    }

    /// Enumerated value representing the type/class of passenger, as defined by the agency.
    #[allow(dead_code)]
    pub fn passenger_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    /// Read TransactionType signal from can frame
    #[allow(dead_code)]
    pub fn transaction_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn transaction_type(&self) -> TransactionType2566765566 {
        TransactionType2566765566::from(self.transaction_type_raw_value() as u64)
    }
}

/// Farebox Service Detail
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr4 {
    frame_payload: Vec<u8>,
}

impl Tr4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr4 {
        frame_payload.resize(8, 0);
        Tr4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419282174);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Security code for the farebox, numerical only.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn drivers_farebox_security_code_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0xFFFF)) as u16
    }

    #[allow(dead_code)]
    pub fn drivers_farebox_security_code(&self) -> DriversFareboxSecurityCode2566765822 {
        DriversFareboxSecurityCode2566765822::from(self.drivers_farebox_security_code_raw_value() as u64)
    }

    /// Read AssignedBlock signal from can frame
    /// Unit: counts
    #[allow(dead_code)]
    pub fn assigned_block_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 88) & 0xFFFF)) as u16
    }

    /// Read AssignedRun signal from can frame
    /// Unit: counts
    #[allow(dead_code)]
    pub fn assigned_run_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0xFFFF)) as u16
    }

    /// The identity number assigned to this route.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn assigned_route_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFFFF)) as u16
    }

    /// Read PatternNumber signal from can frame
    /// Unit: counts
    #[allow(dead_code)]
    pub fn pattern_number_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF)) as u16
    }

    /// The identity number assigned to this trip.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn trip_number_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF)) as u16
    }

    /// Read FarePresets signal from can frame
    #[allow(dead_code)]
    pub fn fare_presets_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// The general direction of travel for this trip.
    #[allow(dead_code)]
    pub fn trip_direction_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn trip_direction(&self) -> TripDirection2566765822 {
        TripDirection2566765822::from(self.trip_direction_raw_value() as u64)
    }

    /// Read TripStatus signal from can frame
    #[allow(dead_code)]
    pub fn trip_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trip_status(&self) -> TripStatus2566765822 {
        TripStatus2566765822::from(self.trip_status_raw_value() as u64)
    }

    /// Indicates if the farebox is in or out of service.
    #[allow(dead_code)]
    pub fn farebox_service_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn farebox_service_status(&self) -> FareboxServiceStatus2566765822 {
        FareboxServiceStatus2566765822::from(self.farebox_service_status_raw_value() as u64)
    }
}

/// Signal Preemption
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr3 {
    frame_payload: Vec<u8>,
}

impl Tr3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr3 {
        frame_payload.resize(8, 0);
        Tr3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419282430);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Numerical designation of the vehicle.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn vehicle_id_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Read StrobeActivationCtrlStatus signal from can frame
    #[allow(dead_code)]
    pub fn strobe_activation_ctrl_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn strobe_activation_ctrl_status(&self) -> StrobeActivationCtrlStatus2566766078 {
        StrobeActivationCtrlStatus2566766078::from(self.strobe_activation_ctrl_status_raw_value() as u64)
    }

    /// Read TransitDoorEnable signal from can frame
    #[allow(dead_code)]
    pub fn transit_door_enable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn transit_door_enable(&self) -> TransitDoorEnable2566766078 {
        TransitDoorEnable2566766078::from(self.transit_door_enable_raw_value() as u64)
    }

    /// Read PriorityOfRespSentByEmitter signal from can frame
    #[allow(dead_code)]
    pub fn priority_of_resp_sent_by_emitter_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn priority_of_resp_sent_by_emitter(&self) -> PriorityOfRespSentByEmitter2566766078 {
        PriorityOfRespSentByEmitter2566766078::from(self.priority_of_resp_sent_by_emitter_raw_value() as u64)
    }

    /// Read IntersectionPreemptionRq_Resp signal from can frame
    #[allow(dead_code)]
    pub fn intersection_preemption_rq_resp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn intersection_preemption_rq_resp(&self) -> IntersectionPreemptionRqResp2566766078 {
        IntersectionPreemptionRqResp2566766078::from(self.intersection_preemption_rq_resp_raw_value() as u64)
    }

    /// Read TransitRouteIDUsage signal from can frame
    #[allow(dead_code)]
    pub fn transit_route_id_usage_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn transit_route_id_usage(&self) -> TransitRouteIdUsage2566766078 {
        TransitRouteIdUsage2566766078::from(self.transit_route_id_usage_raw_value() as u64)
    }

    /// Read RangeCodeEnable signal from can frame
    #[allow(dead_code)]
    pub fn range_code_enable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn range_code_enable(&self) -> RangeCodeEnable2566766078 {
        RangeCodeEnable2566766078::from(self.range_code_enable_raw_value() as u64)
    }
}

/// Transit Milepost
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr2 {
    frame_payload: Vec<u8>,
}

impl Tr2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr2 {
        frame_payload.resize(8, 0);
        Tr2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419282942);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read NmbrOfBytsInMlpstIdentification signal from can frame
    #[allow(dead_code)]
    pub fn nmbr_of_byts_in_mlpst_identification_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Transit Route
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tr1 {
    frame_payload: Vec<u8>,
}

impl Tr1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tr1 {
        frame_payload.resize(8, 0);
        Tr1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tr1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419282686);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tr1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Agency signal from can frame
    #[allow(dead_code)]
    pub fn agency_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Read NmbrOfBytsInTrnstAssgndBlckIdntt signal from can frame
    #[allow(dead_code)]
    pub fn nmbr_of_byts_in_trnst_assgnd_blck_idntt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Read NmbrOfBytsInTrnstAssgndRnIdntty signal from can frame
    #[allow(dead_code)]
    pub fn nmbr_of_byts_in_trnst_assgnd_rn_idntty_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read NmbrOfBytsInTrnstAssgndRtIdntty signal from can frame
    #[allow(dead_code)]
    pub fn nmbr_of_byts_in_trnst_assgnd_rt_idntty_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }
}

/// Tire Pressure Reference Setting
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tprs {
    frame_payload: Vec<u8>,
}

impl Tprs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tprs {
        frame_payload.resize(8, 0);
        Tprs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tprs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(414121726);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tprs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ReferenceTirePressSetting signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn reference_tire_press_setting_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Identifies which tire is associated with the parametric data in this PGN.
    #[allow(dead_code)]
    pub fn tire_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Tire Pressure Reference Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tpri {
    frame_payload: Vec<u8>,
}

impl Tpri {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tpri {
        frame_payload.resize(8, 0);
        Tpri { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tpri, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419281406);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tpri::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ReferenceTirePress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn reference_tire_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Identifies which tire is associated with the parametric data in this PGN.
    #[allow(dead_code)]
    pub fn tire_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Tire Pressure Control Unit Current Pressures
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tp3 {
    frame_payload: Vec<u8>,
}

impl Tp3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tp3 {
        frame_payload.resize(8, 0);
        Tp3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tp3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486439678);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tp3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The latest gage pressure reading of the steer group of tires, as opposed to the pressure in each tire.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn steer_channel_tire_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// The latest gage pressure reading of the drive group of tires, as opposed to the pressure in each tire.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn drive_channel_tire_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// The latest gage pressure reading of the trailer, tag, or push group of tires, as opposed to the pressure in each tire.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn trailer_tag_push_channel_tire_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Tire Pressure Control Unit Target Pressures
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tp2 {
    frame_payload: Vec<u8>,
}

impl Tp2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tp2 {
        frame_payload.resize(8, 0);
        Tp2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tp2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486439422);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tp2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The tire pressure control system�s target gage pressure for the steer group of tires.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn steer_channel_tire_press_target_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// The tire pressure control system�s target gage pressure for the drive group of tires.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn drive_channel_tire_press_target_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// The tire pressure control system�s target gage pressure for the trailer, tag, or push group of tires.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn trlr_tg_psh_channel_tire_press_target_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Tire Pressure Control Unit Mode and Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tp1 {
    frame_payload: Vec<u8>,
}

impl Tp1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tp1 {
        frame_payload.resize(8, 0);
        Tp1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tp1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486439166);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tp1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Current state of the supply solenoid used to implement a tire pressure control system in its pneumatic control unit (PCU).
    #[allow(dead_code)]
    pub fn pcu_supply_solenoid_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pcu_supply_solenoid_status(&self) -> PcuSupplySolenoidStatus2633922814 {
        PcuSupplySolenoidStatus2633922814::from(self.pcu_supply_solenoid_status_raw_value() as u64)
    }

    /// Current state of the control solenoid used to implement a tire pressure control system in its pneumatic control unit (PCU).
    #[allow(dead_code)]
    pub fn pcu_ctrl_solenoid_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pcu_ctrl_solenoid_status(&self) -> PcuCtrlSolenoidStatus2633922814 {
        PcuCtrlSolenoidStatus2633922814::from(self.pcu_ctrl_solenoid_status_raw_value() as u64)
    }

    /// Current state of the deflate solenoid used to implement a tire pressure control system in its pneumatic control unit (PCU).
    #[allow(dead_code)]
    pub fn pcu_deflate_solenoid_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pcu_deflate_solenoid_status(&self) -> PcuDeflateSolenoidStatus2633922814 {
        PcuDeflateSolenoidStatus2633922814::from(self.pcu_deflate_solenoid_status_raw_value() as u64)
    }

    /// Current state of an open/closed type switch used to determine if adequate pressure exists for system implementation.
    #[allow(dead_code)]
    pub fn tire_press_supply_switch_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tire_press_supply_switch_status(&self) -> TirePressSupplySwitchStatus2633922814 {
        TirePressSupplySwitchStatus2633922814::from(self.tire_press_supply_switch_status_raw_value() as u64)
    }

    /// Current state of the steer solenoid used to implement a tire pressure control system in its pneumatic control unit (PCU).
    #[allow(dead_code)]
    pub fn pcu_steer_solenoid_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pcu_steer_solenoid_status(&self) -> PcuSteerSolenoidStatus2633922814 {
        PcuSteerSolenoidStatus2633922814::from(self.pcu_steer_solenoid_status_raw_value() as u64)
    }

    /// Current state of the drive solenoid used to implement a tire pressure control system in its pneumatic control unit (PCU).
    #[allow(dead_code)]
    pub fn pcu_drive_solenoid_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pcu_drive_solenoid_status(&self) -> PcuDriveSolenoidStatus2633922814 {
        PcuDriveSolenoidStatus2633922814::from(self.pcu_drive_solenoid_status_raw_value() as u64)
    }

    /// Indicates the functional mode of trailer/tag channel of the tire pressure control system.
    #[allow(dead_code)]
    pub fn drive_channel_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn drive_channel_mode(&self) -> DriveChannelMode2633922814 {
        DriveChannelMode2633922814::from(self.drive_channel_mode_raw_value() as u64)
    }

    /// Indicates the functional mode of trailer/tag channel of the tire pressure control system.
    #[allow(dead_code)]
    pub fn trailer_tag_channel_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_tag_channel_mode(&self) -> TrailerTagChannelMode2633922814 {
        TrailerTagChannelMode2633922814::from(self.trailer_tag_channel_mode_raw_value() as u64)
    }

    /// Indicates the functional mode of steer channel of the tire pressure control system.
    #[allow(dead_code)]
    pub fn steer_channel_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn steer_channel_mode(&self) -> SteerChannelMode2633922814 {
        SteerChannelMode2633922814::from(self.steer_channel_mode_raw_value() as u64)
    }

    /// The interval at which the system will check the tire pressures (e.
    /// Unit: mins
    #[allow(dead_code)]
    pub fn tire_press_check_interval_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Read PCUTrailerTagPushSolenoidStatus signal from can frame
    #[allow(dead_code)]
    pub fn pcu_trailer_tag_push_solenoid_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pcu_trailer_tag_push_solenoid_status(&self) -> PcuTrailerTagPushSolenoidStatus2633922814 {
        PcuTrailerTagPushSolenoidStatus2633922814::from(self.pcu_trailer_tag_push_solenoid_status_raw_value() as u64)
    }
}

/// Tire Condition
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tire {
    frame_payload: Vec<u8>,
}

impl Tire {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tire {
        frame_payload.resize(8, 0);
        Tire { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tire, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419362046);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tire::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal indicating the pressure level of the tire.
    #[allow(dead_code)]
    pub fn tire_press_threshold_detection_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 61) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tire_press_threshold_detection(&self) -> TirePressThresholdDetection2566845694 {
        TirePressThresholdDetection2566845694::from(self.tire_press_threshold_detection_raw_value() as u64)
    }

    /// The pressure loss rate of a tire.
    /// Unit: Pa/s
    #[allow(dead_code)]
    pub fn tire_air_leakage_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Indicates the status of electrical fault on CTI wheel interface.
    #[allow(dead_code)]
    pub fn cti_wheel_end_electrical_fault_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cti_wheel_end_electrical_fault(&self) -> CtiWheelEndElectricalFault2566845694 {
        CtiWheelEndElectricalFault2566845694::from(self.cti_wheel_end_electrical_fault_raw_value() as u64)
    }

    /// Indicates the status of the tire.
    #[allow(dead_code)]
    pub fn cti_tire_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cti_tire_status(&self) -> CtiTireStatus2566845694 {
        CtiTireStatus2566845694::from(self.cti_tire_status_raw_value() as u64)
    }

    /// Indicates whether the wheel is being monitored by the CTI controller.
    #[allow(dead_code)]
    pub fn cti_wheel_sensor_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cti_wheel_sensor_status(&self) -> CtiWheelSensorStatus2566845694 {
        CtiWheelSensorStatus2566845694::from(self.cti_wheel_sensor_status_raw_value() as u64)
    }

    /// Temperature at the surface of the tire sidewall.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn tire_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Pressure at which air is contained in cavity formed by tire and rim.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn tire_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Identifies which tire is associated with the parametric data in this PGN.
    #[allow(dead_code)]
    pub fn tire_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Tank Information 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ti1 {
    frame_payload: Vec<u8>,
}

impl Ti1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ti1 {
        frame_payload.resize(8, 0);
        Ti1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ti1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419321598);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ti1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the reagent in the storage tank.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn catalyst_tank_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// A special catalyst uses chemical substance to reach legal requirement for NOX emissions.
    /// Unit: %
    #[allow(dead_code)]
    pub fn catalyst_tank_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Used to identify the applicable J1939-73 FMI that applies to the most significant failure of the catalyst tank level sensor.
    #[allow(dead_code)]
    pub fn catalyst_tank_level_preliminary_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    /// The measure of the reagent level in the catalyst tank.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn catalyst_tank_level2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Trip Fan Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tfi {
    frame_payload: Vec<u8>,
}

impl Tfi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tfi {
        frame_payload.resize(8, 0);
        Tfi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tfi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486456318);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tfi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total time the fan has been on due to manual activation by the operator (i.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_fan_on_time_due_to_a_manual_switch_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time the fan has been on (due to an automatic trigger or manual trigger) since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_fan_on_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time the fan has been on due to the A/C system since the last trip reset.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_fan_on_time_due_to_a_c_system_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total time the fan has been on due to engine triggers (i.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn trip_fan_on_time_due_to_eng_system_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }
}

/// Trip Distance Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tdi {
    frame_payload: Vec<u8>,
}

impl Tdi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tdi {
        frame_payload.resize(8, 0);
        Tdi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tdi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486456062);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tdi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total distance accumulated while the vehicle has operated in top gear for a calibrated minimum time since the last trip reset.
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_distance_in_top_gear_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }

    /// Read TripGearDownDistance signal from can frame
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_gear_down_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }

    /// Total distance accumulated while the engine torque mode is road speed governing since the last trip reset.
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_distance_on_vsl_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }
}

/// Time/Date Adjust
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tda {
    frame_payload: Vec<u8>,
}

impl Tda {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tda {
        frame_payload.resize(8, 0);
        Tda { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tda, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416677630);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tda::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read AdjustLocalHourOffset signal from can frame
    /// Unit: hr
    #[allow(dead_code)]
    pub fn adjust_local_hour_offset_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Used to set the local offset in minutes from a reference time.
    /// Unit: mins
    #[allow(dead_code)]
    pub fn adjust_local_minute_offset_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Part of a parameter used to set a calendar date.
    /// Unit: years
    #[allow(dead_code)]
    pub fn adjust_year_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Part of a parameter used to set a calendar date.
    /// Unit: days
    #[allow(dead_code)]
    pub fn adjust_day_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.250000).round() as u8
    }

    /// Part of a parameter used to set a calendar date.
    /// Unit: months
    #[allow(dead_code)]
    pub fn adjust_month_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Part of the parameter used to set the time.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn adjust_hours_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Part of the parameter used to set the time.
    /// Unit: mins
    #[allow(dead_code)]
    pub fn adjust_minutes_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Part of the parameter used to set the time.
    /// Unit: s
    #[allow(dead_code)]
    pub fn adjust_seconds_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.250000).round() as u8
    }
}

/// Time/Date
#[allow(dead_code)]
#[derive(Debug)]
pub struct Td {
    frame_payload: Vec<u8>,
}

impl Td {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Td {
        frame_payload.resize(8, 0);
        Td { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Td, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419358462);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Td::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read LocalHourOffset signal from can frame
    /// Unit: hr
    #[allow(dead_code)]
    pub fn local_hour_offset_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Local offset in minutes from a reference time.
    /// Unit: mins
    #[allow(dead_code)]
    pub fn local_minute_offset_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Part of a parameter used to represent a calendar date.
    /// Unit: years
    #[allow(dead_code)]
    pub fn year_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Part of a parameter used to represent a calendar date.
    /// Unit: days
    #[allow(dead_code)]
    pub fn day_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.250000).round() as u8
    }

    /// Part of a parameter used to represent a calendar date.
    /// Unit: months
    #[allow(dead_code)]
    pub fn month_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Part of a parameter used to represent time.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn hours_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Part of a parameter used to represent time.
    /// Unit: mins
    #[allow(dead_code)]
    pub fn minutes_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Part of a parameter used to represent time.
    /// Unit: s
    #[allow(dead_code)]
    pub fn seconds_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.250000).round() as u8
    }
}

/// Turbocharger Wastegate
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tcw {
    frame_payload: Vec<u8>,
}

impl Tcw {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tcw {
        frame_payload.resize(8, 0);
        Tcw { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tcw, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419337982);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tcw::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Gage pressure of the air used to control the actuator which opens and closes the wastegate valve.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_trb_wstgt_actuator_ctrl_air_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Position of the wastegate drive.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_turbo4_wastegate_drive_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Position of the wastegate drive.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_turbo3_wastegate_drive_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Position of the wastegate drive.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_turbo2_wastegate_drive_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Position of the wastegate drive.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_turbo1_wastegate_drive_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Tachograph
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tco1 {
    frame_payload: Vec<u8>,
}

impl Tco1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tco1 {
        frame_payload.resize(8, 0);
        Tco1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tco1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218000638);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tco1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Speed of the vehicle registered by the tachograph.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn tachograph_vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// Calculated speed of the transmission output shaft.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn tachograph_output_shaft_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Indicates the direction of the vehicle.
    #[allow(dead_code)]
    pub fn direction_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn direction_indicator(&self) -> DirectionIndicator2365484286 {
        DirectionIndicator2365484286::from(self.direction_indicator_raw_value() as u64)
    }

    /// Read TachographPerformance signal from can frame
    #[allow(dead_code)]
    pub fn tachograph_performance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn tachograph_performance(&self) -> TachographPerformance2365484286 {
        TachographPerformance2365484286::from(self.tachograph_performance_raw_value() as u64)
    }

    /// Indicates that handling information is present.
    #[allow(dead_code)]
    pub fn handling_information_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn handling_information(&self) -> HandlingInformation2365484286 {
        HandlingInformation2365484286::from(self.handling_information_raw_value() as u64)
    }

    /// Indicates that a tachograph event has occurred.
    #[allow(dead_code)]
    pub fn system_event_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn system_event(&self) -> SystemEvent2365484286 {
        SystemEvent2365484286::from(self.system_event_raw_value() as u64)
    }

    /// Read DriverCardDriver2 signal from can frame
    #[allow(dead_code)]
    pub fn driver_card_driver2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn driver_card_driver2(&self) -> DriverCardDriver22365484286 {
        DriverCardDriver22365484286::from(self.driver_card_driver2_raw_value() as u64)
    }

    /// Indicates if the driver approaches or exceeds working time limits (or other limits).
    #[allow(dead_code)]
    pub fn driver2_time_related_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn driver2_time_related_states(&self) -> Driver2TimeRelatedStates2365484286 {
        Driver2TimeRelatedStates2365484286::from(self.driver2_time_related_states_raw_value() as u64)
    }

    /// Indicates whether the vehicle is exceeding the legal speed limit set in the tachograph.
    #[allow(dead_code)]
    pub fn overspeed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn overspeed(&self) -> Overspeed2365484286 {
        Overspeed2365484286::from(self.overspeed_raw_value() as u64)
    }

    /// Read DriverCardDriver1 signal from can frame
    #[allow(dead_code)]
    pub fn driver_card_driver1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn driver_card_driver1(&self) -> DriverCardDriver12365484286 {
        DriverCardDriver12365484286::from(self.driver_card_driver1_raw_value() as u64)
    }

    /// Indicates if the driver approaches or exceeds working time limits (or other limits).
    #[allow(dead_code)]
    pub fn driver1_time_related_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn driver1_time_related_states(&self) -> Driver1TimeRelatedStates2365484286 {
        Driver1TimeRelatedStates2365484286::from(self.driver1_time_related_states_raw_value() as u64)
    }

    /// Indicates whether motion of the vehicle is detected or not.
    #[allow(dead_code)]
    pub fn drive_recognize_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn drive_recognize(&self) -> DriveRecognize2365484286 {
        DriveRecognize2365484286::from(self.drive_recognize_raw_value() as u64)
    }

    /// State of work of the driver.
    #[allow(dead_code)]
    pub fn driver2_working_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 3) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn driver2_working_state(&self) -> Driver2WorkingState2365484286 {
        Driver2WorkingState2365484286::from(self.driver2_working_state_raw_value() as u64)
    }

    /// State of work of the driver.
    #[allow(dead_code)]
    pub fn driver1_working_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn driver1_working_state(&self) -> Driver1WorkingState2365484286 {
        Driver1WorkingState2365484286::from(self.driver1_working_state_raw_value() as u64)
    }
}

/// Turbocharger Information 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci6 {
    frame_payload: Vec<u8>,
}

impl Tci6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci6 {
        frame_payload.resize(8, 0);
        Tci6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419288062);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngTurbo4CompressorOutletTemp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo4_compressor_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngTurbo3CompressorOutletTemp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo3_compressor_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngTurbo2CompressorOutletTemp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo2_compressor_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngTurbo1CompressorOutletTemp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo1_compressor_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Turbocharger Information 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci5 {
    frame_payload: Vec<u8>,
}

impl Tci5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci5 {
        frame_payload.resize(8, 0);
        Tci5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419338238);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the combustion by-products exiting the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo4_turbine_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the combustion by-products exiting the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo3_turbine_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the combustion by-products exiting the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo2_turbine_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the combustion by-products exiting the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo1_turbine_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Turbocharger Information 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci4 {
    frame_payload: Vec<u8>,
}

impl Tci4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci4 {
        frame_payload.resize(8, 0);
        Tci4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419338494);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the combustion by-products entering the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo4_turbine_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the combustion by-products entering the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo3_turbine_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the combustion by-products entering the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo2_turbine_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the combustion by-products entering the turbine side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo1_turbine_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Turbocharger Information 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci3 {
    frame_payload: Vec<u8>,
}

impl Tci3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci3 {
        frame_payload.resize(8, 0);
        Tci3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419338750);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Gage pressure of the air entering the compressor side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo4_compressor_inlet_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Gage pressure of the air entering the compressor side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo3_compressor_inlet_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Gage pressure of the air entering the compressor side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo2_compressor_inlet_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Gage pressure of the air entering the compressor side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo1_compressor_inlet_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Turbocharger Information 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci2 {
    frame_payload: Vec<u8>,
}

impl Tci2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci2 {
        frame_payload.resize(8, 0);
        Tci2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419339006);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the air entering the compressor side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo4_compressor_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the air entering the compressor side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo3_compressor_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the air entering the compressor side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo2_compressor_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the air entering the compressor side of the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo1_compressor_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Turbocharger Information 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tci1 {
    frame_payload: Vec<u8>,
}

impl Tci1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tci1 {
        frame_payload.resize(8, 0);
        Tci1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tci1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486448126);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tci1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Rotational velocity of rotor in the turbocharger.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_turbo4_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 4.000000).round() as u16
    }

    /// Rotational velocity of rotor in the turbocharger.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_turbo3_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 4.000000).round() as u16
    }

    /// Rotational velocity of rotor in the turbocharger.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_turbo2_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 4.000000).round() as u16
    }

    /// Gage pressure of oil in turbocharger lubrication system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo_lube_oil_press2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// Transmission Configuration 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tcfg2 {
    frame_payload: Vec<u8>,
}

impl Tcfg2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tcfg2 {
        frame_payload.resize(8, 0);
        Tcfg2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tcfg2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419318782);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tcfg2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TransTorqueLimit signal from can frame
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn trans_torque_limit_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Transmission Configuration
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tcfg {
    frame_payload: Vec<u8>,
}

impl Tcfg {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tcfg {
        frame_payload.resize(8, 0);
        Tcfg { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tcfg, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419357438);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tcfg::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TransGearRatio signal from can frame
    #[allow(dead_code)]
    pub fn trans_gear_ratio_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.001000).round() as u16
    }

    /// Number of forward gear ratios in the transmission, provided as part of the configuration.
    #[allow(dead_code)]
    pub fn number_of_forward_gear_ratios_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Number of reverse gear ratios in the transmission, provided as part of the transmission configuration.
    #[allow(dead_code)]
    pub fn number_of_reverse_gear_ratios_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Transmission Control 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tc1 {
    frame_payload: Vec<u8>,
}

impl Tc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tc1 {
        frame_payload.resize(8, 0);
        Tc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(201457406);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Status of the operator�s switch used to �toggle� through multiple display modes of a shift selector display.
    #[allow(dead_code)]
    pub fn trns_shft_slctor_display_mode_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trns_shft_slctor_display_mode_switch(&self) -> TrnsShftSlctorDisplayModeSwitch2348941054 {
        TrnsShftSlctorDisplayModeSwitch2348941054::from(self.trns_shft_slctor_display_mode_switch_raw_value() as u64)
    }

    /// Indicates whether transmission mode 4 is enabled.
    #[allow(dead_code)]
    pub fn trans_mode4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode4(&self) -> TransMode42348941054 {
        TransMode42348941054::from(self.trans_mode4_raw_value() as u64)
    }

    /// Indicates whether transmission mode 3 is enabled.
    #[allow(dead_code)]
    pub fn trans_mode3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode3(&self) -> TransMode32348941054 {
        TransMode32348941054::from(self.trans_mode3_raw_value() as u64)
    }

    /// Indicates whether transmission mode 2 is enabled.
    #[allow(dead_code)]
    pub fn trans_mode2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode2(&self) -> TransMode22348941054 {
        TransMode22348941054::from(self.trans_mode2_raw_value() as u64)
    }

    /// Indicates whether transmission mode 1 is enabled.
    #[allow(dead_code)]
    pub fn trans_mode1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode1(&self) -> TransMode12348941054 {
        TransMode12348941054::from(self.trans_mode1_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_central_rear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_central_rear(&self) -> DisengageDiffLockRqCentralRear2348941054 {
        DisengageDiffLockRqCentralRear2348941054::from(self.disengage_diff_lock_rq_central_rear_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_central_front_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_central_front(&self) -> DisengageDiffLockRqCentralFront2348941054 {
        DisengageDiffLockRqCentralFront2348941054::from(self.disengage_diff_lock_rq_central_front_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_central_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_central(&self) -> DisengageDiffLockRqCentral2348941054 {
        DisengageDiffLockRqCentral2348941054::from(self.disengage_diff_lock_rq_central_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_rear_axle2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_rear_axle2(&self) -> DisengageDiffLockRqRearAxle22348941054 {
        DisengageDiffLockRqRearAxle22348941054::from(self.disengage_diff_lock_rq_rear_axle2_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_rear_axle1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_rear_axle1(&self) -> DisengageDiffLockRqRearAxle12348941054 {
        DisengageDiffLockRqRearAxle12348941054::from(self.disengage_diff_lock_rq_rear_axle1_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_front_axle2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_front_axle2(&self) -> DisengageDiffLockRqFrontAxle22348941054 {
        DisengageDiffLockRqFrontAxle22348941054::from(self.disengage_diff_lock_rq_front_axle2_raw_value() as u64)
    }

    /// Command signal used to disengage the various differential locks, e.
    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_front_axle1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_diff_lock_rq_front_axle1(&self) -> DisengageDiffLockRqFrontAxle12348941054 {
        DisengageDiffLockRqFrontAxle12348941054::from(self.disengage_diff_lock_rq_front_axle1_raw_value() as u64)
    }

    /// Gear requested by the operator, ABS, or engine.
    #[allow(dead_code)]
    pub fn trans_rqed_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_rqed_gear(&self) -> TransRqedGear2348941054 {
        TransRqedGear2348941054::from(self.trans_rqed_gear_raw_value() as u64)
    }

    /// Parameter which represents the percent clutch slip requested by a device.
    /// Unit: %
    #[allow(dead_code)]
    pub fn rqed_percent_clutch_slip_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Command signal used to simply disengage the driveline, e.
    #[allow(dead_code)]
    pub fn disengage_driveline_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn disengage_driveline_rq(&self) -> DisengageDrivelineRq2348941054 {
        DisengageDrivelineRq2348941054::from(self.disengage_driveline_rq_raw_value() as u64)
    }

    /// Command signal to prevent torque converter lockup, which may cause problems in certain circumstances for ASR.
    #[allow(dead_code)]
    pub fn torque_converter_lockup_disable_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn torque_converter_lockup_disable_rq(&self) -> TorqueConverterLockupDisableRq2348941054 {
        TorqueConverterLockupDisableRq2348941054::from(self.torque_converter_lockup_disable_rq_raw_value() as u64)
    }

    /// Command signal to inhibit gear shifts.
    #[allow(dead_code)]
    pub fn trans_gear_shift_inhibit_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_gear_shift_inhibit_rq(&self) -> TransGearShiftInhibitRq2348941054 {
        TransGearShiftInhibitRq2348941054::from(self.trans_gear_shift_inhibit_rq_raw_value() as u64)
    }
}

/// Turbocharger
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tc {
    frame_payload: Vec<u8>,
}

impl Tc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tc {
        frame_payload.resize(8, 0);
        Tc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419356158);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngTurboOilLevelSwitch signal from can frame
    #[allow(dead_code)]
    pub fn eng_turbo_oil_level_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    /// Rotational velocity of rotor in the turbocharger.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_turbo1_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 4.000000).round() as u16
    }

    /// Gage pressure of oil in turbocharger lubrication system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo_lube_oil_press1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// Total Averaged Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tavg {
    frame_payload: Vec<u8>,
}

impl Tavg {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tavg {
        frame_payload.resize(8, 0);
        Tavg { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tavg, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486428158);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tavg::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngTotalAverageFuelEconomy signal from can frame
    /// Unit: km/L
    #[allow(dead_code)]
    pub fn eng_total_average_fuel_economy_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.001953).round() as u16
    }

    /// Read EngTotalAverageFuelRate signal from can frame
    /// Unit: L/h
    #[allow(dead_code)]
    pub fn eng_total_average_fuel_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Supply Pressure Demand
#[allow(dead_code)]
#[derive(Debug)]
pub struct Spr {
    frame_payload: Vec<u8>,
}

impl Spr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Spr {
        frame_payload.resize(8, 0);
        Spr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Spr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419291902);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Spr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Command signal to influence the pneumatic pressure in the circuit for the electronically controlled air suspension system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn air_suspension_supply_press_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Command signal to influence the pneumatic pressure in the auxiliary circuit.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_equipment_supply_press_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Command signal to influence the pneumatic pressure in the service brake circuit or reservoir #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn service_brake_air_press_rq_circuit2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Command signal to influence the pneumatic pressure in the service brake circuit or reservoir #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn service_brake_air_press_rq_circuit1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Command signal to influence the pneumatic pressure in the circuit or reservoir for the parking brake and/or the trailer supply.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn parking_and_or_trailer_air_press_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// Command signal to influence the pneumatic pressure in the main reservoir.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn pneumatic_supply_press_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 8.000000).round() as u8
    }
}

/// Supply Pressure 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Sp2 {
    frame_payload: Vec<u8>,
}

impl Sp2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Sp2 {
        frame_payload.resize(8, 0);
        Sp2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Sp2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419336190);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Sp2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Pressure of the air used to shut off the fuel supply to the engine.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_extl_shutdown_air_supply_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Software Identification
#[allow(dead_code)]
#[derive(Debug)]
pub struct Soft {
    frame_payload: Vec<u8>,
}

impl Soft {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Soft {
        frame_payload.resize(8, 0);
        Soft { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Soft, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419355390);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Soft::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Number of software identification designators represented in the software identification parameter group.
    /// Unit: steps
    #[allow(dead_code)]
    pub fn nmbr_of_sftwr_identification_fields_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Shutdown
#[allow(dead_code)]
#[derive(Debug)]
pub struct Shutdow {
    frame_payload: Vec<u8>,
}

impl Shutdow {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Shutdow {
        frame_payload.resize(8, 0);
        Shutdow { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Shutdow, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419357950);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Shutdow::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The engine overspeed test signal as measured by the reporting ECM.
    #[allow(dead_code)]
    pub fn eng_overspeed_test_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_overspeed_test(&self) -> EngOverspeedTest2566841598 {
        EngOverspeedTest2566841598::from(self.eng_overspeed_test_raw_value() as u64)
    }

    /// State signal which indicates when the Air Shutoff driver output is being driven.
    #[allow(dead_code)]
    pub fn eng_air_shutoff_cmd_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_air_shutoff_cmd_status(&self) -> EngAirShutoffCmdStatus2566841598 {
        EngAirShutoffCmdStatus2566841598::from(self.eng_air_shutoff_cmd_status_raw_value() as u64)
    }

    /// State signal which indicates when the Alarm driver output is being driven.
    #[allow(dead_code)]
    pub fn eng_alarm_output_cmd_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alarm_output_cmd_status(&self) -> EngAlarmOutputCmdStatus2566841598 {
        EngAlarmOutputCmdStatus2566841598::from(self.eng_alarm_output_cmd_status_raw_value() as u64)
    }

    /// The Engine Alarm Acknowledge Input signal as measured by the reporting ECM.
    #[allow(dead_code)]
    pub fn eng_alarm_acknowledge_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alarm_acknowledge(&self) -> EngAlarmAcknowledge2566841598 {
        EngAlarmAcknowledge2566841598::from(self.eng_alarm_acknowledge_raw_value() as u64)
    }

    /// Parameter which indicates the configuration of the engine shutdown system.
    #[allow(dead_code)]
    pub fn eng_protection_system_config_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_protection_system_config(&self) -> EngProtectionSystemConfig2566841598 {
        EngProtectionSystemConfig2566841598::from(self.eng_protection_system_config_raw_value() as u64)
    }

    /// Status signal which indicates the current mode of the engine protection system timer system.
    #[allow(dead_code)]
    pub fn eng_protection_system_timer_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_protection_system_timer_state(&self) -> EngProtectionSystemTimerState2566841598 {
        EngProtectionSystemTimerState2566841598::from(self.eng_protection_system_timer_state_raw_value() as u64)
    }

    /// Status signal which indicates the status of the override feature of the engine protection system timer.
    #[allow(dead_code)]
    pub fn eng_prtection_system_timer_override_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_prtection_system_timer_override(&self) -> EngPrtectionSystemTimerOverride2566841598 {
        EngPrtectionSystemTimerOverride2566841598::from(self.eng_prtection_system_timer_override_raw_value() as u64)
    }

    /// Status signal which indicates that engine shutdown is imminent.
    #[allow(dead_code)]
    pub fn eng_prtctn_systm_apprching_shutdown_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_prtctn_systm_apprching_shutdown(&self) -> EngPrtctnSystmApprchingShutdown2566841598 {
        EngPrtctnSystmApprchingShutdown2566841598::from(self.eng_prtctn_systm_apprching_shutdown_raw_value() as u64)
    }

    /// Status signal which indicates whether or not the engine protection system has shutdown the engine.
    #[allow(dead_code)]
    pub fn eng_prtction_system_has_shutdown_eng_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_prtction_system_has_shutdown_eng(&self) -> EngPrtctionSystemHasShutdownEng2566841598 {
        EngPrtctionSystemHasShutdownEng2566841598::from(self.eng_prtction_system_has_shutdown_eng_raw_value() as u64)
    }

    /// Read EngWaitToStartLamp signal from can frame
    #[allow(dead_code)]
    pub fn eng_wait_to_start_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_wait_to_start_lamp(&self) -> EngWaitToStartLamp2566841598 {
        EngWaitToStartLamp2566841598::from(self.eng_wait_to_start_lamp_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the high pressure switch in the coolant circuit of an air conditioning system.
    #[allow(dead_code)]
    pub fn refrigerant_high_press_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn refrigerant_high_press_switch(&self) -> RefrigerantHighPressSwitch2566841598 {
        RefrigerantHighPressSwitch2566841598::from(self.refrigerant_high_press_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the low pressure switch in the coolant circuit of an air conditioning system.
    #[allow(dead_code)]
    pub fn refrigerant_low_press_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn refrigerant_low_press_switch(&self) -> RefrigerantLowPressSwitch2566841598 {
        RefrigerantLowPressSwitch2566841598::from(self.refrigerant_low_press_switch_raw_value() as u64)
    }

    /// Read A_CHighPressFanSwitch signal from can frame
    #[allow(dead_code)]
    pub fn a_c_high_press_fan_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn a_c_high_press_fan_switch(&self) -> ACHighPressFanSwitch2566841598 {
        ACHighPressFanSwitch2566841598::from(self.a_c_high_press_fan_switch_raw_value() as u64)
    }

    /// Parameter which indicates the configuration of the idle shutdown timer system.
    #[allow(dead_code)]
    pub fn eng_idle_shutdown_timer_function_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_shutdown_timer_function(&self) -> EngIdleShutdownTimerFunction2566841598 {
        EngIdleShutdownTimerFunction2566841598::from(self.eng_idle_shutdown_timer_function_raw_value() as u64)
    }

    /// Status signal which indicates the current mode of operation of the idle shutdown timer system.
    #[allow(dead_code)]
    pub fn eng_idle_shutdown_timer_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_shutdown_timer_state(&self) -> EngIdleShutdownTimerState2566841598 {
        EngIdleShutdownTimerState2566841598::from(self.eng_idle_shutdown_timer_state_raw_value() as u64)
    }

    /// Status signal which indicates the status of the override feature of the idle shutdown timer system.
    #[allow(dead_code)]
    pub fn eng_idle_shutdown_timer_override_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_shutdown_timer_override(&self) -> EngIdleShutdownTimerOverride2566841598 {
        EngIdleShutdownTimerOverride2566841598::from(self.eng_idle_shutdown_timer_override_raw_value() as u64)
    }

    /// Status signal which indicates the status of the driver alert mode of the idle shutdown timer system.
    #[allow(dead_code)]
    pub fn eng_idle_shutdown_driver_alert_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_shutdown_driver_alert_mode(&self) -> EngIdleShutdownDriverAlertMode2566841598 {
        EngIdleShutdownDriverAlertMode2566841598::from(self.eng_idle_shutdown_driver_alert_mode_raw_value() as u64)
    }

    /// Status signal which identifies whether or not the engine has been shutdown by the idle shutdown timer system.
    #[allow(dead_code)]
    pub fn eng_idle_shutdown_has_shutdown_eng_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_shutdown_has_shutdown_eng(&self) -> EngIdleShutdownHasShutdownEng2566841598 {
        EngIdleShutdownHasShutdownEng2566841598::from(self.eng_idle_shutdown_has_shutdown_eng_raw_value() as u64)
    }
}

/// Service Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Serv {
    frame_payload: Vec<u8>,
}

impl Serv {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Serv {
        frame_payload.resize(8, 0);
        Serv { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Serv, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419348734);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Serv::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identification of component needing service.
    /// Unit: ID
    #[allow(dead_code)]
    pub fn service_component_identification_b_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Identification of component needing service.
    /// Unit: ID
    #[allow(dead_code)]
    pub fn service_component_identification_a_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// The time in vehicle operational time until the next vehicle service inspection is required.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn srvce_delay_operational_time_based_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The time in weeks until the next vehicle service inspection is required.
    /// Unit: weeks
    #[allow(dead_code)]
    pub fn service_delay_calendar_time_based_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// The distance which can be traveled by the vehicle before the next service inspection is required.
    /// Unit: km
    #[allow(dead_code)]
    pub fn service_distance_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 5.000000).round() as u16
    }

    /// Identification of component needing service.
    /// Unit: ID
    #[allow(dead_code)]
    pub fn service_component_identification_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }
}

/// Service 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct S2 {
    frame_payload: Vec<u8>,
}

impl S2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> S2 {
        frame_payload.resize(8, 0);
        S2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<S2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486444798);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| S2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The vehicle operation time since the last service was performed.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn time_since_last_service_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF)) as u16
    }

    /// Identification of component needing service.
    /// Unit: ID
    #[allow(dead_code)]
    pub fn service_component_identification_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Retarder Continuous Torque & Speed Limit
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rtc1 {
    frame_payload: Vec<u8>,
}

impl Rtc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rtc1 {
        frame_payload.resize(8, 0);
        Rtc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rtc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419320830);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rtc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Applied limit for maximum continuous retarder torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn max_continuous_retarder_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Read MinContinuousRetarderSpeed signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn min_continuous_retarder_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read MaxContinuousRetarderSpeed signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn max_continuous_retarder_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Maximum allowable value for minimum continuous retarder torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn hgh_lmt_thrshhld_fr_mn_cntns_trq_frm_rtr_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Minimum allowable value for maximum continuous retarder torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn lw_lmt_thrshhld_fr_mx_trq_frm_retarder_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read HghLmtThrshhldFrMnCntnsRPMFrmRtr signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn hgh_lmt_thrshhld_fr_mn_cntns_rpm_frm_rtr_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read LwLmtThrshhldFrMxRPMFrmRetarder signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn lw_lmt_thrshhld_fr_mx_rpm_frm_retarder_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read MinContinuousRetarderTorque signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn min_continuous_retarder_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }
}

/// Retarder fluids
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rf {
    frame_payload: Vec<u8>,
}

impl Rf {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rf {
        frame_payload.resize(8, 0);
        Rf { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rf, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419363838);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rf::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of oil found in a hydraulic retarder.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn hyd_retarder_oil_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Gage pressure of oil in hydraulic retarder system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn hyd_retarder_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 16.000000).round() as u8
    }
}

/// Reset
#[allow(dead_code)]
#[derive(Debug)]
pub struct Reset {
    frame_payload: Vec<u8>,
}

impl Reset {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Reset {
        frame_payload.resize(8, 0);
        Reset { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Reset, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(484376318);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Reset::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Command signal used to reset the engine rebuild hours.
    #[allow(dead_code)]
    pub fn eng_build_hours_reset_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_build_hours_reset(&self) -> EngBuildHoursReset2631859966 {
        EngBuildHoursReset2631859966::from(self.eng_build_hours_reset_raw_value() as u64)
    }

    /// Identification of component needing service.
    /// Unit: ID
    #[allow(dead_code)]
    pub fn service_component_identification_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Command signal used to reset proprietary parameters associated with a trip but not defined within this document.
    #[allow(dead_code)]
    pub fn trip_group2_proprietary_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trip_group2_proprietary(&self) -> TripGroup2Proprietary2631859966 {
        TripGroup2Proprietary2631859966::from(self.trip_group2_proprietary_raw_value() as u64)
    }

    /// Command signal used to reset the PGNs and parameters as defined in Table SPN988_A.
    #[allow(dead_code)]
    pub fn trip_group1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trip_group1(&self) -> TripGroup12631859966 {
        TripGroup12631859966::from(self.trip_group1_raw_value() as u64)
    }
}

/// Retarder Configuration
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rc {
    frame_payload: Vec<u8>,
}

impl Rc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rc {
        frame_payload.resize(8, 0);
        Rc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419357182);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read PercentTorqueAtPeakTorquePoint5 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_torque_at_peak_torque_point5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFF)) as u8
    }

    /// This parameter is the 100% reference value for all defined indicated retarder torque parameters.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn reference_retarder_torque_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFF)) as u16
    }

    /// Read RetarderSpeedAtPeakTorquePoint5 signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn retarder_speed_at_peak_torque_point5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read PercentTorqueAtPoint4 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_torque_at_point4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0xFF)) as u8
    }

    /// Retarder speed of point 4 of the engine retarder torque map.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn retarder_speed_at_point4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 88) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read PercentTorqueAtPoint3 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_torque_at_point3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFF)) as u8
    }

    /// Retarder speed of point 3 of the engine retarder torque map.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn retarder_speed_at_point3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The torque limit that indicates the available retarder torque which can be provided by the retarder at its maximum speed.
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_torque_at_max_speed_point2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Maximum speed of retarder (Please reference PGN 65249).
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn max_retarder_speed_point2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The torque limit that indicates the available retarder torque which can be provided by the retarder at idle speed.
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_torque_at_idle_point1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Read RetarderSpeedAtIdlePoint1 signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn retarder_speed_at_idle_point1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// This parameter identifies the number of steps used by the retarder.
    /// Unit: steps
    #[allow(dead_code)]
    pub fn retarder_ctrl_method_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Read RetarderLocation signal from can frame
    #[allow(dead_code)]
    pub fn retarder_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn retarder_location(&self) -> RetarderLocation2566840830 {
        RetarderLocation2566840830::from(self.retarder_location_raw_value() as u64)
    }

    /// A vehicle retarder is a supplementary device to the wheel brakes for the driver to better control the vehicle.
    #[allow(dead_code)]
    pub fn retarder_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn retarder_type(&self) -> RetarderType2566840830 {
        RetarderType2566840830::from(self.retarder_type_raw_value() as u64)
    }
}

/// Rebuild Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rbi {
    frame_payload: Vec<u8>,
}

impl Rbi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rbi {
        frame_payload.resize(8, 0);
        Rbi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rbi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486446590);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rbi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The time in engine operation since the last engine rebuild.
    /// Unit: s
    #[allow(dead_code)]
    pub fn eng_operation_time_since_rebuild_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Power Takeoff Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Pto {
    frame_payload: Vec<u8>,
}

impl Pto {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Pto {
        frame_payload.resize(8, 0);
        Pto { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Pto, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419361022);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Pto::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Measured state of the operator PTO memory select switch.
    #[allow(dead_code)]
    pub fn operator_pto_memory_select_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn operator_pto_memory_select_switch(&self) -> OperatorPtoMemorySelectSwitch2566844670 {
        OperatorPtoMemorySelectSwitch2566844670::from(self.operator_pto_memory_select_switch_raw_value() as u64)
    }

    /// Switch signal of the PTO control activator which indicates that the activator is in the position 'accelerate'.
    #[allow(dead_code)]
    pub fn eng_pto_accelerate_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_pto_accelerate_switch(&self) -> EngPtoAccelerateSwitch2566844670 {
        EngPtoAccelerateSwitch2566844670::from(self.eng_pto_accelerate_switch_raw_value() as u64)
    }

    /// Switch signal of the PTO control activator which indicates that the activator is in the position 'resume'.
    #[allow(dead_code)]
    pub fn eng_pto_resume_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_pto_resume_switch(&self) -> EngPtoResumeSwitch2566844670 {
        EngPtoResumeSwitch2566844670::from(self.eng_pto_resume_switch_raw_value() as u64)
    }

    /// Switch signal of the PTO control activator which indicates that the activator is in the position 'coast/decelerate'.
    #[allow(dead_code)]
    pub fn eng_pto_coast_decelerate_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_pto_coast_decelerate_switch(&self) -> EngPtoCoastDecelerateSwitch2566844670 {
        EngPtoCoastDecelerateSwitch2566844670::from(self.eng_pto_coast_decelerate_switch_raw_value() as u64)
    }

    /// Switch signal of the PTO control activator which indicates that the activator is in the position 'set'.
    #[allow(dead_code)]
    pub fn eng_pto_set_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_pto_set_switch(&self) -> EngPtoSetSwitch2566844670 {
        EngPtoSetSwitch2566844670::from(self.eng_pto_set_switch_raw_value() as u64)
    }

    /// Switch signal which indicates that the remote PTO toggle switch is in the enabled (ON) position.
    #[allow(dead_code)]
    pub fn eng_rmt_pto_vriable_speed_ctrl_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_rmt_pto_vriable_speed_ctrl_switch(&self) -> EngRmtPtoVriableSpeedCtrlSwitch2566844670 {
        EngRmtPtoVriableSpeedCtrlSwitch2566844670::from(self.eng_rmt_pto_vriable_speed_ctrl_switch_raw_value() as u64)
    }

    /// Switch signal which indicates that the remote PTO toggle switch is in the enabled (ON) position.
    #[allow(dead_code)]
    pub fn eng_rmt_pto_prprgrmmd_spd_ctrl_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_rmt_pto_prprgrmmd_spd_ctrl_switch(&self) -> EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670 {
        EngRmtPtoPrprgrmmdSpdCtrlSwitch2566844670::from(self.eng_rmt_pto_prprgrmmd_spd_ctrl_switch_raw_value() as u64)
    }

    /// Read EngPTOEnableSwitch signal from can frame
    #[allow(dead_code)]
    pub fn eng_pto_enable_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_pto_enable_switch(&self) -> EngPtoEnableSwitch2566844670 {
        EngPtoEnableSwitch2566844670::from(self.eng_pto_enable_switch_raw_value() as u64)
    }

    /// Rotational velocity selected by operator for device used to transmit engine power to auxiliary equipment.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn power_takeoff_set_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Rotational velocity of device used to transmit engine power to auxiliary equipment.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn power_takeoff_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Temperature of lubricant in device used to transmit engine power to auxiliary equipment.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn power_takeoff_oil_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Switch signal which indicates that the remote PTO toggle switch #2 is in the enabled (ON) position.
    #[allow(dead_code)]
    pub fn rmt_pto_prprgrmmd_speed_ctrl_switch2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rmt_pto_prprgrmmd_speed_ctrl_switch2(&self) -> RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670 {
        RmtPtoPrprgrmmdSpeedCtrlSwitch22566844670::from(self.rmt_pto_prprgrmmd_speed_ctrl_switch2_raw_value() as u64)
    }

    /// Switch signal which overrides other switch input's ability to kick out of an engine's operating condition.
    #[allow(dead_code)]
    pub fn aux_input_ignore_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_input_ignore_switch(&self) -> AuxInputIgnoreSwitch2566844670 {
        AuxInputIgnoreSwitch2566844670::from(self.aux_input_ignore_switch_raw_value() as u64)
    }
}

/// Operator Wiper and Washer Controls Message
#[allow(dead_code)]
#[derive(Debug)]
pub struct Oww {
    frame_payload: Vec<u8>,
}

impl Oww {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Oww {
        frame_payload.resize(8, 0);
        Oww { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Oww, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419286526);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Oww::new(frame.data().to_vec())));
        Ok(f)
    }

    /// State of operation selected by operator switch for the rear washer.
    #[allow(dead_code)]
    pub fn rear_washer_function_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_washer_function(&self) -> RearWasherFunction2566770174 {
        RearWasherFunction2566770174::from(self.rear_washer_function_raw_value() as u64)
    }

    /// State of operation selected by operator switch for the washer in front of the operator position.
    #[allow(dead_code)]
    pub fn front_operator_washer_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 45) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn front_operator_washer_switch(&self) -> FrontOperatorWasherSwitch2566770174 {
        FrontOperatorWasherSwitch2566770174::from(self.front_operator_washer_switch_raw_value() as u64)
    }

    /// State of operation selected by operator switch for the front washer not in front of the operator position.
    #[allow(dead_code)]
    pub fn front_nonoperator_washer_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn front_nonoperator_washer_switch(&self) -> FrontNonoperatorWasherSwitch2566770174 {
        FrontNonoperatorWasherSwitch2566770174::from(self.front_nonoperator_washer_switch_raw_value() as u64)
    }

    /// Time between cycles of the rear wiper (i.
    /// Unit: %
    #[allow(dead_code)]
    pub fn rear_wiper_delay_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Time between cycles of the front non-operator side wiper (i.
    /// Unit: %
    #[allow(dead_code)]
    pub fn front_nonoperator_wiper_delay_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Time between cycles of the front operator side wiper (i.
    /// Unit: %
    #[allow(dead_code)]
    pub fn front_operator_wiper_delay_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// State of operation selected by operator switch for the rear wiper.
    #[allow(dead_code)]
    pub fn rear_wiper_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_wiper_switch(&self) -> RearWiperSwitch2566770174 {
        RearWiperSwitch2566770174::from(self.rear_wiper_switch_raw_value() as u64)
    }

    /// State of operation selected by operator switch for the Wiper in front of the operator position.
    #[allow(dead_code)]
    pub fn front_operator_wiper_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn front_operator_wiper_switch(&self) -> FrontOperatorWiperSwitch2566770174 {
        FrontOperatorWiperSwitch2566770174::from(self.front_operator_wiper_switch_raw_value() as u64)
    }

    /// State of operation selected by operator switch for the front wiper not in front of the operator position.
    #[allow(dead_code)]
    pub fn front_nonoperator_wiper_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn front_nonoperator_wiper_switch(&self) -> FrontNonoperatorWiperSwitch2566770174 {
        FrontNonoperatorWiperSwitch2566770174::from(self.front_nonoperator_wiper_switch_raw_value() as u64)
    }
}

/// Off-Highway Engine Control Selection
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ohecs {
    frame_payload: Vec<u8>,
}

impl Ohecs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ohecs {
        frame_payload.resize(8, 0);
        Ohecs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ohecs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419286014);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ohecs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngAltDroopAuxInputSelect signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_aux_input_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_aux_input_select(&self) -> EngAltDroopAuxInputSelect2566769662 {
        EngAltDroopAuxInputSelect2566769662::from(self.eng_alt_droop_aux_input_select_raw_value() as u64)
    }

    /// Read EngAltDroopRemoteAccelSelect signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_remote_accel_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_remote_accel_select(&self) -> EngAltDroopRemoteAccelSelect2566769662 {
        EngAltDroopRemoteAccelSelect2566769662::from(self.eng_alt_droop_remote_accel_select_raw_value() as u64)
    }

    /// Read EngAltDroopAccel2Select signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_accel2_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_accel2_select(&self) -> EngAltDroopAccel2Select2566769662 {
        EngAltDroopAccel2Select2566769662::from(self.eng_alt_droop_accel2_select_raw_value() as u64)
    }

    /// Read EngAltDroopAccel1Select signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_accel1_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_accel1_select(&self) -> EngAltDroopAccel1Select2566769662 {
        EngAltDroopAccel1Select2566769662::from(self.eng_alt_droop_accel1_select_raw_value() as u64)
    }

    /// In some off-highway applications it may be desirable to have multiple engine ratings available for selection by the operator.
    #[allow(dead_code)]
    pub fn eng_alt_rating_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_rating_select(&self) -> EngAltRatingSelect2566769662 {
        EngAltRatingSelect2566769662::from(self.eng_alt_rating_select_raw_value() as u64)
    }

    /// Operator switch which selects between two low idle speeds, default and alternate.
    #[allow(dead_code)]
    pub fn eng_alt_low_idle_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_low_idle_switch(&self) -> EngAltLowIdleSwitch2566769662 {
        EngAltLowIdleSwitch2566769662::from(self.eng_alt_low_idle_switch_raw_value() as u64)
    }

    /// This is the On/Off operation of the Multiple Unit Synchronization functionality.
    #[allow(dead_code)]
    pub fn eng_synchronization_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_synchronization_switch(&self) -> EngSynchronizationSwitch2566769662 {
        EngSynchronizationSwitch2566769662::from(self.eng_synchronization_switch_raw_value() as u64)
    }

    /// This is the On/Off operation of the Auxiliary Governor feature switch.
    #[allow(dead_code)]
    pub fn eng_aux_governor_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_aux_governor_switch(&self) -> EngAuxGovernorSwitch2566769662 {
        EngAuxGovernorSwitch2566769662::from(self.eng_aux_governor_switch_raw_value() as u64)
    }
}

/// Off-Highway Engine Control Selection States
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ohcss {
    frame_payload: Vec<u8>,
}

impl Ohcss {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ohcss {
        frame_payload.resize(8, 0);
        Ohcss { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ohcss, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419284990);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ohcss::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngAltDroopAuxInputSelectState signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_aux_input_select_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_aux_input_select_state(&self) -> EngAltDroopAuxInputSelectState2566768638 {
        EngAltDroopAuxInputSelectState2566768638::from(self.eng_alt_droop_aux_input_select_state_raw_value() as u64)
    }

    /// Read EngAltDrpRemoteAccelSelectState signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_drp_remote_accel_select_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_drp_remote_accel_select_state(&self) -> EngAltDrpRemoteAccelSelectState2566768638 {
        EngAltDrpRemoteAccelSelectState2566768638::from(self.eng_alt_drp_remote_accel_select_state_raw_value() as u64)
    }

    /// Read EngAltDroopAccel2SelectState signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_accel2_select_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_accel2_select_state(&self) -> EngAltDroopAccel2SelectState2566768638 {
        EngAltDroopAccel2SelectState2566768638::from(self.eng_alt_droop_accel2_select_state_raw_value() as u64)
    }

    /// Read EngAltDroopAccel1SelectState signal from can frame
    #[allow(dead_code)]
    pub fn eng_alt_droop_accel1_select_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_droop_accel1_select_state(&self) -> EngAltDroopAccel1SelectState2566768638 {
        EngAltDroopAccel1SelectState2566768638::from(self.eng_alt_droop_accel1_select_state_raw_value() as u64)
    }

    /// In some off-highway applications it may be desirable to have multiple engine ratings available for selection by the operator.
    #[allow(dead_code)]
    pub fn eng_alt_rating_select_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_rating_select_state(&self) -> EngAltRatingSelectState2566768638 {
        EngAltRatingSelectState2566768638::from(self.eng_alt_rating_select_state_raw_value() as u64)
    }

    /// In many applications, it is desirable that an alternate low idle speed setting be made available via switch input.
    #[allow(dead_code)]
    pub fn eng_alt_low_idle_select_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_alt_low_idle_select_state(&self) -> EngAltLowIdleSelectState2566768638 {
        EngAltLowIdleSelectState2566768638::from(self.eng_alt_low_idle_select_state_raw_value() as u64)
    }

    /// This feature is widely used in Industry to operate multiple engines from a single command source.
    #[allow(dead_code)]
    pub fn eng_multi_unit_sync_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_multi_unit_sync_state(&self) -> EngMultiUnitSyncState2566768638 {
        EngMultiUnitSyncState2566768638::from(self.eng_multi_unit_sync_state_raw_value() as u64)
    }

    /// This is the Engine Auxiliary Governor feature.
    #[allow(dead_code)]
    pub fn eng_aux_governor_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_aux_governor_state(&self) -> EngAuxGovernorState2566768638 {
        EngAuxGovernorState2566768638::from(self.eng_aux_governor_state_raw_value() as u64)
    }
}

/// Operators External Light Controls Message
#[allow(dead_code)]
#[derive(Debug)]
pub struct Oel {
    frame_payload: Vec<u8>,
}

impl Oel {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Oel {
        frame_payload.resize(8, 0);
        Oel { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Oel, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217959678);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Oel::new(frame.data().to_vec())));
        Ok(f)
    }

    /// A 16 bit parameter to be associated with Delayed Off position (1000 binary) of the Main Light Switch.
    /// Unit: s
    #[allow(dead_code)]
    pub fn oprtrs_desired_delayed_lamp_off_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF)) as u16
    }

    /// A 8 bit parameter to indicate the level of back lighting the operator has selected for displays.
    /// Unit: %
    #[allow(dead_code)]
    pub fn operators_desired_backlight_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// A 2 bit parameter to indicate the selected position of the operator's high/low beam select switch.
    #[allow(dead_code)]
    pub fn high_low_beam_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn high_low_beam_switch(&self) -> HighLowBeamSwitch2365443326 {
        HighLowBeamSwitch2365443326::from(self.high_low_beam_switch_raw_value() as u64)
    }

    /// A 2 bit parameter to indicate the selected position of the operator's hazard light switch.
    #[allow(dead_code)]
    pub fn hazard_light_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn hazard_light_switch(&self) -> HazardLightSwitch2365443326 {
        HazardLightSwitch2365443326::from(self.hazard_light_switch_raw_value() as u64)
    }

    /// A 4 bit parameter to indicate the selected position of the operator's turn signal switch.
    #[allow(dead_code)]
    pub fn turn_signal_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn turn_signal_switch(&self) -> TurnSignalSwitch2365443326 {
        TurnSignalSwitch2365443326::from(self.turn_signal_switch_raw_value() as u64)
    }

    /// A 4 bit parameter to indicate the selected position of the operator's main light switch.
    #[allow(dead_code)]
    pub fn main_light_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn main_light_switch(&self) -> MainLightSwitch2365443326 {
        MainLightSwitch2365443326::from(self.main_light_switch_raw_value() as u64)
    }

    /// A 4 bit parameter to indicate the selected position of the operator's work light switch.
    #[allow(dead_code)]
    pub fn work_light_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn work_light_switch(&self) -> WorkLightSwitch2365443326 {
        WorkLightSwitch2365443326::from(self.work_light_switch_raw_value() as u64)
    }
}

/// Maximum Vehicle Speed Limit Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Mvs {
    frame_payload: Vec<u8>,
}

impl Mvs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Mvs {
        frame_payload.resize(8, 0);
        Mvs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Mvs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419292670);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Mvs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The vehicle speed limit in effect.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn applied_vehicle_speed_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Read MaxVehicleSpeedLimit7 signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit7_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Read MaxVehicleSpeedLimit6 signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit6_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Read MaxVehicleSpeedLimit5 signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Read MaxVehicleSpeedLimit4 signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Read MaxVehicleSpeedLimit3 signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read MaxVehicleSpeedLimit2 signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// The lowest Maximum Vehicle Speed Limit.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Military Lighting Command
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ml {
    frame_payload: Vec<u8>,
}

impl Ml {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ml {
        frame_payload.resize(8, 0);
        Ml { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ml, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419319038);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ml::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Operators Selection of lamp intensity in black out mode.
    /// Unit: %
    #[allow(dead_code)]
    pub fn oprtrs_blck_out_intensity_selection_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read BlackOutWorkLampSelect signal from can frame
    #[allow(dead_code)]
    pub fn black_out_work_lamp_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn black_out_work_lamp_select(&self) -> BlackOutWorkLampSelect2566802686 {
        BlackOutWorkLampSelect2566802686::from(self.black_out_work_lamp_select_raw_value() as u64)
    }

    /// Read NightVisionIlluminatorSelect signal from can frame
    #[allow(dead_code)]
    pub fn night_vision_illuminator_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn night_vision_illuminator_select(&self) -> NightVisionIlluminatorSelect2566802686 {
        NightVisionIlluminatorSelect2566802686::from(self.night_vision_illuminator_select_raw_value() as u64)
    }

    /// Read BlackOutBrake_StopLampSelect signal from can frame
    #[allow(dead_code)]
    pub fn black_out_brake_stop_lamp_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn black_out_brake_stop_lamp_select(&self) -> BlackOutBrakeStopLampSelect2566802686 {
        BlackOutBrakeStopLampSelect2566802686::from(self.black_out_brake_stop_lamp_select_raw_value() as u64)
    }

    /// Read ConvoyDrivingLampSelect signal from can frame
    #[allow(dead_code)]
    pub fn convoy_driving_lamp_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn convoy_driving_lamp_select(&self) -> ConvoyDrivingLampSelect2566802686 {
        ConvoyDrivingLampSelect2566802686::from(self.convoy_driving_lamp_select_raw_value() as u64)
    }

    /// Read ConvoyLampSelect signal from can frame
    #[allow(dead_code)]
    pub fn convoy_lamp_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn convoy_lamp_select(&self) -> ConvoyLampSelect2566802686 {
        ConvoyLampSelect2566802686::from(self.convoy_lamp_select_raw_value() as u64)
    }

    /// Read FrontBlackOutMarkerLampSelect signal from can frame
    #[allow(dead_code)]
    pub fn front_black_out_marker_lamp_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn front_black_out_marker_lamp_select(&self) -> FrontBlackOutMarkerLampSelect2566802686 {
        FrontBlackOutMarkerLampSelect2566802686::from(self.front_black_out_marker_lamp_select_raw_value() as u64)
    }

    /// Read RearBlackOutMarkerSelect signal from can frame
    #[allow(dead_code)]
    pub fn rear_black_out_marker_select_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_black_out_marker_select(&self) -> RearBlackOutMarkerSelect2566802686 {
        RearBlackOutMarkerSelect2566802686::from(self.rear_black_out_marker_select_raw_value() as u64)
    }
}

/// Marine Control Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Mci {
    frame_payload: Vec<u8>,
}

impl Mci {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Mci {
        frame_payload.resize(8, 0);
        Mci { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Mci, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419290366);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Mci::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The status of the Slow Vessel Mode.
    #[allow(dead_code)]
    pub fn slow_vessel_mode_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn slow_vessel_mode_status(&self) -> SlowVesselModeStatus2566774014 {
        SlowVesselModeStatus2566774014::from(self.slow_vessel_mode_status_raw_value() as u64)
    }

    /// The status of the Trolling Mode.
    #[allow(dead_code)]
    pub fn trolling_mode_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trolling_mode_status(&self) -> TrollingModeStatus2566774014 {
        TrollingModeStatus2566774014::from(self.trolling_mode_status_raw_value() as u64)
    }

    /// The status of the Throttle Synchronization Mode.
    #[allow(dead_code)]
    pub fn eng_thrttl_synchrnztion_mode_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_thrttl_synchrnztion_mode_status(&self) -> EngThrttlSynchrnztionModeStatus2566774014 {
        EngThrttlSynchrnztionModeStatus2566774014::from(self.eng_thrttl_synchrnztion_mode_status_raw_value() as u64)
    }
}

/// Main Bearing Temperature 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Mbt3 {
    frame_payload: Vec<u8>,
}

impl Mbt3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Mbt3 {
        frame_payload.resize(8, 0);
        Mbt3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Mbt3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419339518);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Mbt3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing11_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing10_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing9_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Main Bearing Temperature 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Mbt2 {
    frame_payload: Vec<u8>,
}

impl Mbt2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Mbt2 {
        frame_payload.resize(8, 0);
        Mbt2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Mbt2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419339774);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Mbt2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing8_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing7_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing6_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing5_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Main Bearing Temperature 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Mbt1 {
    frame_payload: Vec<u8>,
}

impl Mbt1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Mbt1 {
        frame_payload.resize(8, 0);
        Mbt1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Mbt1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419340030);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Mbt1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing4_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing3_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing2_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the main bearing which supports the crankshaft of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_main_bearing1_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Laser Leveling System Vertical Position Display Data
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lvdd {
    frame_payload: Vec<u8>,
}

impl Lvdd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lvdd {
        frame_payload.resize(8, 0);
        Lvdd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lvdd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(285112062);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lvdd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Sets Display Deadbands mode.
    #[allow(dead_code)]
    pub fn display_deadbands_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn display_deadbands(&self) -> DisplayDeadbands2432595710 {
        DisplayDeadbands2432595710::from(self.display_deadbands_raw_value() as u64)
    }

    /// Sets LED Pattern control mode on laser leveling systems.
    #[allow(dead_code)]
    pub fn led_pattern_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn led_pattern_ctrl(&self) -> LedPatternCtrl2432595710 {
        LedPatternCtrl2432595710::from(self.led_pattern_ctrl_raw_value() as u64)
    }

    /// This parameter informs the system what the selected Display deadband will be.
    #[allow(dead_code)]
    pub fn led_display_deadband_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn led_display_deadband_ctrl(&self) -> LedDisplayDeadbandCtrl2432595710 {
        LedDisplayDeadbandCtrl2432595710::from(self.led_display_deadband_ctrl_raw_value() as u64)
    }

    /// This parameter informs the system what the selected Display mode will be.
    #[allow(dead_code)]
    pub fn led_display_mode_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn led_display_mode_ctrl(&self) -> LedDisplayModeCtrl2432595710 {
        LedDisplayModeCtrl2432595710::from(self.led_display_mode_ctrl_raw_value() as u64)
    }

    /// Informs display devices how to display the current vertical position.
    #[allow(dead_code)]
    pub fn led_display_data1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn led_display_data1(&self) -> LedDisplayData12432595710 {
        LedDisplayData12432595710::from(self.led_display_data1_raw_value() as u64)
    }
}

/// Laser Leveling System Vertical Deviation
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lvd {
    frame_payload: Vec<u8>,
}

impl Lvd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lvd {
        frame_payload.resize(8, 0);
        Lvd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lvd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218002942);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lvd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Laser Strike location on the survey type laser receiver.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn abs_laser_strike_position_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Time from laser strike to CAN message transmission.
    /// Unit: s
    #[allow(dead_code)]
    pub fn laser_strike_data_latency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 51.200000).round() as u16
    }

    /// Identifies which type of Laser Receiver transmitted the message.
    #[allow(dead_code)]
    pub fn laser_receiver_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn laser_receiver_type(&self) -> LaserReceiverType2365486590 {
        LaserReceiverType2365486590::from(self.laser_receiver_type_raw_value() as u64)
    }

    /// The calculated distance from the laser strike position to the current land leveling system reference point.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn laser_strike_vertical_deviation_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Laser Tracer Position
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ltp {
    frame_payload: Vec<u8>,
}

impl Ltp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ltp {
        frame_payload.resize(8, 0);
        Ltp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ltp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218001918);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ltp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Provides the status of the laser tracer to the operator.
    #[allow(dead_code)]
    pub fn laser_tracer_information_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn laser_tracer_information(&self) -> LaserTracerInformation2365485566 {
        LaserTracerInformation2365485566::from(self.laser_tracer_information_raw_value() as u64)
    }

    /// Informs display devices how to display the current position of the laser tracer.
    #[allow(dead_code)]
    pub fn led_display_data2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn led_display_data2(&self) -> LedDisplayData22365485566 {
        LedDisplayData22365485566::from(self.led_display_data2_raw_value() as u64)
    }

    /// The calculated percent deviation between the target distance and the center of the laser tracer.
    /// Unit: %
    #[allow(dead_code)]
    pub fn laser_tracer_horizontal_deviation_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// The elevation of the laser tracer sensor in a laser leveling system.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn laser_tracer_vertical_distance_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// The calculated distance for the laser target to the current laser tracer reference point.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn laser_tracer_target_deviation_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Trip Fuel Information (Liquid)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ltfi {
    frame_payload: Vec<u8>,
}

impl Ltfi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ltfi {
        frame_payload.resize(8, 0);
        Ltfi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ltfi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486455806);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ltfi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TripDriveFuelEconomy signal from can frame
    /// Unit: km/L
    #[allow(dead_code)]
    pub fn trip_drive_fuel_economy_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0xFFFF) as f64 * 0.001953).round() as u16
    }

    /// Total fuel consumed while the engine is in the cruise hold state since the last trip reset.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_cruise_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripVehicleIdleFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_vehicle_idle_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripPTONonmovingFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_pto_nonmoving_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripPTOMovingFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_pto_moving_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Read TripDriveFuelUsed signal from can frame
    /// Unit: kg
    #[allow(dead_code)]
    pub fn trip_drive_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Modify Leveling System Control Set Point
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lsp {
    frame_payload: Vec<u8>,
}

impl Lsp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lsp {
        frame_payload.resize(8, 0);
        Lsp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lsp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218002686);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lsp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// High resolution for the laser guided blade set point.
    /// Unit: m
    #[allow(dead_code)]
    pub fn bld_height_set_point_high_resolution_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFFFFFF) as f64 * 0.100000).round() as u32
    }

    /// Used to control and coordinate the set point for the leveling system.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn modify_set_point_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Land Leveling System Operational Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Loi {
    frame_payload: Vec<u8>,
}

impl Loi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Loi {
        frame_payload.resize(8, 0);
        Loi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Loi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217058814);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Loi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates the side-shift blade control mode operator control state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn sdshft_dsrd_bld_offset_operator_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn sdshft_dsrd_bld_offset_operator_ctrl(&self) -> SdshftDsrdBldOffsetOperatorCtrl2364542462 {
        SdshftDsrdBldOffsetOperatorCtrl2364542462::from(self.sdshft_dsrd_bld_offset_operator_ctrl_raw_value() as u64)
    }

    /// This parameter indicates the side-shift blade control mode operator control state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn sdshft_bld_ctrl_mde_operator_control_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn sdshft_bld_ctrl_mde_operator_control(&self) -> SdshftBldCtrlMdeOperatorControl2364542462 {
        SdshftBldCtrlMdeOperatorControl2364542462::from(self.sdshft_bld_ctrl_mde_operator_control_raw_value() as u64)
    }

    /// This parameter indicates the right blade offset operator control state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn rght_dsrd_blade_offset_operator_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn rght_dsrd_blade_offset_operator_ctrl(&self) -> RghtDsrdBladeOffsetOperatorCtrl2364542462 {
        RghtDsrdBladeOffsetOperatorCtrl2364542462::from(self.rght_dsrd_blade_offset_operator_ctrl_raw_value() as u64)
    }

    /// This parameter indicates the right blade control mode operator control state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn rght_blde_ctrl_mode_operator_control_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn rght_blde_ctrl_mode_operator_control(&self) -> RghtBldeCtrlModeOperatorControl2364542462 {
        RghtBldeCtrlModeOperatorControl2364542462::from(self.rght_blde_ctrl_mode_operator_control_raw_value() as u64)
    }

    /// This parameter indicates the left blade offset operator control state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn lft_dsred_blade_offset_operator_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn lft_dsred_blade_offset_operator_ctrl(&self) -> LftDsredBladeOffsetOperatorCtrl2364542462 {
        LftDsredBladeOffsetOperatorCtrl2364542462::from(self.lft_dsred_blade_offset_operator_ctrl_raw_value() as u64)
    }

    /// This parameter indicates the left blade control mode operator control state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn lft_blade_ctrl_mode_operator_control_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn lft_blade_ctrl_mode_operator_control(&self) -> LftBladeCtrlModeOperatorControl2364542462 {
        LftBladeCtrlModeOperatorControl2364542462::from(self.lft_blade_ctrl_mode_operator_control_raw_value() as u64)
    }

    /// Read BladeAutoModeCmd signal from can frame
    #[allow(dead_code)]
    pub fn blade_auto_mode_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn blade_auto_mode_cmd(&self) -> BladeAutoModeCmd2364542462 {
        BladeAutoModeCmd2364542462::from(self.blade_auto_mode_cmd_raw_value() as u64)
    }

    /// This parameter indicates the grade offset switch state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn desired_grade_offset_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn desired_grade_offset_switch(&self) -> DesiredGradeOffsetSwitch2364542462 {
        DesiredGradeOffsetSwitch2364542462::from(self.desired_grade_offset_switch_raw_value() as u64)
    }

    /// This parameter indicates the blade control mode switch state the user has set for the land leveling system.
    #[allow(dead_code)]
    pub fn blade_ctrl_mode_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn blade_ctrl_mode_switch(&self) -> BladeCtrlModeSwitch2364542462 {
        BladeCtrlModeSwitch2364542462::from(self.blade_ctrl_mode_switch_raw_value() as u64)
    }
}

/// Laser Receiver Mast Position
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lmp {
    frame_payload: Vec<u8>,
}

impl Lmp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lmp {
        frame_payload.resize(8, 0);
        Lmp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lmp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(218002430);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lmp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Used to monitor the position of the sensor attached to the land leveling mast.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn mast_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Fuel Information (Liquid)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lfi {
    frame_payload: Vec<u8>,
}

impl Lfi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lfi {
        frame_payload.resize(8, 0);
        Lfi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lfi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486454270);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lfi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Average fuel rate, equal to trip fuel divided by trip time while the engine speed is above zero, since the last trip reset.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn trip_average_fuel_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Total fuel used while the PTO or remote PTO is in the hold state and engine speed is above zero, over the life of the engine.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn total_eng_pto_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Fuel Economy (Liquid)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lfe {
    frame_payload: Vec<u8>,
}

impl Lfe {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lfe {
        frame_payload.resize(8, 0);
        Lfe { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lfe, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419361534);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lfe::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Average of instantaneous fuel economy for that segment of vehicle operation of interest.
    /// Unit: km/L
    #[allow(dead_code)]
    pub fn eng_average_fuel_economy_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.001953).round() as u16
    }

    /// Current fuel economy at current vehicle velocity.
    /// Unit: km/L
    #[allow(dead_code)]
    pub fn eng_instantaneous_fuel_economy_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.001953).round() as u16
    }

    /// Amount of fuel consumed by engine per unit of time.
    /// Unit: L/h
    #[allow(dead_code)]
    pub fn eng_fuel_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Read EngThrottle2Pos signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_throttle2_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The position of the valve used to regulate the supply of a fluid, usually air or fuel/air mixture, to an engine.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_throttle_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Fuel Consumption (Liquid)
#[allow(dead_code)]
#[derive(Debug)]
pub struct Lfc {
    frame_payload: Vec<u8>,
}

impl Lfc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Lfc {
        frame_payload.resize(8, 0);
        Lfc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Lfc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419359230);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Lfc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Accumulated amount of fuel used during vehicle operation.
    /// Unit: L
    #[allow(dead_code)]
    pub fn eng_total_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Fuel consumed during all or part of a journey.
    /// Unit: L
    #[allow(dead_code)]
    pub fn eng_trip_fuel_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }
}

/// Front Wheel Drive Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fwd {
    frame_payload: Vec<u8>,
}

impl Fwd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fwd {
        frame_payload.resize(8, 0);
        Fwd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fwd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486399998);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fwd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Feedback on the front wheel drive actuator.
    #[allow(dead_code)]
    pub fn front_wheel_drive_actuator_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn front_wheel_drive_actuator_status(&self) -> FrontWheelDriveActuatorStatus2633883646 {
        FrontWheelDriveActuatorStatus2633883646::from(self.front_wheel_drive_actuator_status_raw_value() as u64)
    }
}

/// FMS-standard Interface Identity/Capabilities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fms {
    frame_payload: Vec<u8>,
}

impl Fms {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fms {
        frame_payload.resize(8, 0);
        Fms { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fms, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486396414);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fms::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Information that identifies which issue level of the FMS-standard document the software included in the FMS gateway supports.
    #[allow(dead_code)]
    pub fn fm_sstandard_s_wversion_supported_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFFFFFF)) as u32
    }

    /// Read FMSstandardRqsSupported signal from can frame
    #[allow(dead_code)]
    pub fn fm_sstandard_rqs_supported_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fm_sstandard_rqs_supported(&self) -> FmSstandardRqsSupported2633880062 {
        FmSstandardRqsSupported2633880062::from(self.fm_sstandard_rqs_supported_raw_value() as u64)
    }

    /// Read FMSstandardDiagnosticsSupported signal from can frame
    #[allow(dead_code)]
    pub fn fm_sstandard_diagnostics_supported_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fm_sstandard_diagnostics_supported(&self) -> FmSstandardDiagnosticsSupported2633880062 {
        FmSstandardDiagnosticsSupported2633880062::from(self.fm_sstandard_diagnostics_supported_raw_value() as u64)
    }
}

/// Forward Lane Image
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fli2 {
    frame_payload: Vec<u8>,
}

impl Fli2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fli2 {
        frame_payload.resize(8, 0);
        Fli2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fli2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419322878);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fli2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates whether lane departure indication is active.
    #[allow(dead_code)]
    pub fn ln_dprture_indication_enable_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ln_dprture_indication_enable_status(&self) -> LnDprtureIndicationEnableStatus2566806526 {
        LnDprtureIndicationEnableStatus2566806526::from(self.ln_dprture_indication_enable_status_raw_value() as u64)
    }

    /// Indicates whether the left side is tracking lane.
    #[allow(dead_code)]
    pub fn lane_tracking_status_left_side_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lane_tracking_status_left_side(&self) -> LaneTrackingStatusLeftSide2566806526 {
        LaneTrackingStatusLeftSide2566806526::from(self.lane_tracking_status_left_side_raw_value() as u64)
    }

    /// Indicates whether right side is tracking lane.
    #[allow(dead_code)]
    pub fn lane_tracking_status_right_side_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lane_tracking_status_right_side(&self) -> LaneTrackingStatusRightSide2566806526 {
        LaneTrackingStatusRightSide2566806526::from(self.lane_tracking_status_right_side_raw_value() as u64)
    }
}

/// Forward Lane Image urgent msg
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fli1 {
    frame_payload: Vec<u8>,
}

impl Fli1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fli1 {
        frame_payload.resize(8, 0);
        Fli1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fli1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(284166142);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fli1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates departure imminent on left side of lane.
    #[allow(dead_code)]
    pub fn lane_departure_imminent_left_side_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lane_departure_imminent_left_side(&self) -> LaneDepartureImminentLeftSide2431649790 {
        LaneDepartureImminentLeftSide2431649790::from(self.lane_departure_imminent_left_side_raw_value() as u64)
    }

    /// Indicates departure imminent on right side of lane.
    #[allow(dead_code)]
    pub fn lane_departure_imminent_right_side_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lane_departure_imminent_right_side(&self) -> LaneDepartureImminentRightSide2431649790 {
        LaneDepartureImminentRightSide2431649790::from(self.lane_departure_imminent_right_side_raw_value() as u64)
    }
}

/// Fuel Leakage
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fl {
    frame_payload: Vec<u8>,
}

impl Fl {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fl {
        frame_payload.resize(8, 0);
        Fl { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fl, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486445566);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fl::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Status signal which indicates fuel leakage in the fuel rail of the engine.
    #[allow(dead_code)]
    pub fn eng_fuel_leakage2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_fuel_leakage2(&self) -> EngFuelLeakage22633929214 {
        EngFuelLeakage22633929214::from(self.eng_fuel_leakage2_raw_value() as u64)
    }

    /// Status signal which indicates fuel leakage in the fuel rail of the engine.
    #[allow(dead_code)]
    pub fn eng_fuel_leakage1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_fuel_leakage1(&self) -> EngFuelLeakage12633929214 {
        EngFuelLeakage12633929214::from(self.eng_fuel_leakage1_raw_value() as u64)
    }
}

/// Fan Drive
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fd {
    frame_payload: Vec<u8>,
}

impl Fd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fd {
        frame_payload.resize(8, 0);
        Fd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419347966);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The speed of the fan associated with engine coolant system.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn fan_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// This parameter is used to indicate the current state or mode of operation by the fan drive.
    #[allow(dead_code)]
    pub fn fan_drive_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn fan_drive_state(&self) -> FanDriveState2566831614 {
        FanDriveState2566831614::from(self.fan_drive_state_raw_value() as u64)
    }

    /// Estimated fan speed as a ratio of the fan drive (current speed) to the fully engaged fan drive (maximum fan speed).
    /// Unit: %
    #[allow(dead_code)]
    pub fn est_percent_fan_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Engine Torque History
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eth {
    frame_payload: Vec<u8>,
}

impl Eth {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eth {
        frame_payload.resize(8, 0);
        Eth { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eth, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419336446);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eth::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Limit applied to the engine output torque based on the maximum allowable axle input torque.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_torque_limit6_axle_input_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 248) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// Limit applied to the engine output torque based on activation of an ECU switch input.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_torque_limit5_switch_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 232) & 0xFFFF)) as u16
    }

    /// Read EngTorqueLimit4Trans signal from can frame
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_torque_limit4_trans_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 216) & 0xFFFF)) as u16
    }

    /// Read EngTorqueLimit3Trans signal from can frame
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_torque_limit3_trans_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 200) & 0xFFFF)) as u16
    }

    /// Read TransGearRatio3 signal from can frame
    #[allow(dead_code)]
    pub fn trans_gear_ratio3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 184) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// Read EngTorqueLimit2Trans signal from can frame
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_torque_limit2_trans_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0xFFFF)) as u16
    }

    /// Read TransGearRatio2 signal from can frame
    #[allow(dead_code)]
    pub fn trans_gear_ratio2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 152) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// Read EngTorqueLimit1Trans signal from can frame
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_torque_limit1_trans_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0xFFFF)) as u16
    }

    /// Read TransGearRatio1 signal from can frame
    #[allow(dead_code)]
    pub fn trans_gear_ratio1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 120) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// Torque limit rating described in the current record.
    #[allow(dead_code)]
    pub fn eng_torque_limit_feature_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 114) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_torque_limit_feature(&self) -> EngTorqueLimitFeature2566820094 {
        EngTorqueLimitFeature2566820094::from(self.eng_torque_limit_feature_raw_value() as u64)
    }

    /// Status of an ECU feature which limits the torque output of the engine.
    #[allow(dead_code)]
    pub fn torque_limiting_feature_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn torque_limiting_feature_status(&self) -> TorqueLimitingFeatureStatus2566820094 {
        TorqueLimitingFeatureStatus2566820094::from(self.torque_limiting_feature_status_raw_value() as u64)
    }

    /// Duration in hours for which the engine operated in the conditions captured in the current record.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn calib_record_duration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Calendar year timestamp when an ECU record was established.
    /// Unit: years
    #[allow(dead_code)]
    pub fn calib_record_start_year_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0xFF)) as u8
    }

    /// Calendar day timestamp when an ECU record was established.
    /// Unit: days
    #[allow(dead_code)]
    pub fn calib_record_start_day_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFF) as f64 * 0.250000).round() as u8
    }

    /// Calendar month timestamp when an ECU record was established.
    /// Unit: months
    #[allow(dead_code)]
    pub fn calib_record_start_month_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Maximum torque output of the current ECU calibration when the engine operates on torque curve 2.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_peak_torque2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF)) as u16
    }

    /// Maximum torque output of the current ECU calibration when the engine operates on torque curve 1.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_peak_torque1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF)) as u16
    }

    /// Advertised engine power capability.
    /// Unit: kW
    #[allow(dead_code)]
    pub fn eng_power_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// Number of torque history records contained in the engine torque history PGN.
    /// Unit: records
    #[allow(dead_code)]
    pub fn number_of_eng_torque_history_records_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Electronic Transmission Controller #8
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc8 {
    frame_payload: Vec<u8>,
}

impl Etc8 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc8 {
        frame_payload.resize(8, 0);
        Etc8 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc8, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217058558);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc8::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Ratio of the transmissions torque converter output torque to torque converter input torque at current speed.
    #[allow(dead_code)]
    pub fn trans_torque_converter_ratio_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.001000).round() as u16
    }
}

/// Electronic Transmission Controller 7
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc7 {
    frame_payload: Vec<u8>,
}

impl Etc7 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc7 {
        frame_payload.resize(8, 0);
        Etc7 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc7, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419318526);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc7::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TransRqedGearFeedback signal from can frame
    #[allow(dead_code)]
    pub fn trans_rqed_gear_feedback_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Read TransMode1Indicator signal from can frame
    #[allow(dead_code)]
    pub fn trans_mode1_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode1_indicator(&self) -> TransMode1Indicator2566802174 {
        TransMode1Indicator2566802174::from(self.trans_mode1_indicator_raw_value() as u64)
    }

    /// Read TransMode2Indicator signal from can frame
    #[allow(dead_code)]
    pub fn trans_mode2_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode2_indicator(&self) -> TransMode2Indicator2566802174 {
        TransMode2Indicator2566802174::from(self.trans_mode2_indicator_raw_value() as u64)
    }

    /// Read TransMode3Indicator signal from can frame
    #[allow(dead_code)]
    pub fn trans_mode3_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode3_indicator(&self) -> TransMode3Indicator2566802174 {
        TransMode3Indicator2566802174::from(self.trans_mode3_indicator_raw_value() as u64)
    }

    /// Read TransMode4Indicator signal from can frame
    #[allow(dead_code)]
    pub fn trans_mode4_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_mode4_indicator(&self) -> TransMode4Indicator2566802174 {
        TransMode4Indicator2566802174::from(self.trans_mode4_indicator_raw_value() as u64)
    }

    /// State signal indicating a transmission request for the Shift Inhibit Indicator to be active or inactive.
    #[allow(dead_code)]
    pub fn trans_shift_inhibit_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_shift_inhibit_indicator(&self) -> TransShiftInhibitIndicator2566802174 {
        TransShiftInhibitIndicator2566802174::from(self.trans_shift_inhibit_indicator_raw_value() as u64)
    }

    /// State signal from the transmission indicating if the transmission�s status is such that engine cranking is allowed (i.
    #[allow(dead_code)]
    pub fn trans_eng_crank_enable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_eng_crank_enable(&self) -> TransEngCrankEnable2566802174 {
        TransEngCrankEnable2566802174::from(self.trans_eng_crank_enable_raw_value() as u64)
    }

    /// Read ActiveShiftConsoleIndicator signal from can frame
    #[allow(dead_code)]
    pub fn active_shift_console_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn active_shift_console_indicator(&self) -> ActiveShiftConsoleIndicator2566802174 {
        ActiveShiftConsoleIndicator2566802174::from(self.active_shift_console_indicator_raw_value() as u64)
    }

    /// Read TransReadyForBrakeRelease signal from can frame
    #[allow(dead_code)]
    pub fn trans_ready_for_brake_release_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_ready_for_brake_release(&self) -> TransReadyForBrakeRelease2566802174 {
        TransReadyForBrakeRelease2566802174::from(self.trans_ready_for_brake_release_raw_value() as u64)
    }

    /// Read TransRqedRangeDisplayFlashState signal from can frame
    #[allow(dead_code)]
    pub fn trans_rqed_range_display_flash_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_rqed_range_display_flash_state(&self) -> TransRqedRangeDisplayFlashState2566802174 {
        TransRqedRangeDisplayFlashState2566802174::from(self.trans_rqed_range_display_flash_state_raw_value() as u64)
    }

    /// Read TransRqedRangeDisplayBlankState signal from can frame
    #[allow(dead_code)]
    pub fn trans_rqed_range_display_blank_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_rqed_range_display_blank_state(&self) -> TransRqedRangeDisplayBlankState2566802174 {
        TransRqedRangeDisplayBlankState2566802174::from(self.trans_rqed_range_display_blank_state_raw_value() as u64)
    }
}

/// Electronic Transmission Controller 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc6 {
    frame_payload: Vec<u8>,
}

impl Etc6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc6 {
        frame_payload.resize(8, 0);
        Etc6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486452222);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates the actual clutch life remaining in percent.
    /// Unit: %
    #[allow(dead_code)]
    pub fn clutch_life_remaining_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The transmission calculates this gear continuously.
    #[allow(dead_code)]
    pub fn lowest_possible_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// The transmission calculates this gear continuously.
    #[allow(dead_code)]
    pub fn highest_possible_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// The transmission calculates this gear continuously.
    #[allow(dead_code)]
    pub fn recommended_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Electronic Transmission Controller 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc5 {
    frame_payload: Vec<u8>,
}

impl Etc5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc5 {
        frame_payload.resize(8, 0);
        Etc5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486458366);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the status of the switch that indicates forward direction.
    #[allow(dead_code)]
    pub fn trans_forward_direction_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_forward_direction_switch(&self) -> TransForwardDirectionSwitch2633942014 {
        TransForwardDirectionSwitch2633942014::from(self.trans_forward_direction_switch_raw_value() as u64)
    }

    /// Identifies the status of the switch that indicates neutral.
    #[allow(dead_code)]
    pub fn trans_neutral_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_neutral_switch(&self) -> TransNeutralSwitch2633942014 {
        TransNeutralSwitch2633942014::from(self.trans_neutral_switch_raw_value() as u64)
    }

    /// Identifies the status of the switch that indicates reverse direction.
    #[allow(dead_code)]
    pub fn trans_reverse_direction_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_reverse_direction_switch(&self) -> TransReverseDirectionSwitch2633942014 {
        TransReverseDirectionSwitch2633942014::from(self.trans_reverse_direction_switch_raw_value() as u64)
    }

    /// Identifies the status of the switch that represents low range.
    #[allow(dead_code)]
    pub fn trans_low_range_sense_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_low_range_sense_switch(&self) -> TransLowRangeSenseSwitch2633942014 {
        TransLowRangeSenseSwitch2633942014::from(self.trans_low_range_sense_switch_raw_value() as u64)
    }

    /// Identifies the status of the switch that represents high range.
    #[allow(dead_code)]
    pub fn trans_high_range_sense_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_high_range_sense_switch(&self) -> TransHighRangeSenseSwitch2633942014 {
        TransHighRangeSenseSwitch2633942014::from(self.trans_high_range_sense_switch_raw_value() as u64)
    }
}

/// Electronic Transmission Controller 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc4 {
    frame_payload: Vec<u8>,
}

impl Etc4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc4 {
        frame_payload.resize(8, 0);
        Etc4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486458878);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The current modulated value for the air supply to the synchronizer brake.
    /// Unit: %
    #[allow(dead_code)]
    pub fn trans_synchronizer_brake_value_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The current modulated value for the air supply to the synchronizer clutch.
    /// Unit: %
    #[allow(dead_code)]
    pub fn trans_synchronizer_clutch_value_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Electronic Transmission Controller 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc3 {
    frame_payload: Vec<u8>,
}

impl Etc3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc3 {
        frame_payload.resize(8, 0);
        Etc3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486459390);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the status of the actuator that controls the inertia brake.
    #[allow(dead_code)]
    pub fn trans_inertia_brake_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_inertia_brake_actuator(&self) -> TransInertiaBrakeActuator2633943038 {
        TransInertiaBrakeActuator2633943038::from(self.trans_inertia_brake_actuator_raw_value() as u64)
    }

    /// Identifies the status of the actuator that controls the engine defuel mechanism.
    #[allow(dead_code)]
    pub fn trans_defuel_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_defuel_actuator(&self) -> TransDefuelActuator2633943038 {
        TransDefuelActuator2633943038::from(self.trans_defuel_actuator_raw_value() as u64)
    }

    /// Identifies the status of the actuator that controls the lockup clutch.
    #[allow(dead_code)]
    pub fn trans_lockup_clutch_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_lockup_clutch_actuator(&self) -> TransLockupClutchActuator2633943038 {
        TransLockupClutchActuator2633943038::from(self.trans_lockup_clutch_actuator_raw_value() as u64)
    }

    /// Identifies the status of the actuator that controls the clutch.
    #[allow(dead_code)]
    pub fn trans_clutch_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_clutch_actuator(&self) -> TransClutchActuator2633943038 {
        TransClutchActuator2633943038::from(self.trans_clutch_actuator_raw_value() as u64)
    }

    /// Identifies the status of the splitter indirect actuator in the auxiliary unit.
    #[allow(dead_code)]
    pub fn trans_splitter_indirect_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_splitter_indirect_actuator(&self) -> TransSplitterIndirectActuator2633943038 {
        TransSplitterIndirectActuator2633943038::from(self.trans_splitter_indirect_actuator_raw_value() as u64)
    }

    /// Identifies the status of the splitter direct actuator in the auxiliary unit.
    #[allow(dead_code)]
    pub fn trans_splitter_direct_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_splitter_direct_actuator(&self) -> TransSplitterDirectActuator2633943038 {
        TransSplitterDirectActuator2633943038::from(self.trans_splitter_direct_actuator_raw_value() as u64)
    }

    /// Identifies the status of the range low actuator in the auxiliary unit.
    #[allow(dead_code)]
    pub fn trans_range_low_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_range_low_actuator(&self) -> TransRangeLowActuator2633943038 {
        TransRangeLowActuator2633943038::from(self.trans_range_low_actuator_raw_value() as u64)
    }

    /// Identifies the status of the range high actuator in the auxiliary unit.
    #[allow(dead_code)]
    pub fn trans_range_high_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_range_high_actuator(&self) -> TransRangeHighActuator2633943038 {
        TransRangeHighActuator2633943038::from(self.trans_range_high_actuator_raw_value() as u64)
    }

    /// Identifies the status of the actuator that moves the shift finger identified as gear actuator #2.
    #[allow(dead_code)]
    pub fn trans_shift_finger_gear_actuator2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_shift_finger_gear_actuator2(&self) -> TransShiftFingerGearActuator22633943038 {
        TransShiftFingerGearActuator22633943038::from(self.trans_shift_finger_gear_actuator2_raw_value() as u64)
    }

    /// Identifies the status of the actuator that moves the shift finger identified as rail actuator #2.
    #[allow(dead_code)]
    pub fn trans_shift_finger_rail_actuator2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_shift_finger_rail_actuator2(&self) -> TransShiftFingerRailActuator22633943038 {
        TransShiftFingerRailActuator22633943038::from(self.trans_shift_finger_rail_actuator2_raw_value() as u64)
    }

    /// Identifies the status of the actuator that moves the shift finger identified as gear actuator #1.
    #[allow(dead_code)]
    pub fn trans_shift_finger_gear_actuator1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_shift_finger_gear_actuator1(&self) -> TransShiftFingerGearActuator12633943038 {
        TransShiftFingerGearActuator12633943038::from(self.trans_shift_finger_gear_actuator1_raw_value() as u64)
    }

    /// Identifies the status of the actuator that moves the shift finger identified as rail actuator #1.
    #[allow(dead_code)]
    pub fn trans_shift_finger_rail_actuator1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_shift_finger_rail_actuator1(&self) -> TransShiftFingerRailActuator12633943038 {
        TransShiftFingerRailActuator12633943038::from(self.trans_shift_finger_rail_actuator1_raw_value() as u64)
    }

    /// Identifies the status of the shift finger in the center rail position.
    #[allow(dead_code)]
    pub fn trns_shft_fngr_center_rail_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trns_shft_fngr_center_rail_indicator(&self) -> TrnsShftFngrCenterRailIndicator2633943038 {
        TrnsShftFngrCenterRailIndicator2633943038::from(self.trns_shft_fngr_center_rail_indicator_raw_value() as u64)
    }

    /// Identifies the status of the shift finger in the engagement position.
    #[allow(dead_code)]
    pub fn trns_shft_fngr_engagement_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trns_shft_fngr_engagement_indicator(&self) -> TrnsShftFngrEngagementIndicator2633943038 {
        TrnsShftFngrEngagementIndicator2633943038::from(self.trns_shft_fngr_engagement_indicator_raw_value() as u64)
    }

    /// Indicates the status of the shift finger in the neutral position.
    #[allow(dead_code)]
    pub fn trns_shift_finger_neutral_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trns_shift_finger_neutral_indicator(&self) -> TrnsShiftFingerNeutralIndicator2633943038 {
        TrnsShiftFingerNeutralIndicator2633943038::from(self.trns_shift_finger_neutral_indicator_raw_value() as u64)
    }

    /// The current position of the shift finger in the rail direction.
    /// Unit: %
    #[allow(dead_code)]
    pub fn trans_shift_finger_rail_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The current position of the shift finger in the gear direction.
    /// Unit: %
    #[allow(dead_code)]
    pub fn trans_shift_finger_gear_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Electronic Transmission Controller 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc2 {
    frame_payload: Vec<u8>,
}

impl Etc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc2 {
        frame_payload.resize(8, 0);
        Etc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418383358);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Range currently being commanded by the transmission control system.
    #[allow(dead_code)]
    pub fn trans_current_range_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Range selected by the operator.
    #[allow(dead_code)]
    pub fn trans_rqed_range_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Read TransCurrentGear signal from can frame
    #[allow(dead_code)]
    pub fn trans_current_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Actual ratio of input shaft speed to output shaft speed.
    #[allow(dead_code)]
    pub fn trans_actual_gear_ratio_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.001000).round() as u16
    }

    /// Read TransSelectedGear signal from can frame
    #[allow(dead_code)]
    pub fn trans_selected_gear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Electronic Transmission Controller 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Etc1 {
    frame_payload: Vec<u8>,
}

impl Etc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Etc1 {
        frame_payload.resize(8, 0);
        Etc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Etc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217055998);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Etc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The source address of the SAE J1939 device currently controlling the transmission.
    #[allow(dead_code)]
    pub fn src_addrss_of_ctrllng_dvc_fr_trns_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Rotational velocity of the primary shaft transferring power into the transmission.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn trans_input_shaft_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Command signal used to indicate that progressive shifting by the engine should be disallowed.
    #[allow(dead_code)]
    pub fn progressive_shift_disable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn progressive_shift_disable(&self) -> ProgressiveShiftDisable2364539646 {
        ProgressiveShiftDisable2364539646::from(self.progressive_shift_disable_raw_value() as u64)
    }

    /// Read EngMomentaryOverspeedEnable signal from can frame
    #[allow(dead_code)]
    pub fn eng_momentary_overspeed_enable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_momentary_overspeed_enable(&self) -> EngMomentaryOverspeedEnable2364539646 {
        EngMomentaryOverspeedEnable2364539646::from(self.eng_momentary_overspeed_enable_raw_value() as u64)
    }

    /// Parameter which represents the ratio of input shaft speed to current engine speed (in percent).
    /// Unit: %
    #[allow(dead_code)]
    pub fn percent_clutch_slip_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Calculated speed of the transmission output shaft.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn trans_output_shaft_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Indicates that the transmission is in process of shifting from the current gear to the selected gear.
    #[allow(dead_code)]
    pub fn trans_shift_in_process_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_shift_in_process(&self) -> TransShiftInProcess2364539646 {
        TransShiftInProcess2364539646::from(self.trans_shift_in_process_raw_value() as u64)
    }

    /// State signal which indicates whether the torque converter lockup is engaged.
    #[allow(dead_code)]
    pub fn torque_converter_lockup_engaged_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn torque_converter_lockup_engaged(&self) -> TorqueConverterLockupEngaged2364539646 {
        TorqueConverterLockupEngaged2364539646::from(self.torque_converter_lockup_engaged_raw_value() as u64)
    }

    /// Read TransDrivelineEngaged signal from can frame
    #[allow(dead_code)]
    pub fn trans_driveline_engaged_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_driveline_engaged(&self) -> TransDrivelineEngaged2364539646 {
        TransDrivelineEngaged2364539646::from(self.trans_driveline_engaged_raw_value() as u64)
    }
}

/// Engine Temperature 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Et3 {
    frame_payload: Vec<u8>,
}

impl Et3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Et3 {
        frame_payload.resize(8, 0);
        Et3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Et3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419326462);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Et3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of combustion air after it exits from the Charge Air Cooler but before any mixing of Recirculated Exhaust Gas.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_charge_air_cooler_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of liquid found in engine cooling system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_coolant_temp_hi_res_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// The temperature of the oil in the hydraulic system that powers the intake valve actuation system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intk_vlv_actation_system_oil_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of pre-combustion air found in intake manifold of engine air supply system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intake_manifold1_air_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Engine Temperature 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Et2 {
    frame_payload: Vec<u8>,
}

impl Et2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Et2 {
        frame_payload.resize(8, 0);
        Et2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Et2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419341566);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Et2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngExhaustGasRecirculationTemp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_recirculation_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngExhstGsRcirculationDiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_exhst_gs_rcirculation_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Temperature of the engine electronic control unit.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_ecu_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the engine lubricant.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_oil_temp2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Engine Temperature 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Et1 {
    frame_payload: Vec<u8>,
}

impl Et1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Et1 {
        frame_payload.resize(8, 0);
        Et1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Et1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419360510);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Et1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The current position of the thermostat used to regulate the temperature of the engine intercooler.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_intercooler_thermostat_opening_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Temperature of liquid found in the intercooler located after the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_intercooler_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Temperature of the turbocharger lubricant.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_turbo_oil_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of the engine lubricant.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_oil_temp1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of fuel entering injectors.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_fuel_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Temperature of liquid found in engine cooling system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_coolant_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Exhaust Temperature
#[allow(dead_code)]
#[derive(Debug)]
pub struct Et {
    frame_payload: Vec<u8>,
}

impl Et {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Et {
        frame_payload.resize(8, 0);
        Et { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Et, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419301374);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Et::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of combustion byproducts within the left engine exhaust manifold.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhst_exhst_gs_temp_left_manifold_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of combustion byproducts within the right engine exhaust manifold.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhst_exhst_gs_tmp_right_manifold_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Electronic Steering Control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Esc1 {
    frame_payload: Vec<u8>,
}

impl Esc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Esc1 {
        frame_payload.resize(8, 0);
        Esc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Esc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418384894);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Esc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// A signal which indicates if lowering of lifted axle is allowed or inhibited.
    #[allow(dead_code)]
    pub fn sterable_lift_axle_lowering_inhibit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sterable_lift_axle_lowering_inhibit(&self) -> SterableLiftAxleLoweringInhibit2565868542 {
        SterableLiftAxleLoweringInhibit2565868542::from(self.sterable_lift_axle_lowering_inhibit_raw_value() as u64)
    }

    /// To identify to which of several similar devices (such as tires or fuel tanks) the information applies.
    #[allow(dead_code)]
    pub fn axle_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Type of Steering Transmission (Ref.
    #[allow(dead_code)]
    pub fn type_of_steer_trans_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn type_of_steer_trans(&self) -> TypeOfSteerTrans2565868542 {
        TypeOfSteerTrans2565868542::from(self.type_of_steer_trans_raw_value() as u64)
    }

    /// Type of Steering Forces (Ref.
    #[allow(dead_code)]
    pub fn type_of_steer_forces_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn type_of_steer_forces(&self) -> TypeOfSteerForces2565868542 {
        TypeOfSteerForces2565868542::from(self.type_of_steer_forces_raw_value() as u64)
    }

    /// Indicates the different types of steering systems (ref.
    #[allow(dead_code)]
    pub fn steer_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn steer_type(&self) -> SteerType2565868542 {
        SteerType2565868542::from(self.steer_type_raw_value() as u64)
    }

    /// Read StatusOfSteerAxle signal from can frame
    #[allow(dead_code)]
    pub fn status_of_steer_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn status_of_steer_axle(&self) -> StatusOfSteerAxle2565868542 {
        StatusOfSteerAxle2565868542::from(self.status_of_steer_axle_raw_value() as u64)
    }

    /// Signal which indicates the actual inner wheel steering angle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn actual_inner_wheel_steer_angle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.003906).round() as u16
    }
}

/// Electronic Retarder Controller 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Erc2 {
    frame_payload: Vec<u8>,
}

impl Erc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Erc2 {
        frame_payload.resize(8, 0);
        Erc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Erc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486458110);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Erc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the status of the transmission output retarder.
    #[allow(dead_code)]
    pub fn trans_output_retarder_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_output_retarder(&self) -> TransOutputRetarder2633941758 {
        TransOutputRetarder2633941758::from(self.trans_output_retarder_raw_value() as u64)
    }
}

/// Electronic Retarder Controller 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Erc1 {
    frame_payload: Vec<u8>,
}

impl Erc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Erc1 {
        frame_payload.resize(8, 0);
        Erc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Erc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418382078);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Erc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read RetarderSelectionNonEng signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn retarder_selection_non_eng_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// This is the maximum amount of torque that the retarder can immediately deliver.
    /// Unit: %
    #[allow(dead_code)]
    pub fn actl_mx_avlbl_rtarder_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Read DrvrsDmandRetarderPercentTorque signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn drvrs_dmand_retarder_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// The source address of the SAE J1939 device currently controlling the retarder.
    #[allow(dead_code)]
    pub fn src_addrss_of_ctrllng_dvc_fr_rtrdr_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Read RetarderRqingBrakeLight signal from can frame
    #[allow(dead_code)]
    pub fn retarder_rqing_brake_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    /// Status of an event, external to the engine, that may increase the nominal temperature of the engine coolant liquid.
    #[allow(dead_code)]
    pub fn eng_coolant_load_increase_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_coolant_load_increase(&self) -> EngCoolantLoadIncrease2565865726 {
        EngCoolantLoadIncrease2565865726::from(self.eng_coolant_load_increase_raw_value() as u64)
    }

    /// Braking torque of retarder that the retarder is currently trying to achieve.
    /// Unit: %
    #[allow(dead_code)]
    pub fn intended_retarder_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Actual braking torque of the retarder as a percent of retarder configuration reference torque SPN 556.
    /// Unit: %
    #[allow(dead_code)]
    pub fn actual_retarder_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Switch signal which indicates whether the operator wishes the retarder to be enabled for transmission shift assist.
    #[allow(dead_code)]
    pub fn retarder_enable_shift_assist_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn retarder_enable_shift_assist_switch(&self) -> RetarderEnableShiftAssistSwitch2565865726 {
        RetarderEnableShiftAssistSwitch2565865726::from(self.retarder_enable_shift_assist_switch_raw_value() as u64)
    }

    /// Switch signal which indicates whether the operator wishes the retarder to be enabled for vehicle braking assist.
    #[allow(dead_code)]
    pub fn retarder_enable_brake_assist_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn retarder_enable_brake_assist_switch(&self) -> RetarderEnableBrakeAssistSwitch2565865726 {
        RetarderEnableBrakeAssistSwitch2565865726::from(self.retarder_enable_brake_assist_switch_raw_value() as u64)
    }

    /// State signal which indicates which retarder torque mode is currently generating, limiting, or controlling the torque.
    #[allow(dead_code)]
    pub fn retarder_torque_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }
}

/// Exhaust Port Temperature 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ept5 {
    frame_payload: Vec<u8>,
}

impl Ept5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ept5 {
        frame_payload.resize(8, 0);
        Ept5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ept5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486449150);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ept5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port20_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port19_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port18_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port17_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Exhaust Port Temperature 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ept4 {
    frame_payload: Vec<u8>,
}

impl Ept4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ept4 {
        frame_payload.resize(8, 0);
        Ept4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ept4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419340542);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ept4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port16_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port15_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port14_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port13_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Exhaust Port Temperature 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ept3 {
    frame_payload: Vec<u8>,
}

impl Ept3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ept3 {
        frame_payload.resize(8, 0);
        Ept3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ept3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486449662);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ept3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port12_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port11_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port10_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port9_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Exhaust Port Temperature 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ept2 {
    frame_payload: Vec<u8>,
}

impl Ept2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ept2 {
        frame_payload.resize(8, 0);
        Ept2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ept2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486449918);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ept2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port8_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port7_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port6_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port5_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Exhaust Port Temperature 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ept1 {
    frame_payload: Vec<u8>,
}

impl Ept1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ept1 {
        frame_payload.resize(8, 0);
        Ept1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ept1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486450174);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ept1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port4_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port3_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port2_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature at the cylinder exhaust port of the engine.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_port1_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Equipment Performance Data
#[allow(dead_code)]
#[derive(Debug)]
pub struct Epd {
    frame_payload: Vec<u8>,
}

impl Epd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Epd {
        frame_payload.resize(8, 0);
        Epd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Epd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419292414);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Epd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The current payload of the equipment, reported as a percentage of the equipment's rated payload limit.
    /// Unit: %
    #[allow(dead_code)]
    pub fn payload_percentage_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// ECU Performance
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ep {
    frame_payload: Vec<u8>,
}

impl Ep {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ep {
        frame_payload.resize(8, 0);
        Ep { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ep, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419287806);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ep::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The used storage capacity of the data buffer memory internal to an ECU, such as a data logger.
    /// Unit: %
    #[allow(dead_code)]
    pub fn data_memory_usage_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The capacity consumed from the direct battery connection since the key was last turned off.
    /// Unit: mAhr
    #[allow(dead_code)]
    pub fn keep_alive_battery_consumption_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Equipment Operation and Control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eoac {
    frame_payload: Vec<u8>,
}

impl Eoac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eoac {
        frame_payload.resize(8, 0);
        Eoac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eoac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419292158);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eoac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TravelVelocityCtrlPos signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn travel_velocity_ctrl_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Exhaust Oxygen 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eo1 {
    frame_payload: Vec<u8>,
}

impl Eo1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eo1 {
        frame_payload.resize(8, 0);
        Eo1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eo1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486451710);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eo1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates whether the engine is using the Exhaust Gas Oxygen sensor to control the air/fuel ratio.
    #[allow(dead_code)]
    pub fn eng_exhst_gs_oxygn_snsr_clsd_lp_oprton_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_exhst_gs_oxygn_snsr_clsd_lp_oprton(&self) -> EngExhstGsOxygnSnsrClsdLpOprton2633935358 {
        EngExhstGsOxygnSnsrClsdLpOprton2633935358::from(self.eng_exhst_gs_oxygn_snsr_clsd_lp_oprton_raw_value() as u64)
    }

    /// Read EngExhstGsOxygnSnsrFlngCrrction signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_exhst_gs_oxygn_snsr_flng_crrction_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Read EngActualExhaustOxygen signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_actual_exhaust_oxygen_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read EngDesiredExhaustOxygen signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_desired_exhaust_oxygen_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Read EngDesiredRatedExhaustOxygen signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_desired_rated_exhaust_oxygen_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.002500).round() as u16
    }
}

/// Extended Joystick Message 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ejm3 {
    frame_payload: Vec<u8>,
}

impl Ejm3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ejm3 {
        frame_payload.resize(8, 0);
        Ejm3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ejm3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217963518);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ejm3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports when the current joystick grip position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck3_grip_x_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grip_x_axis_detent_pos_status(&self) -> Jystck3GripXAxisDetentPosStatus2365447166 {
        Jystck3GripXAxisDetentPosStatus2365447166::from(self.jystck3_grip_x_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck3_grip_y_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grip_y_axis_detent_pos_status(&self) -> Jystck3GripYAxisDetentPosStatus2365447166 {
        Jystck3GripYAxisDetentPosStatus2365447166::from(self.jystck3_grip_y_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck3_theta_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_theta_axis_detent_pos_status(&self) -> Jystck3ThetaAxisDetentPosStatus2365447166 {
        Jystck3ThetaAxisDetentPosStatus2365447166::from(self.jystck3_theta_axis_detent_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick3_theta_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck3ThtAxsClckwsPstvPsStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_tht_axs_clckws_pstv_ps_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_tht_axs_clckws_pstv_ps_status(&self) -> Jystck3ThtAxsClckwsPstvPsStatus2365447166 {
        Jystck3ThtAxsClckwsPstvPsStatus2365447166::from(self.jystck3_tht_axs_clckws_pstv_ps_status_raw_value() as u64)
    }

    /// Read Jystck3ThtAxsCntrClckwsNgtvPsStt signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_tht_axs_cntr_clckws_ngtv_ps_stt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_tht_axs_cntr_clckws_ngtv_ps_stt(&self) -> Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166 {
        Jystck3ThtAxsCntrClckwsNgtvPsStt2365447166::from(self.jystck3_tht_axs_cntr_clckws_ngtv_ps_stt_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck3_thta_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_thta_axis_neutral_pos_status(&self) -> Jystck3ThtaAxisNeutralPosStatus2365447166 {
        Jystck3ThtaAxisNeutralPosStatus2365447166::from(self.jystck3_thta_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick grip in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick3_grip_y_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck3GrpYAxsLvrFrwrdPstvPsStts signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_grp_y_axs_lvr_frwrd_pstv_ps_stts_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grp_y_axs_lvr_frwrd_pstv_ps_stts(&self) -> Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166 {
        Jystck3GrpYAxsLvrFrwrdPstvPsStts2365447166::from(self.jystck3_grp_y_axs_lvr_frwrd_pstv_ps_stts_raw_value() as u64)
    }

    /// Read Jystck3GrpYAxsLvrBckNgtvPsSttus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_grp_y_axs_lvr_bck_ngtv_ps_sttus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grp_y_axs_lvr_bck_ngtv_ps_sttus(&self) -> Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166 {
        Jystck3GrpYAxsLvrBckNgtvPsSttus2365447166::from(self.jystck3_grp_y_axs_lvr_bck_ngtv_ps_sttus_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck3_grp_y_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grp_y_axis_neutral_pos_status(&self) -> Jystck3GrpYAxisNeutralPosStatus2365447166 {
        Jystck3GrpYAxisNeutralPosStatus2365447166::from(self.jystck3_grp_y_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick grip in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick3_grip_x_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck3GrpXAxsLvrRghtPstvPsStts signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_grp_x_axs_lvr_rght_pstv_ps_stts_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grp_x_axs_lvr_rght_pstv_ps_stts(&self) -> Jystck3GrpXAxsLvrRghtPstvPsStts2365447166 {
        Jystck3GrpXAxsLvrRghtPstvPsStts2365447166::from(self.jystck3_grp_x_axs_lvr_rght_pstv_ps_stts_raw_value() as u64)
    }

    /// Read Jystck3GrpXAxsLvrLftNgtvPsSttus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_grp_x_axs_lvr_lft_ngtv_ps_sttus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grp_x_axs_lvr_lft_ngtv_ps_sttus(&self) -> Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166 {
        Jystck3GrpXAxsLvrLftNgtvPsSttus2365447166::from(self.jystck3_grp_x_axs_lvr_lft_ngtv_ps_sttus_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck3_grp_x_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_grp_x_axis_neutral_pos_status(&self) -> Jystck3GrpXAxisNeutralPosStatus2365447166 {
        Jystck3GrpXAxisNeutralPosStatus2365447166::from(self.jystck3_grp_x_axis_neutral_pos_status_raw_value() as u64)
    }
}

/// Extended Joystick Message 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ejm2 {
    frame_payload: Vec<u8>,
}

impl Ejm2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ejm2 {
        frame_payload.resize(8, 0);
        Ejm2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ejm2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217963006);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ejm2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports when the current joystick grip position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck2_grip_x_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grip_x_axis_detent_pos_status(&self) -> Jystck2GripXAxisDetentPosStatus2365446654 {
        Jystck2GripXAxisDetentPosStatus2365446654::from(self.jystck2_grip_x_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck2_grip_y_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grip_y_axis_detent_pos_status(&self) -> Jystck2GripYAxisDetentPosStatus2365446654 {
        Jystck2GripYAxisDetentPosStatus2365446654::from(self.jystck2_grip_y_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck2_theta_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_theta_axis_detent_pos_status(&self) -> Jystck2ThetaAxisDetentPosStatus2365446654 {
        Jystck2ThetaAxisDetentPosStatus2365446654::from(self.jystck2_theta_axis_detent_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick2_theta_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck2ThtAxsClckwsPstvPsStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_tht_axs_clckws_pstv_ps_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_tht_axs_clckws_pstv_ps_status(&self) -> Jystck2ThtAxsClckwsPstvPsStatus2365446654 {
        Jystck2ThtAxsClckwsPstvPsStatus2365446654::from(self.jystck2_tht_axs_clckws_pstv_ps_status_raw_value() as u64)
    }

    /// Read Jystck2ThtAxsCntrClckwsNgtvPsStt signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_tht_axs_cntr_clckws_ngtv_ps_stt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_tht_axs_cntr_clckws_ngtv_ps_stt(&self) -> Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654 {
        Jystck2ThtAxsCntrClckwsNgtvPsStt2365446654::from(self.jystck2_tht_axs_cntr_clckws_ngtv_ps_stt_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck2_thta_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_thta_axis_neutral_pos_status(&self) -> Jystck2ThtaAxisNeutralPosStatus2365446654 {
        Jystck2ThtaAxisNeutralPosStatus2365446654::from(self.jystck2_thta_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick grip in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick2_grip_y_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck2GrpYAxsLvrFrwrdPstvPsStts signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_grp_y_axs_lvr_frwrd_pstv_ps_stts_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grp_y_axs_lvr_frwrd_pstv_ps_stts(&self) -> Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654 {
        Jystck2GrpYAxsLvrFrwrdPstvPsStts2365446654::from(self.jystck2_grp_y_axs_lvr_frwrd_pstv_ps_stts_raw_value() as u64)
    }

    /// Read Jystck2GrpYAxsLvrBckNgtvPsSttus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_grp_y_axs_lvr_bck_ngtv_ps_sttus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grp_y_axs_lvr_bck_ngtv_ps_sttus(&self) -> Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654 {
        Jystck2GrpYAxsLvrBckNgtvPsSttus2365446654::from(self.jystck2_grp_y_axs_lvr_bck_ngtv_ps_sttus_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck2_grp_y_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grp_y_axis_neutral_pos_status(&self) -> Jystck2GrpYAxisNeutralPosStatus2365446654 {
        Jystck2GrpYAxisNeutralPosStatus2365446654::from(self.jystck2_grp_y_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick grip in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick2_grip_x_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck2GrpXAxsLvrRghtPstvPsStts signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_grp_x_axs_lvr_rght_pstv_ps_stts_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grp_x_axs_lvr_rght_pstv_ps_stts(&self) -> Jystck2GrpXAxsLvrRghtPstvPsStts2365446654 {
        Jystck2GrpXAxsLvrRghtPstvPsStts2365446654::from(self.jystck2_grp_x_axs_lvr_rght_pstv_ps_stts_raw_value() as u64)
    }

    /// Read Jystck2GrpXAxsLvrLftNgtvPsSttus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_grp_x_axs_lvr_lft_ngtv_ps_sttus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grp_x_axs_lvr_lft_ngtv_ps_sttus(&self) -> Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654 {
        Jystck2GrpXAxsLvrLftNgtvPsSttus2365446654::from(self.jystck2_grp_x_axs_lvr_lft_ngtv_ps_sttus_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck2_grp_x_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_grp_x_axis_neutral_pos_status(&self) -> Jystck2GrpXAxisNeutralPosStatus2365446654 {
        Jystck2GrpXAxisNeutralPosStatus2365446654::from(self.jystck2_grp_x_axis_neutral_pos_status_raw_value() as u64)
    }
}

/// Extended Joystick Message 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ejm1 {
    frame_payload: Vec<u8>,
}

impl Ejm1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ejm1 {
        frame_payload.resize(8, 0);
        Ejm1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ejm1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217962494);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ejm1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports when the current joystick grip position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck1_grip_x_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grip_x_axis_detent_pos_status(&self) -> Jystck1GripXAxisDetentPosStatus2365446142 {
        Jystck1GripXAxisDetentPosStatus2365446142::from(self.jystck1_grip_x_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck1_grip_y_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grip_y_axis_detent_pos_status(&self) -> Jystck1GripYAxisDetentPosStatus2365446142 {
        Jystck1GripYAxisDetentPosStatus2365446142::from(self.jystck1_grip_y_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck1_theta_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_theta_axis_detent_pos_status(&self) -> Jystck1ThetaAxisDetentPosStatus2365446142 {
        Jystck1ThetaAxisDetentPosStatus2365446142::from(self.jystck1_theta_axis_detent_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick1_theta_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck1ThtAxsClckwsPstvPsStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_tht_axs_clckws_pstv_ps_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_tht_axs_clckws_pstv_ps_status(&self) -> Jystck1ThtAxsClckwsPstvPsStatus2365446142 {
        Jystck1ThtAxsClckwsPstvPsStatus2365446142::from(self.jystck1_tht_axs_clckws_pstv_ps_status_raw_value() as u64)
    }

    /// Read Jystck1ThtAxsCntrClckwsNgtvPsStt signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_tht_axs_cntr_clckws_ngtv_ps_stt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_tht_axs_cntr_clckws_ngtv_ps_stt(&self) -> Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142 {
        Jystck1ThtAxsCntrClckwsNgtvPsStt2365446142::from(self.jystck1_tht_axs_cntr_clckws_ngtv_ps_stt_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck1_thta_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_thta_axis_neutral_pos_status(&self) -> Jystck1ThtaAxisNeutralPosStatus2365446142 {
        Jystck1ThtaAxisNeutralPosStatus2365446142::from(self.jystck1_thta_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick grip in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick1_grip_y_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck1GrpYAxsLvrFrwrdPstvPsStts signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_grp_y_axs_lvr_frwrd_pstv_ps_stts_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grp_y_axs_lvr_frwrd_pstv_ps_stts(&self) -> Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142 {
        Jystck1GrpYAxsLvrFrwrdPstvPsStts2365446142::from(self.jystck1_grp_y_axs_lvr_frwrd_pstv_ps_stts_raw_value() as u64)
    }

    /// Read Jystck1GrpYAxsLvrBckNgtvPsSttus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_grp_y_axs_lvr_bck_ngtv_ps_sttus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grp_y_axs_lvr_bck_ngtv_ps_sttus(&self) -> Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142 {
        Jystck1GrpYAxsLvrBckNgtvPsSttus2365446142::from(self.jystck1_grp_y_axs_lvr_bck_ngtv_ps_sttus_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck1_grp_y_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grp_y_axis_neutral_pos_status(&self) -> Jystck1GrpYAxisNeutralPosStatus2365446142 {
        Jystck1GrpYAxisNeutralPosStatus2365446142::from(self.jystck1_grp_y_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick grip in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick1_grip_x_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck1GrpXAxsLvrRghtPstvPsStts signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_grp_x_axs_lvr_rght_pstv_ps_stts_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grp_x_axs_lvr_rght_pstv_ps_stts(&self) -> Jystck1GrpXAxsLvrRghtPstvPsStts2365446142 {
        Jystck1GrpXAxsLvrRghtPstvPsStts2365446142::from(self.jystck1_grp_x_axs_lvr_rght_pstv_ps_stts_raw_value() as u64)
    }

    /// Read Jystck1GrpXAxsLvrLftNgtvPsSttus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_grp_x_axs_lvr_lft_ngtv_ps_sttus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grp_x_axs_lvr_lft_ngtv_ps_sttus(&self) -> Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142 {
        Jystck1GrpXAxsLvrLftNgtvPsSttus2365446142::from(self.jystck1_grp_x_axs_lvr_lft_ngtv_ps_sttus_raw_value() as u64)
    }

    /// Reports when the current joystick grip position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn jystck1_grp_x_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_grp_x_axis_neutral_pos_status(&self) -> Jystck1GrpXAxisNeutralPosStatus2365446142 {
        Jystck1GrpXAxisNeutralPosStatus2365446142::from(self.jystck1_grp_x_axis_neutral_pos_status_raw_value() as u64)
    }
}

/// Engine Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ei {
    frame_payload: Vec<u8>,
}

impl Ei {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ei {
        frame_payload.resize(8, 0);
        Ei { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ei, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486445822);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ei::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Measured position of the engine fuel rack.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_fuel_rack_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Estimate of the power developed by the engine.
    /// Unit: kW
    #[allow(dead_code)]
    pub fn instantaneous_est_brake_power_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// Mass flow of natural gas to the engine.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn eng_mass_flow_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Gage pressure of the exhaust gasses as measured at the turbine inlet of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_exhaust_gas_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Gage pressure of the engine oil before the oil reaches the oil filter.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_prefilter_oil_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// ECU History
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eh {
    frame_payload: Vec<u8>,
}

impl Eh {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eh {
        frame_payload.resize(8, 0);
        Eh { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eh, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486453758);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eh::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total time accumulated over the life of the ECU, from ignition switch ON to ignition switch OFF.
    /// Unit: hr
    #[allow(dead_code)]
    pub fn total_ecu_run_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.050000).round() as u32
    }

    /// Total distance accumulated over the life of the ECU.
    /// Unit: km
    #[allow(dead_code)]
    pub fn total_ecu_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }
}

/// Engine Gas Flow Rate
#[allow(dead_code)]
#[derive(Debug)]
pub struct Egf1 {
    frame_payload: Vec<u8>,
}

impl Egf1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Egf1 {
        frame_payload.resize(8, 0);
        Egf1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Egf1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217058046);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Egf1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Mass flow rate of fresh air entering the engine air intake, before any EGR mixer, if used.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn eng_inlet_air_mass_flow_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Flow rate of gas through the EGR system.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn eng_exhst_gs_rcrcltion_mass_flow_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Engine Fuel/lube systems
#[allow(dead_code)]
#[derive(Debug)]
pub struct Efs {
    frame_payload: Vec<u8>,
}

impl Efs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Efs {
        frame_payload.resize(8, 0);
        Efs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Efs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419326718);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Efs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Differential pressure measured across the fuel filter located between the fuel tank and the supply pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_filter_suc_side_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Absolute pressure of fuel at the fuel supply pump inlet.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_supply_pump_inlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Ratio of current volume of engine oil in a remote reservoir to the maximum required volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_oil_level_remote_reservoir_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Level of crankcase blowby emulsion collected by a container.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_waste_oil_reservoir_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    #[allow(dead_code)]
    pub fn eng_waste_oil_reservoir_level(&self) -> EngWasteOilReservoirLevel2566810366 {
        EngWasteOilReservoirLevel2566810366::from(self.eng_waste_oil_reservoir_level_raw_value() as u64)
    }

    /// Engine ventilation control states.
    #[allow(dead_code)]
    pub fn eng_ventilation_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_ventilation_status(&self) -> EngVentilationStatus2566810366 {
        EngVentilationStatus2566810366::from(self.eng_ventilation_status_raw_value() as u64)
    }

    /// Determination of whether or not the engine is (or has recently been) sufficiently lubricated for starting purposes.
    #[allow(dead_code)]
    pub fn eng_oil_priming_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_oil_priming_state(&self) -> EngOilPrimingState2566810366 {
        EngOilPrimingState2566810366::from(self.eng_oil_priming_state_raw_value() as u64)
    }

    /// Switch input for activating the engine oil priming pump.
    #[allow(dead_code)]
    pub fn eng_oil_priming_pump_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_oil_priming_pump_switch(&self) -> EngOilPrimingPumpSwitch2566810366 {
        EngOilPrimingPumpSwitch2566810366::from(self.eng_oil_priming_pump_switch_raw_value() as u64)
    }

    /// Indicates whether the engine oil pre-heated sufficiently for starting purposes.
    #[allow(dead_code)]
    pub fn eng_oil_pre_heated_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_oil_pre_heated_state(&self) -> EngOilPreHeatedState2566810366 {
        EngOilPreHeatedState2566810366::from(self.eng_oil_pre_heated_state_raw_value() as u64)
    }

    /// Oil pressure (gauge) measured just downstream of oil filter.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_oil_filter_outlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Indicates whether the engine coolant is pre-heated sufficiently for starting purposes.
    #[allow(dead_code)]
    pub fn eng_coolant_preheated_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_coolant_preheated_state(&self) -> EngCoolantPreheatedState2566810366 {
        EngCoolantPreheatedState2566810366::from(self.eng_coolant_preheated_state_raw_value() as u64)
    }
}

/// Engine Fluid Level/Pressure 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP3 {
    frame_payload: Vec<u8>,
}

impl EflP3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP3 {
        frame_payload.resize(8, 0);
        EflP3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419283454);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// EGR inlet gage pressure is measured after the EGR cooler and before the EGR valve.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_exhst_gs_rcrculation_inlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Read EngIntkVlvActtionSystemOilPress signal from can frame
    /// Unit: Mpa
    #[allow(dead_code)]
    pub fn eng_intk_vlv_acttion_system_oil_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.003906).round() as u16
    }
}

/// Engine Fluid Level/Pressure 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP2 {
    frame_payload: Vec<u8>,
}

impl EflP2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP2 {
        frame_payload.resize(8, 0);
        EflP2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419355646);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The gage pressure of fuel in the metering rail #2 as delivered from the supply pump to the injector metering inlet.
    /// Unit: MPa
    #[allow(dead_code)]
    pub fn eng_injector_metering_rail2_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// The gage pressure of fuel in the timing rail delivered from the supply pump to the injector timing inlet.
    /// Unit: Mpa
    #[allow(dead_code)]
    pub fn eng_injector_timing_rail1_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// The gage pressure of fuel in the primary, or first, metering rail as delivered from the supply pump to the injector metering inlet.
    /// Unit: MPa
    #[allow(dead_code)]
    pub fn eng_injector_metering_rail1_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// The gage pressure of the engine oil in the hydraulic accumulator that powers an intensifier used for fuel injection.
    /// Unit: MPa
    #[allow(dead_code)]
    pub fn eng_injection_ctrl_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.003906).round() as u16
    }
}

/// Engine Fluid Level/Pressure 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct EflP1 {
    frame_payload: Vec<u8>,
}

impl EflP1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> EflP1 {
        frame_payload.resize(8, 0);
        EflP1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<EflP1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419360766);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| EflP1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Ratio of volume of liquid found in engine cooling system to total cooling system volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_coolant_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Gage pressure of liquid found in engine cooling system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_coolant_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Gage pressure inside engine crankcase.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_crankcase_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Gage pressure of oil in engine lubrication system as provided by oil pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_oil_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Ratio of current volume of engine sump oil to maximum required volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_oil_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Differential crankcase blow-by pressure as measured through a tube with a venturi.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_ex_crankcase_blowby_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.050000).round() as u8
    }

    /// Gage pressure of fuel in system as delivered from supply pump to the injection pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_delivery_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// Engine Electrical System/Module Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ees {
    frame_payload: Vec<u8>,
}

impl Ees {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ees {
        frame_payload.resize(8, 0);
        Ees { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ees, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486446078);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ees::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Status signal which indicates that the turning gear is engaged.
    #[allow(dead_code)]
    pub fn turning_gear_engaged_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn turning_gear_engaged(&self) -> TurningGearEngaged2633929726 {
        TurningGearEngaged2633929726::from(self.turning_gear_engaged_raw_value() as u64)
    }

    /// Status signal which indicates that the safety wire has been activated.
    #[allow(dead_code)]
    pub fn safety_wire_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn safety_wire_status(&self) -> SafetyWireStatus2633929726 {
        SafetyWireStatus2633929726::from(self.safety_wire_status_raw_value() as u64)
    }

    /// Electrical power delivered by the engine to the electrical system connected to the generator.
    /// Unit: kW
    #[allow(dead_code)]
    pub fn electrical_load_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Electronic Engine Controller 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec5 {
    frame_payload: Vec<u8>,
}

impl Eec5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec5 {
        frame_payload.resize(8, 0);
        Eec5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419288574);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Sensor that measures the position of the variable geometry turbocharger actuator.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_vrbl_gometry_turbo1_actuator_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Isolates vehicle brake air from the Variable Geometry Turbocharger (VGT) system when engine is not running.
    #[allow(dead_code)]
    pub fn eng_vrbl_gmtry_trb_ar_ctrl_shtff_valve_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_vrbl_gmtry_trb_ar_ctrl_shtff_valve(&self) -> EngVrblGmtryTrbArCtrlShtffValve2566772222 {
        EngVrblGmtryTrbArCtrlShtffValve2566772222::from(self.eng_vrbl_gmtry_trb_ar_ctrl_shtff_valve_raw_value() as u64)
    }

    /// Desired percentage of maximum Exhaust Gas Recirculation (EGR) valve opening.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_exhst_gs_rcirculation_valve_ctrl_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002500).round() as u16
    }

    /// Calculated value of turbocharger compressor outlet air temperature.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_trb1_clclted_turbine_outlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngTrb1ClclatedTurbineInletTemp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_trb1_clclated_turbine_inlet_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Electronic Engine Controller 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec4 {
    frame_payload: Vec<u8>,
}

impl Eec4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec4 {
        frame_payload.resize(8, 0);
        Eec4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486457086);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Direction of engine rotation, as reported by the engine.
    #[allow(dead_code)]
    pub fn eng_rotation_direction_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_rotation_direction(&self) -> EngRotationDirection2633940734 {
        EngRotationDirection2633940734::from(self.eng_rotation_direction_raw_value() as u64)
    }

    /// Reports the number of cranking cycles undergone during the present start attempt.
    #[allow(dead_code)]
    pub fn crnk_attmpt_cnt_on_prsnt_strt_attempt_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// The maximum governed rotational velocity of the engine crankshaft under full load conditions.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_rated_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Net brake power that the engine will deliver continuously, specified for a given application at a rated speed.
    /// Unit: kW
    #[allow(dead_code)]
    pub fn eng_rated_power_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Electronic Engine Controller 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec3 {
    frame_payload: Vec<u8>,
}

impl Eec3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec3 {
        frame_payload.resize(8, 0);
        Eec3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419356670);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Measured/calculated exhaust gas mass upstream of the after-treatment system.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn exhaust_gas_mass_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF) as f64 * 2.000000).round() as u16
    }

    /// Read AftrTrtmntIntakeDewPointMessage signal from can frame
    #[allow(dead_code)]
    pub fn aftr_trtmnt_intake_dew_point_message_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    /// Read AftrTrtmntExhustDewPointMessage signal from can frame
    #[allow(dead_code)]
    pub fn aftr_trtmnt_exhust_dew_point_message_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    /// Read EstEngPrsticLossesPercentTorque signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn est_eng_prstic_losses_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Read EngsDsrdOprtngSpdAsymmtryAdjstmn signal from can frame
    #[allow(dead_code)]
    pub fn engs_dsrd_oprtng_spd_asymmtry_adjstmn_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// An indication by the engine of the optimal operating speed of the engine for the current existing conditions.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn engs_desired_operating_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read NominalFrictionPercentTorque signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn nominal_friction_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Electronic Engine Controller 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec2 {
    frame_payload: Vec<u8>,
}

impl Eec2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec2 {
        frame_payload.resize(8, 0);
        Eec2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217056254);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This is the maximum amount of torque that the engine can immediately deliver as a percentage of the reference engine torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn act_max_avail_eng_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read AccelPedalPos2 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn accel_pedal_pos2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Status (active or not active) of the system used to limit maximum forward vehicle acceleration.
    #[allow(dead_code)]
    pub fn vhcl_acceleration_rate_limit_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vhcl_acceleration_rate_limit_status(&self) -> VhclAccelerationRateLimitStatus2364539902 {
        VhclAccelerationRateLimitStatus2364539902::from(self.vhcl_acceleration_rate_limit_status_raw_value() as u64)
    }

    /// Read EngPercentLoadAtCurrentSpeed signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_load_at_current_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Switch signal which indicates the state of the accelerator pedal 2 low idle switch.
    #[allow(dead_code)]
    pub fn accel_pedal2_low_idle_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn accel_pedal2_low_idle_switch(&self) -> AccelPedal2LowIdleSwitch2364539902 {
        AccelPedal2LowIdleSwitch2364539902::from(self.accel_pedal2_low_idle_switch_raw_value() as u64)
    }

    /// Status (active or not active) of the system used to limit maximum vehicle velocity.
    #[allow(dead_code)]
    pub fn road_speed_limit_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn road_speed_limit_status(&self) -> RoadSpeedLimitStatus2364539902 {
        RoadSpeedLimitStatus2364539902::from(self.road_speed_limit_status_raw_value() as u64)
    }

    /// Switch signal which indicates whether the accelerator pedal kickdown switch is opened or closed.
    #[allow(dead_code)]
    pub fn accel_pedal_kickdown_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn accel_pedal_kickdown_switch(&self) -> AccelPedalKickdownSwitch2364539902 {
        AccelPedalKickdownSwitch2364539902::from(self.accel_pedal_kickdown_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the state of the accelerator pedal 1 low idle switch.
    #[allow(dead_code)]
    pub fn accel_pedal1_low_idle_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn accel_pedal1_low_idle_switch(&self) -> AccelPedal1LowIdleSwitch2364539902 {
        AccelPedal1LowIdleSwitch2364539902::from(self.accel_pedal1_low_idle_switch_raw_value() as u64)
    }

    /// Read RemoteAccelPedalPos signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn remote_accel_pedal_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read AccelPedalPos1 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn accel_pedal_pos1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Electronic Engine Controller 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eec1 {
    frame_payload: Vec<u8>,
}

impl Eec1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eec1 {
        frame_payload.resize(8, 0);
        Eec1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eec1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217056510);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eec1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngDemandPercentTorque signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_demand_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// There are several phases in a starting action and different reasons why a start cannot take place.
    #[allow(dead_code)]
    pub fn eng_starter_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_starter_mode(&self) -> EngStarterMode2364540158 {
        EngStarterMode2364540158::from(self.eng_starter_mode_raw_value() as u64)
    }

    /// The source address of the SAE J1939 device currently controlling the engine.
    #[allow(dead_code)]
    pub fn src_addrss_of_ctrllng_dvc_for_eng_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Actual engine speed which is calculated over a minimum crankshaft angle of 720 degrees divided by the number of cylinders.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The calculated output torque of the engine.
    /// Unit: %
    #[allow(dead_code)]
    pub fn actual_eng_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// The requested torque output of the engine by the driver.
    /// Unit: %
    #[allow(dead_code)]
    pub fn drivers_demand_eng_percent_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// State signal which indicates which engine torque mode is currently generating, limiting, or controlling the torque.
    #[allow(dead_code)]
    pub fn eng_torque_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_torque_mode(&self) -> EngTorqueMode2364540158 {
        EngTorqueMode2364540158::from(self.eng_torque_mode_raw_value() as u64)
    }
}

/// ECU Identification Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ecuid {
    frame_payload: Vec<u8>,
}

impl Ecuid {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ecuid {
        frame_payload.resize(8, 0);
        Ecuid { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ecuid, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419284478);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ecuid::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Engine Continuous Torque & Speed Limit
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ect1 {
    frame_payload: Vec<u8>,
}

impl Ect1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ect1 {
        frame_payload.resize(8, 0);
        Ect1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ect1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419321086);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ect1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngMinContinuousTorque signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_min_continuous_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Applied limit for maximum continuous engine torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_max_continuous_torque_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Read EngMinContinuousRPM signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_min_continuous_rpm_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read EngMaxContinuousRPM signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_max_continuous_rpm_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Maximum allowable value for minimum continuous torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_hgh_lmt_thrshhld_fr_mn_cntns_trq_frm_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Minimum allowable value for maximum continuous torque.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_lw_lmt_thrshld_fr_mx_trque_from_eng_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read EngHghLmtThrshhldFrMnCntnsEngRPM signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_hgh_lmt_thrshhld_fr_mn_cntns_eng_rpm_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read EngLwLmtThrshhldFrMaxRPMFromEng signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_lw_lmt_thrshhld_fr_max_rpm_from_eng_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 32.000000).round() as u8
    }
}

/// Engine Configuration
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ec1 {
    frame_payload: Vec<u8>,
}

impl Ec1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ec1 {
        frame_payload.resize(8, 0);
        Ec1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ec1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419357694);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ec1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates which TSC1 control purposes are supported in group 4 of 4.
    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group4_of4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 304) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group4_of4(&self) -> SupportTsc1CtrlPurposeGroup4Of42566841342 {
        SupportTsc1CtrlPurposeGroup4Of42566841342::from(self.support_tsc1_ctrl_purpose_group4_of4_raw_value() as u64)
    }

    /// Read SupportVariableRateTSC1Message signal from can frame
    #[allow(dead_code)]
    pub fn support_variable_rate_tsc1_message_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 272) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn support_variable_rate_tsc1_message(&self) -> SupportVariableRateTsc1Message2566841342 {
        SupportVariableRateTsc1Message2566841342::from(self.support_variable_rate_tsc1_message_raw_value() as u64)
    }

    /// This parameter indicates which TSC1 control purposes are supported in group 3 of 4.
    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group3_of4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 296) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group3_of4(&self) -> SupportTsc1CtrlPurposeGroup3Of42566841342 {
        SupportTsc1CtrlPurposeGroup3Of42566841342::from(self.support_tsc1_ctrl_purpose_group3_of4_raw_value() as u64)
    }

    /// This parameter indicates which TSC1 control purposes are supported in group 2 of 4.
    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group2_of4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 288) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group2_of4(&self) -> SupportTsc1CtrlPurposeGroup2Of42566841342 {
        SupportTsc1CtrlPurposeGroup2Of42566841342::from(self.support_tsc1_ctrl_purpose_group2_of4_raw_value() as u64)
    }

    /// This parameter indicates which TSC1 control purposes are supported in group 1 of 4.
    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group1_of4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 280) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn support_tsc1_ctrl_purpose_group1_of4(&self) -> SupportTsc1CtrlPurposeGroup1Of42566841342 {
        SupportTsc1CtrlPurposeGroup1Of42566841342::from(self.support_tsc1_ctrl_purpose_group1_of4_raw_value() as u64)
    }

    /// Companion parameter to Transmission Torque Limit (SPN 1845).
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_default_torque_limit_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 256) & 0xFFFF)) as u16
    }

    /// Moment of inertia for the engine, including items driven full-time by the engine such as fuel, oil and cooling pumps.
    /// Unit: kg-m�
    #[allow(dead_code)]
    pub fn eng_moment_of_inertia_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 240) & 0xFFFF) as f64 * 0.004000).round() as u16
    }

    /// Read EngExRngRqdSpdCtrlRngUpperLimit signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_ex_rng_rqd_spd_ctrl_rng_upper_limit_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 224) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The maximum engine torque that the engine will allow when operating in a torque control/limit mode.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_rqd_torque_ctrl_range_upper_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 216) & 0xFF)) as u8
    }

    /// The minimum engine torque that the engine will allow when operating in a torque control/limit mode.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_rqd_torque_ctrl_range_lower_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 208) & 0xFF)) as u8
    }

    /// Read EngRqedSpeedCtrlRangeUpperLimit signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_rqed_speed_ctrl_range_upper_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 200) & 0xFF) as f64 * 10.000000).round() as u8
    }

    /// The minimum engine speed that the engine will allow when operating in a speed control/limit mode.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_rqed_speed_ctrl_range_lower_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 192) & 0xFF) as f64 * 10.000000).round() as u8
    }

    /// The maximum time limit allowed to override the engine's high idle speed.
    /// Unit: s
    #[allow(dead_code)]
    pub fn eng_mx_momentary_override_time_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 184) & 0xFF) as f64 * 0.100000).round() as u8
    }

    /// The maximum engine speed above high idle allowed by the engine control during a momentary high idle override.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_mx_mmntary_override_speed_point7_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// This parameter is the 100% reference value for all defined indicated engine torque parameters.
    /// Unit: Nm
    #[allow(dead_code)]
    pub fn eng_reference_torque_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 152) & 0xFFFF)) as u16
    }

    /// Engine speed of high idle (point 6) of the engine torque map (see PGN 65251 and supporting document).
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_at_high_idle_point6_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 120) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read EngGainOfEndspeedGovernor signal from can frame
    /// Unit: %/rpm
    #[allow(dead_code)]
    pub fn eng_gain_of_endspeed_governor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0xFFFF) as f64 * 0.000781).round() as u16
    }

    /// Read EngPercentTorqueAtPoint5 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_torque_at_point5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFF)) as u8
    }

    /// Engine speed of point 3, 4, and 5 of the engine torque map (see PGN 65251 and supporting document).
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_at_point5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read EngPercentTorqueAtPoint4 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_torque_at_point4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 88) & 0xFF)) as u8
    }

    /// Engine speed of point 3, 4, and 5 of the engine torque map (see PGN 65251 and supporting document).
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_at_point4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read EngPercentTorqueAtPoint3 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_torque_at_point3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFF)) as u8
    }

    /// Engine speed of point 3, 4, and 5 of the engine torque map (see PGN 65251 and supporting document).
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_at_point3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// Read EngPercentTorqueAtPoint2 signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_torque_at_point2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Engine speed of point 2 of the engine torque map (see PGN 65251 and supporting document).
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_at_point2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// The torque limit that indicates the available engine torque which can be provided by the engine at idle speed.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_torque_at_idle_point1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read EngSpeedAtIdlePoint1 signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_at_idle_point1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.125000).round() as u16
    }
}

/// Electronic Brake Controller 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebc5 {
    frame_payload: Vec<u8>,
}

impl Ebc5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebc5 {
        frame_payload.resize(8, 0);
        Ebc5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebc5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419284222);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebc5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates if the temperature in the service brakes exceeds a certain value.
    #[allow(dead_code)]
    pub fn brake_temp_warning_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn brake_temp_warning(&self) -> BrakeTempWarning2566767870 {
        BrakeTempWarning2566767870::from(self.brake_temp_warning_raw_value() as u64)
    }

    /// The brake system may temporarily or generally limit the maximum brake performance available for external systems.
    /// Unit: m/s�
    #[allow(dead_code)]
    pub fn xbr_acceleration_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.100000).round() as u8
    }

    /// This parameter indicates which XBR Control Mode is executed by the brake system.
    #[allow(dead_code)]
    pub fn xbr_active_ctrl_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn xbr_active_ctrl_mode(&self) -> XbrActiveCtrlMode2566767870 {
        XbrActiveCtrlMode2566767870::from(self.xbr_active_ctrl_mode_raw_value() as u64)
    }

    /// This parameter indicates which external brake control is allowed.
    #[allow(dead_code)]
    pub fn xbr_system_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn xbr_system_state(&self) -> XbrSystemState2566767870 {
        XbrSystemState2566767870::from(self.xbr_system_state_raw_value() as u64)
    }

    /// This parameter indicates if the brake system presently uses the foundation brakes.
    #[allow(dead_code)]
    pub fn foundation_brake_use_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn foundation_brake_use(&self) -> FoundationBrakeUse2566767870 {
        FoundationBrakeUse2566767870::from(self.foundation_brake_use_raw_value() as u64)
    }

    /// Signal which indicates the current mode of the hill holder function.
    #[allow(dead_code)]
    pub fn hill_holder_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 5) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn hill_holder_mode(&self) -> HillHolderMode2566767870 {
        HillHolderMode2566767870::from(self.hill_holder_mode_raw_value() as u64)
    }

    /// Signal which indicates the current mode of the halt brake function.
    #[allow(dead_code)]
    pub fn halt_brake_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn halt_brake_mode(&self) -> HaltBrakeMode2566767870 {
        HaltBrakeMode2566767870::from(self.halt_brake_mode_raw_value() as u64)
    }
}

/// Wheel Brake Lining Remaining Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebc4 {
    frame_payload: Vec<u8>,
}

impl Ebc4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebc4 {
        frame_payload.resize(8, 0);
        Ebc4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebc4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486452478);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebc4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The percentage of brake lining which can still be measured for the right wheel on the rear axle #3.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmnng_rear_axle3_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the left wheel on the rear axle #3.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmning_rear_axle3_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the right wheel on the rear axle #2.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmnng_rear_axle2_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the left wheel on the rear axle #2.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmning_rear_axle2_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the right wheel on the rear axle #1.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmnng_rear_axle1_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the left wheel on the rear axle #1.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmning_rear_axle1_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the right wheel on the front axle.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmnng_front_axle_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// The percentage of brake lining which can still be measured for the left wheel on the front axle.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brk_lnng_rmning_front_axle_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Wheel Application Pressure High Range Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebc3 {
    frame_payload: Vec<u8>,
}

impl Ebc3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebc3 {
        frame_payload.resize(8, 0);
        Ebc3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebc3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419343870);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebc3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The brake application pressure for the right wheel on the rear axle #3.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_rr_axl3_rght_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the left wheel on the rear axle #3.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_rr_axl3_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the right wheel on the rear axle #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_rr_axl2_rght_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the left wheel on the rear axle #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_rr_axl2_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the right wheel on the rear axle #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_rr_axl1_rght_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the left wheel on the rear axle #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_rr_axl1_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the right wheel on the front axle.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_frnt_axl_rght_whel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 5.000000).round() as u8
    }

    /// The brake application pressure for the left wheel on the front axle.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brk_app_prss_hgh_rng_frnt_axl_lft_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 5.000000).round() as u8
    }
}

/// Wheel Speed Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebc2 {
    frame_payload: Vec<u8>,
}

impl Ebc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebc2 {
        frame_payload.resize(8, 0);
        Ebc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419348478);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The speed of the rear axle #2, right wheel relative to the front axle speed, SPN 904.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn rlative_speed_rear_axle2_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.062500).round() as u8
    }

    /// The speed of the rear axle #2, left wheel relative to the front axle speed, SPN 904.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn relative_speed_rear_axle2_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.062500).round() as u8
    }

    /// The speed of the rear axle #1, right wheel relative to the front axle speed, SPN 904.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn rlative_speed_rear_axle1_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.062500).round() as u8
    }

    /// The speed of the rear axle #1, left wheel relative to the front axle speed, SPN 904.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn relative_speed_rear_axle1_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.062500).round() as u8
    }

    /// The speed of the front axle, right wheel relative to the front axle speed, SPN 904.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn rlative_speed_front_axle_right_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.062500).round() as u8
    }

    /// The speed of the front axle, left wheel relative to the front axle speed, SPN 904.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn relative_speed_front_axle_left_wheel_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.062500).round() as u8
    }

    /// The average speed of the two front wheels.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn front_axle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.003906).round() as u16
    }
}

/// Electronic Brake Controller 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ebc1 {
    frame_payload: Vec<u8>,
}

impl Ebc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ebc1 {
        frame_payload.resize(8, 0);
        Ebc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ebc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418382334);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ebc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The source address of the SAE J1939 device currently controlling the brake system.
    #[allow(dead_code)]
    pub fn src_addrss_of_ctrllng_dvc_fr_brk_cntrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Ratio of brake pedal position to maximum pedal position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn brake_pedal_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// This parameter commands the tractor-mounted trailer ABS optical warning signal.
    #[allow(dead_code)]
    pub fn trctr_mntd_triler_abs_warning_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trctr_mntd_triler_abs_warning_signal(&self) -> TrctrMntdTrilerAbsWarningSignal2565865982 {
        TrctrMntdTrilerAbsWarningSignal2565865982::from(self.trctr_mntd_triler_abs_warning_signal_raw_value() as u64)
    }

    /// State signal which indicates that ABS in the trailer is actively controlling the brakes.
    #[allow(dead_code)]
    pub fn trailer_abs_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_abs_status(&self) -> TrailerAbsStatus2565865982 {
        TrailerAbsStatus2565865982::from(self.trailer_abs_status_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the halt brake switch.
    #[allow(dead_code)]
    pub fn halt_brake_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn halt_brake_switch(&self) -> HaltBrakeSwitch2565865982 {
        HaltBrakeSwitch2565865982::from(self.halt_brake_switch_raw_value() as u64)
    }

    /// This parameter commands the ATC/ASR driver information signal, for example a dash lamp.
    #[allow(dead_code)]
    pub fn atc_asr_information_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn atc_asr_information_signal(&self) -> AtcAsrInformationSignal2565865982 {
        AtcAsrInformationSignal2565865982::from(self.atc_asr_information_signal_raw_value() as u64)
    }

    /// Read ABS_EBSAmberWarningSignal signal from can frame
    #[allow(dead_code)]
    pub fn abs_ebs_amber_warning_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn abs_ebs_amber_warning_signal(&self) -> AbsEbsAmberWarningSignal2565865982 {
        AbsEbsAmberWarningSignal2565865982::from(self.abs_ebs_amber_warning_signal_raw_value() as u64)
    }

    /// Read EBSRedWarningSignal signal from can frame
    #[allow(dead_code)]
    pub fn ebs_red_warning_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ebs_red_warning_signal(&self) -> EbsRedWarningSignal2565865982 {
        EbsRedWarningSignal2565865982::from(self.ebs_red_warning_signal_raw_value() as u64)
    }

    /// Read ABSFullyOperational signal from can frame
    #[allow(dead_code)]
    pub fn abs_fully_operational_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn abs_fully_operational(&self) -> AbsFullyOperational2565865982 {
        AbsFullyOperational2565865982::from(self.abs_fully_operational_raw_value() as u64)
    }

    /// Read EngRetarderSelection signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_retarder_selection_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Switch signal which indicates that the remote accelerator has been enabled and controls the engine.
    #[allow(dead_code)]
    pub fn remote_accel_enable_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn remote_accel_enable_switch(&self) -> RemoteAccelEnableSwitch2565865982 {
        RemoteAccelEnableSwitch2565865982::from(self.remote_accel_enable_switch_raw_value() as u64)
    }

    /// Switch signal which requests that all engine fueling stop.
    #[allow(dead_code)]
    pub fn eng_aux_eng_shutdown_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_aux_eng_shutdown_switch(&self) -> EngAuxEngShutdownSwitch2565865982 {
        EngAuxEngShutdownSwitch2565865982::from(self.eng_aux_eng_shutdown_switch_raw_value() as u64)
    }

    /// Switch signal used to activate the torque limiting feature of the engine.
    #[allow(dead_code)]
    pub fn eng_derate_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_derate_switch(&self) -> EngDerateSwitch2565865982 {
        EngDerateSwitch2565865982::from(self.eng_derate_switch_raw_value() as u64)
    }

    /// Switch signal used to disable the accelerator and remote accelerator inputs, causing the engine to return to idle.
    #[allow(dead_code)]
    pub fn accel_interlock_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn accel_interlock_switch(&self) -> AccelInterlockSwitch2565865982 {
        AccelInterlockSwitch2565865982::from(self.accel_interlock_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the traction control override switch.
    #[allow(dead_code)]
    pub fn traction_ctrl_override_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn traction_ctrl_override_switch(&self) -> TractionCtrlOverrideSwitch2565865982 {
        TractionCtrlOverrideSwitch2565865982::from(self.traction_ctrl_override_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the ASR �hill holder� switch.
    #[allow(dead_code)]
    pub fn asr_hill_holder_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn asr_hill_holder_switch(&self) -> AsrHillHolderSwitch2565865982 {
        AsrHillHolderSwitch2565865982::from(self.asr_hill_holder_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the ASR off-road switch.
    #[allow(dead_code)]
    pub fn asr_offroad_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn asr_offroad_switch(&self) -> AsrOffroadSwitch2565865982 {
        AsrOffroadSwitch2565865982::from(self.asr_offroad_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the ABS off-road switch.
    #[allow(dead_code)]
    pub fn abs_offroad_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn abs_offroad_switch(&self) -> AbsOffroadSwitch2565865982 {
        AbsOffroadSwitch2565865982::from(self.abs_offroad_switch_raw_value() as u64)
    }

    /// Switch signal which indicates that the brake pedal is being pressed.
    #[allow(dead_code)]
    pub fn ebs_brake_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ebs_brake_switch(&self) -> EbsBrakeSwitch2565865982 {
        EbsBrakeSwitch2565865982::from(self.ebs_brake_switch_raw_value() as u64)
    }

    /// State signal which indicates that the ABS is active.
    #[allow(dead_code)]
    pub fn anti_lock_braking_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn anti_lock_braking_active(&self) -> AntiLockBrakingActive2565865982 {
        AntiLockBrakingActive2565865982::from(self.anti_lock_braking_active_raw_value() as u64)
    }

    /// State signal which indicates that ASR brake control is active.
    #[allow(dead_code)]
    pub fn asr_brake_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn asr_brake_ctrl_active(&self) -> AsrBrakeCtrlActive2565865982 {
        AsrBrakeCtrlActive2565865982::from(self.asr_brake_ctrl_active_raw_value() as u64)
    }

    /// State signal which indicates that ASR engine control has been commanded to be active.
    #[allow(dead_code)]
    pub fn asr_eng_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn asr_eng_ctrl_active(&self) -> AsrEngCtrlActive2565865982 {
        AsrEngCtrlActive2565865982::from(self.asr_eng_ctrl_active_raw_value() as u64)
    }
}

/// Electronic Axle Controller 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eac1 {
    frame_payload: Vec<u8>,
}

impl Eac1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eac1 {
        frame_payload.resize(8, 0);
        Eac1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eac1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418383614);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eac1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read RearAxleGroupEngagementStatus signal from can frame
    #[allow(dead_code)]
    pub fn rear_axle_group_engagement_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_axle_group_engagement_status(&self) -> RearAxleGroupEngagementStatus2565867262 {
        RearAxleGroupEngagementStatus2565867262::from(self.rear_axle_group_engagement_status_raw_value() as u64)
    }

    /// Read FrontAxleGroupEngagementStatus signal from can frame
    #[allow(dead_code)]
    pub fn front_axle_group_engagement_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn front_axle_group_engagement_status(&self) -> FrontAxleGroupEngagementStatus2565867262 {
        FrontAxleGroupEngagementStatus2565867262::from(self.front_axle_group_engagement_status_raw_value() as u64)
    }

    /// State used which indicates the condition of the central rear differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_central_rear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_central_rear(&self) -> DiffLockStateCentralRear2565867262 {
        DiffLockStateCentralRear2565867262::from(self.diff_lock_state_central_rear_raw_value() as u64)
    }

    /// State used which indicates the condition of the central front differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_central_front_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_central_front(&self) -> DiffLockStateCentralFront2565867262 {
        DiffLockStateCentralFront2565867262::from(self.diff_lock_state_central_front_raw_value() as u64)
    }

    /// State used which indicates the condition of the central differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_central_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_central(&self) -> DiffLockStateCentral2565867262 {
        DiffLockStateCentral2565867262::from(self.diff_lock_state_central_raw_value() as u64)
    }

    /// State used which indicates the condition of the rear axle 2 differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_rear_axle2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_rear_axle2(&self) -> DiffLockStateRearAxle22565867262 {
        DiffLockStateRearAxle22565867262::from(self.diff_lock_state_rear_axle2_raw_value() as u64)
    }

    /// State used which indicates the condition of the rear axle 1 differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_rear_axle1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_rear_axle1(&self) -> DiffLockStateRearAxle12565867262 {
        DiffLockStateRearAxle12565867262::from(self.diff_lock_state_rear_axle1_raw_value() as u64)
    }

    /// State used which indicates the condition of the front axle 2 differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_front_axle2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_front_axle2(&self) -> DiffLockStateFrontAxle22565867262 {
        DiffLockStateFrontAxle22565867262::from(self.diff_lock_state_front_axle2_raw_value() as u64)
    }

    /// State used which indicates the condition of the front axle 1 differential lock.
    #[allow(dead_code)]
    pub fn diff_lock_state_front_axle1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn diff_lock_state_front_axle1(&self) -> DiffLockStateFrontAxle12565867262 {
        DiffLockStateFrontAxle12565867262::from(self.diff_lock_state_front_axle1_raw_value() as u64)
    }

    /// To identify to which of several similar devices (such as tires or fuel tanks) the information applies.
    #[allow(dead_code)]
    pub fn location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Engine Auxiliary Coolant
#[allow(dead_code)]
#[derive(Debug)]
pub struct Eac {
    frame_payload: Vec<u8>,
}

impl Eac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Eac {
        frame_payload.resize(8, 0);
        Eac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Eac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419337470);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Eac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Gauge pressure of liquid found at outlet of sea water pump in sea water cooling system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn sea_water_pump_outlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Temperature of coolant found in the intercooler which is located after the turbocharger.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_aux_coolant_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Gage pressure of coolant found in the intercooler which is located after the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_aux_coolant_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// Driver's Identification
#[allow(dead_code)]
#[derive(Debug)]
pub struct Di {
    frame_payload: Vec<u8>,
}

impl Di {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Di {
        frame_payload.resize(8, 0);
        Di { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Di, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419326974);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Di::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Dash Display
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dd {
    frame_payload: Vec<u8>,
}

impl Dd {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dd {
        frame_payload.resize(8, 0);
        Dd { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dd, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419364094);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dd::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of air inside vehicle container used to accommodate cargo.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn cargo_ambient_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read EngOilFilterDiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_oil_filter_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.500000).round() as u8
    }

    /// Differential pressure measured across the fuel filter located between the fuel tank and the supply pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_fuel_filter_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Ratio of volume of fuel to the total volume of fuel storage container.
    /// Unit: %
    #[allow(dead_code)]
    pub fn fuel_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Ratio of volume of liquid to total container volume of fluid reservoir in windshield wash system.
    /// Unit: %
    #[allow(dead_code)]
    pub fn washer_fluid_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Cold Start Aids
#[allow(dead_code)]
#[derive(Debug)]
pub struct Csa {
    frame_payload: Vec<u8>,
}

impl Csa {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Csa {
        frame_payload.resize(8, 0);
        Csa { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Csa, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419284734);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Csa::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The start enable device installed for start enable device 2.
    #[allow(dead_code)]
    pub fn eng_start_enable_device2_config_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_start_enable_device2_config(&self) -> EngStartEnableDevice2Config2566768382 {
        EngStartEnableDevice2Config2566768382::from(self.eng_start_enable_device2_config_raw_value() as u64)
    }

    /// The start enable device installed for start enable device 1.
    #[allow(dead_code)]
    pub fn eng_start_enable_device1_config_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_start_enable_device1_config(&self) -> EngStartEnableDevice1Config2566768382 {
        EngStartEnableDevice1Config2566768382::from(self.eng_start_enable_device1_config_raw_value() as u64)
    }

    /// Devices that assist an engine in starting, e.
    #[allow(dead_code)]
    pub fn eng_start_enable_device2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_start_enable_device2(&self) -> EngStartEnableDevice22566768382 {
        EngStartEnableDevice22566768382::from(self.eng_start_enable_device2_raw_value() as u64)
    }

    /// Devices that assist an Engine in starting, e.
    #[allow(dead_code)]
    pub fn eng_start_enable_device1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_start_enable_device1(&self) -> EngStartEnableDevice12566768382 {
        EngStartEnableDevice12566768382::from(self.eng_start_enable_device1_raw_value() as u64)
    }
}

/// Combination Vehicle Weight
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cvw {
    frame_payload: Vec<u8>,
}

impl Cvw {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cvw {
        frame_payload.resize(8, 0);
        Cvw { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cvw, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419328254);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cvw::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total mass imposed by the tires of the powered vehicle on the road surface.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn powered_vehicle_weight_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 10.000000).round() as u16
    }

    /// The total weight of the truck and all attached trailers.
    /// Unit: kg
    #[allow(dead_code)]
    pub fn gross_combination_vehicle_weight_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 10.000000).round() as u16
    }
}

/// Continuous Torque & Speed Limit Request
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ctl {
    frame_payload: Vec<u8>,
}

impl Ctl {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ctl {
        frame_payload.resize(8, 0);
        Ctl { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ctl, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416284414);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ctl::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read MxCntnuousRetarderTorqueLimitRq signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn mx_cntnuous_retarder_torque_limit_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Read MnCntnuousRetarderTorqueLimitRq signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn mn_cntnuous_retarder_torque_limit_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF)) as u8
    }

    /// Read MxCntinuousRetarderSpeedLimitRq signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn mx_cntinuous_retarder_speed_limit_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read MnCntinuousRetarderSpeedLimitRq signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn mn_cntinuous_retarder_speed_limit_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read EngTorqueLimitRqMaxContinuous signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_torque_limit_rq_max_continuous_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Read EngTorqueLimitRqMinContinuous signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_torque_limit_rq_min_continuous_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Read EngSpeedLimitRqMaxContinuous signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_limit_rq_max_continuous_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 32.000000).round() as u8
    }

    /// Read EngSpeedLimitRqMinContinuous signal from can frame
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_limit_rq_min_continuous_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 32.000000).round() as u8
    }
}

/// Combustion Time 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ct6 {
    frame_payload: Vec<u8>,
}

impl Ct6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ct6 {
        frame_payload.resize(8, 0);
        Ct6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ct6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486441214);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ct6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The average combustion time of all cylinders of an engine.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_average_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The desired combustion time based upon engine load and speed lookup maps.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_desired_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.010000).round() as u16
    }
}

/// Combustion Time 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ct5 {
    frame_payload: Vec<u8>,
}

impl Ct5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ct5 {
        frame_payload.resize(8, 0);
        Ct5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ct5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486440958);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ct5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl20_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl19_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl18_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl17_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.010000).round() as u16
    }
}

/// Combustion Time 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ct4 {
    frame_payload: Vec<u8>,
}

impl Ct4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ct4 {
        frame_payload.resize(8, 0);
        Ct4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ct4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486440702);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ct4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl16_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl15_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl14_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl13_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.010000).round() as u16
    }
}

/// Combustion Time 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ct3 {
    frame_payload: Vec<u8>,
}

impl Ct3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ct3 {
        frame_payload.resize(8, 0);
        Ct3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ct3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486440446);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ct3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl12_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl11_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl10_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl9_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.010000).round() as u16
    }
}

/// Combustion Time 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ct2 {
    frame_payload: Vec<u8>,
}

impl Ct2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ct2 {
        frame_payload.resize(8, 0);
        Ct2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ct2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486440190);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ct2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl8_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl7_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl6_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl5_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.010000).round() as u16
    }
}

/// Combustion Time 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ct1 {
    frame_payload: Vec<u8>,
}

impl Ct1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ct1 {
        frame_payload.resize(8, 0);
        Ct1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ct1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486439934);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ct1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl4_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl3_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl2_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.010000).round() as u16
    }

    /// The amount of time from when the ignition of the fuel is initiated to when the fuel is completely ignited (i.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn eng_cyl1_combustion_time_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.010000).round() as u16
    }
}

/// Electronic Control Module Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cmi {
    frame_payload: Vec<u8>,
}

impl Cmi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cmi {
        frame_payload.resize(8, 0);
        Cmi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cmi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486394366);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cmi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total number of times changes have been made to any of the configurable parameters.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn total_count_of_config_changes_made_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Cab Message 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cm3 {
    frame_payload: Vec<u8>,
}

impl Cm3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cm3 {
        frame_payload.resize(8, 0);
        Cm3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cm3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419288318);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cm3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Conveys operator or vehicle system desire for a transmission oil level reading to be taken.
    #[allow(dead_code)]
    pub fn trans_oil_level_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_oil_level_rq(&self) -> TransOilLevelRq2566771966 {
        TransOilLevelRq2566771966::from(self.trans_oil_level_rq_raw_value() as u64)
    }

    /// Operator input used to release the fifth wheel.
    #[allow(dead_code)]
    pub fn fifth_wheel_release_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fifth_wheel_release_ctrl(&self) -> FifthWheelReleaseCtrl2566771966 {
        FifthWheelReleaseCtrl2566771966::from(self.fifth_wheel_release_ctrl_raw_value() as u64)
    }

    /// Operator's fifth wheel release control interlock.
    #[allow(dead_code)]
    pub fn ffth_whl_rlase_ctrl_security_lockout_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ffth_whl_rlase_ctrl_security_lockout(&self) -> FfthWhlRlaseCtrlSecurityLockout2566771966 {
        FfthWhlRlaseCtrlSecurityLockout2566771966::from(self.ffth_whl_rlase_ctrl_security_lockout_raw_value() as u64)
    }

    /// Operator switch to select the condition of the transfer case.
    #[allow(dead_code)]
    pub fn transfer_case_selector_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn transfer_case_selector_switch(&self) -> TransferCaseSelectorSwitch2566771966 {
        TransferCaseSelectorSwitch2566771966::from(self.transfer_case_selector_switch_raw_value() as u64)
    }
}

/// Cab Message 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cm1 {
    frame_payload: Vec<u8>,
}

impl Cm1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cm1 {
        frame_payload.resize(8, 0);
        Cm1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cm1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417398526);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cm1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read SelectedMaxVehicleSpeedLimit signal from can frame
    #[allow(dead_code)]
    pub fn selected_max_vehicle_speed_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// Request to activate cab zone heating.
    #[allow(dead_code)]
    pub fn rq_cab_zone_heating_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rq_cab_zone_heating(&self) -> RqCabZoneHeating2564882174 {
        RqCabZoneHeating2564882174::from(self.rq_cab_zone_heating_raw_value() as u64)
    }

    /// Request to activate engine zone heating.
    #[allow(dead_code)]
    pub fn rq_eng_zone_heating_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rq_eng_zone_heating(&self) -> RqEngZoneHeating2564882174 {
        RqEngZoneHeating2564882174::from(self.rq_eng_zone_heating_raw_value() as u64)
    }

    /// Request to activate the auxiliary heater.
    #[allow(dead_code)]
    pub fn aux_heater_mode_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_heater_mode_rq(&self) -> AuxHeaterModeRq2564882174 {
        AuxHeaterModeRq2564882174::from(self.aux_heater_mode_rq_raw_value() as u64)
    }

    /// Switch signal which enables the idle management system to be enabled.
    #[allow(dead_code)]
    pub fn eng_automatic_start_enable_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    /// Read AtmaticGearShiftingEnableSwitch signal from can frame
    #[allow(dead_code)]
    pub fn atmatic_gear_shifting_enable_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    /// Read VhclLmtngSpdGvernorEnableSwitch signal from can frame
    #[allow(dead_code)]
    pub fn vhcl_lmtng_spd_gvernor_enable_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    /// Switch signal which increases the Vehicle Limiting Speed Governor (VLSG).
    #[allow(dead_code)]
    pub fn vhcl_lmtng_spd_gvrnr_incrment_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    /// Switch signal which decreases the Vehicle Limiting Speed Governor (VLSG).
    #[allow(dead_code)]
    pub fn vhcl_lmtng_spd_gvrnr_dcrement_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    /// Read SeatBeltSwitch signal from can frame
    #[allow(dead_code)]
    pub fn seat_belt_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn seat_belt_switch(&self) -> SeatBeltSwitch2564882174 {
        SeatBeltSwitch2564882174::from(self.seat_belt_switch_raw_value() as u64)
    }

    /// Read OperatorSeatDirectionSwitch signal from can frame
    #[allow(dead_code)]
    pub fn operator_seat_direction_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn operator_seat_direction_switch(&self) -> OperatorSeatDirectionSwitch2564882174 {
        OperatorSeatDirectionSwitch2564882174::from(self.operator_seat_direction_switch_raw_value() as u64)
    }

    /// Request to hold the battery main switch.
    #[allow(dead_code)]
    pub fn battery_main_switch_hold_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn battery_main_switch_hold_rq(&self) -> BatteryMainSwitchHoldRq2564882174 {
        BatteryMainSwitchHoldRq2564882174::from(self.battery_main_switch_hold_rq_raw_value() as u64)
    }

    /// Indicates whether to activate the auxiliary heater coolant water pump.
    #[allow(dead_code)]
    pub fn aux_heater_coolant_pump_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_heater_coolant_pump_rq(&self) -> AuxHeaterCoolantPumpRq2564882174 {
        AuxHeaterCoolantPumpRq2564882174::from(self.aux_heater_coolant_pump_rq_raw_value() as u64)
    }

    /// Parameter used to command a certain cab interior temperature.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn cab_interior_temp_cmd_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Fan speed as a ratio of the actual fan drive (current speed) to the fully engaged fan drive (maximum fan speed).
    /// Unit: %
    #[allow(dead_code)]
    pub fn rqed_percent_fan_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Cab Illumination Message
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cl {
    frame_payload: Vec<u8>,
}

impl Cl {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cl {
        frame_payload.resize(8, 0);
        Cl { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cl, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416349950);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cl::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read IlluminationBrightnessPercent signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn illumination_brightness_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Component Identification
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ci {
    frame_payload: Vec<u8>,
}

impl Ci {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ci {
        frame_payload.resize(8, 0);
        Ci { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ci, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419359742);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ci::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Cruise Control/Vehicle Speed
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ccvs {
    frame_payload: Vec<u8>,
}

impl Ccvs {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ccvs {
        frame_payload.resize(8, 0);
        Ccvs { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ccvs, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419361278);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ccvs::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ParkBrakeReleaseInhibitRq signal from can frame
    #[allow(dead_code)]
    pub fn park_brake_release_inhibit_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn park_brake_release_inhibit_rq(&self) -> ParkBrakeReleaseInhibitRq2566844926 {
        ParkBrakeReleaseInhibitRq2566844926::from(self.park_brake_release_inhibit_rq_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the engine shutdown override switch.
    #[allow(dead_code)]
    pub fn eng_shutdown_override_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_shutdown_override_switch(&self) -> EngShutdownOverrideSwitch2566844926 {
        EngShutdownOverrideSwitch2566844926::from(self.eng_shutdown_override_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the engine test mode switch.
    #[allow(dead_code)]
    pub fn eng_test_mode_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_test_mode_switch(&self) -> EngTestModeSwitch2566844926 {
        EngTestModeSwitch2566844926::from(self.eng_test_mode_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the idle decrement switch.
    #[allow(dead_code)]
    pub fn eng_idle_decrement_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_decrement_switch(&self) -> EngIdleDecrementSwitch2566844926 {
        EngIdleDecrementSwitch2566844926::from(self.eng_idle_decrement_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the position of the idle increment switch.
    #[allow(dead_code)]
    pub fn eng_idle_increment_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_idle_increment_switch(&self) -> EngIdleIncrementSwitch2566844926 {
        EngIdleIncrementSwitch2566844926::from(self.eng_idle_increment_switch_raw_value() as u64)
    }

    /// This parameter is used to indicate the current state, or mode, of operation by the cruise control device.
    #[allow(dead_code)]
    pub fn cruise_ctrl_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x7)) as u8
    }

    /// This parameter is used to indicate the current state or mode of operation by the power takeoff (PTO) device.
    #[allow(dead_code)]
    pub fn pto_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Value of set (chosen) velocity of velocity control system.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn cruise_ctrl_set_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Switch signal of the cruise control activator which indicates that the activator is in the position �accelerate.
    #[allow(dead_code)]
    pub fn cruise_ctrl_accelerate_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_accelerate_switch(&self) -> CruiseCtrlAccelerateSwitch2566844926 {
        CruiseCtrlAccelerateSwitch2566844926::from(self.cruise_ctrl_accelerate_switch_raw_value() as u64)
    }

    /// Switch signal of the cruise control activator which indicates that the activator is in the position �resume.
    #[allow(dead_code)]
    pub fn cruise_ctrl_resume_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_resume_switch(&self) -> CruiseCtrlResumeSwitch2566844926 {
        CruiseCtrlResumeSwitch2566844926::from(self.cruise_ctrl_resume_switch_raw_value() as u64)
    }

    /// Switch signal of the cruise control activator which indicates that the activator is in the position �coast (decelerate).
    #[allow(dead_code)]
    pub fn cruise_ctrl_coast_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_coast_switch(&self) -> CruiseCtrlCoastSwitch2566844926 {
        CruiseCtrlCoastSwitch2566844926::from(self.cruise_ctrl_coast_switch_raw_value() as u64)
    }

    /// Switch signal of the cruise control activator which indicates that the activator is in the position �set.
    #[allow(dead_code)]
    pub fn cruise_ctrl_set_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_set_switch(&self) -> CruiseCtrlSetSwitch2566844926 {
        CruiseCtrlSetSwitch2566844926::from(self.cruise_ctrl_set_switch_raw_value() as u64)
    }

    /// Switch signal which indicates that the clutch pedal is being pressed.
    #[allow(dead_code)]
    pub fn clutch_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn clutch_switch(&self) -> ClutchSwitch2566844926 {
        ClutchSwitch2566844926::from(self.clutch_switch_raw_value() as u64)
    }

    /// Switch signal which indicates that the driver operated brake foot pedal is being pressed.
    #[allow(dead_code)]
    pub fn brake_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn brake_switch(&self) -> BrakeSwitch2566844926 {
        BrakeSwitch2566844926::from(self.brake_switch_raw_value() as u64)
    }

    /// Switch signal which indicates that it is possible to manage the cruise control function.
    #[allow(dead_code)]
    pub fn cruise_ctrl_enable_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_enable_switch(&self) -> CruiseCtrlEnableSwitch2566844926 {
        CruiseCtrlEnableSwitch2566844926::from(self.cruise_ctrl_enable_switch_raw_value() as u64)
    }

    /// Cruise control is switched on.
    #[allow(dead_code)]
    pub fn cruise_ctrl_active_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_active(&self) -> CruiseCtrlActive2566844926 {
        CruiseCtrlActive2566844926::from(self.cruise_ctrl_active_raw_value() as u64)
    }

    /// Speed of the vehicle as calculated from wheel or tailshaft speed.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn wheel_based_vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// Switch signal which indicates the position of the Cruise Control Pause Switch used on Remote Cruise Control applications.
    #[allow(dead_code)]
    pub fn cruise_ctrl_pause_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn cruise_ctrl_pause_switch(&self) -> CruiseCtrlPauseSwitch2566844926 {
        CruiseCtrlPauseSwitch2566844926::from(self.cruise_ctrl_pause_switch_raw_value() as u64)
    }

    /// Switch signal which indicates when the parking brake is set.
    #[allow(dead_code)]
    pub fn parking_brake_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn parking_brake_switch(&self) -> ParkingBrakeSwitch2566844926 {
        ParkingBrakeSwitch2566844926::from(self.parking_brake_switch_raw_value() as u64)
    }

    /// Switch signal which indicates the current axle range.
    #[allow(dead_code)]
    pub fn two_speed_axle_switch_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn two_speed_axle_switch(&self) -> TwoSpeedAxleSwitch2566844926 {
        TwoSpeedAxleSwitch2566844926::from(self.two_speed_axle_switch_raw_value() as u64)
    }
}

/// Cruise Control/Vehicle Speed Setup
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ccss {
    frame_payload: Vec<u8>,
}

impl Ccss {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ccss {
        frame_payload.resize(8, 0);
        Ccss { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ccss, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419360254);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ccss::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read CruiseCtrlLowSetLimitSpeed signal from can frame
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn cruise_ctrl_low_set_limit_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Maximum vehicle velocity at which cruise can be set.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn cruise_ctrl_high_set_limit_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Maximum vehicle velocity allowed.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn max_vehicle_speed_limit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Climate Control Configuration
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ccc {
    frame_payload: Vec<u8>,
}

impl Ccc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ccc {
        frame_payload.resize(8, 0);
        Ccc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ccc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419325950);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ccc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The maximum output power of the auxiliary heater.
    /// Unit: W
    #[allow(dead_code)]
    pub fn aux_heater_max_output_power_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 2.000000).round() as u16
    }
}

/// Compression/Service Brake Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Cbi {
    frame_payload: Vec<u8>,
}

impl Cbi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Cbi {
        frame_payload.resize(8, 0);
        Cbi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Cbi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486456574);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Cbi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total number of times the service brakes have been activated since the last trip reset.
    #[allow(dead_code)]
    pub fn trip_service_brake_apps_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF)) as u32
    }

    /// Total distance over which the service brakes have been active since the last trip reset.
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_service_brake_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }

    /// Total distance over which the compression brakes have been active since the last trip reset.
    /// Unit: km
    #[allow(dead_code)]
    pub fn trip_compression_brake_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }

    /// Total distance over which the compression brakes have been active for the life of the engine.
    /// Unit: km
    #[allow(dead_code)]
    pub fn total_compression_brake_distance_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.125000).round() as u32
    }
}

/// Cab A/C Climate System Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Caci {
    frame_payload: Vec<u8>,
}

impl Caci {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Caci {
        frame_payload.resize(8, 0);
        Caci { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Caci, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419291646);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Caci::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This is the gage pressure at the compressor outlet in the cab air conditioning system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn cb_a_c_rfrgrnt_cmprssor_outlet_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 16.000000).round() as u8
    }
}

/// Battery Temperature
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bt1 {
    frame_payload: Vec<u8>,
}

impl Bt1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bt1 {
        frame_payload.resize(8, 0);
        Bt1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bt1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419320062);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bt1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the battery 2.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn battery2_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Temperature of the battery 1.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn battery1_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Battery Main Switch Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bm {
    frame_payload: Vec<u8>,
}

impl Bm {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bm {
        frame_payload.resize(8, 0);
        Bm { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bm, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419325694);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bm::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Parameter indicating whether the battery main switch is held due to an external request or not.
    #[allow(dead_code)]
    pub fn battery_main_switch_hold_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn battery_main_switch_hold_state(&self) -> BatteryMainSwitchHoldState2566809342 {
        BatteryMainSwitchHoldState2566809342::from(self.battery_main_switch_hold_state_raw_value() as u64)
    }
}

/// Basic Joystick Message 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bjm3 {
    frame_payload: Vec<u8>,
}

impl Bjm3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bjm3 {
        frame_payload.resize(8, 0);
        Bjm3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bjm3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217963262);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bjm3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick3_x_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_x_axis_detent_pos_status(&self) -> Joystick3XAxisDetentPosStatus2365446910 {
        Joystick3XAxisDetentPosStatus2365446910::from(self.joystick3_x_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button9_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button9_pressed_status(&self) -> Joystick3Button9PressedStatus2365446910 {
        Joystick3Button9PressedStatus2365446910::from(self.joystick3_button9_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button10_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button10_pressed_status(&self) -> Joystick3Button10PressedStatus2365446910 {
        Joystick3Button10PressedStatus2365446910::from(self.joystick3_button10_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button11_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button11_pressed_status(&self) -> Joystick3Button11PressedStatus2365446910 {
        Joystick3Button11PressedStatus2365446910::from(self.joystick3_button11_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button12_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button12_pressed_status(&self) -> Joystick3Button12PressedStatus2365446910 {
        Joystick3Button12PressedStatus2365446910::from(self.joystick3_button12_pressed_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick3_y_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_y_axis_detent_pos_status(&self) -> Joystick3YAxisDetentPosStatus2365446910 {
        Joystick3YAxisDetentPosStatus2365446910::from(self.joystick3_y_axis_detent_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick3_y_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck3YAxsLvrFrwrdPstvPsStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_y_axs_lvr_frwrd_pstv_ps_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_y_axs_lvr_frwrd_pstv_ps_status(&self) -> Jystck3YAxsLvrFrwrdPstvPsStatus2365446910 {
        Jystck3YAxsLvrFrwrdPstvPsStatus2365446910::from(self.jystck3_y_axs_lvr_frwrd_pstv_ps_status_raw_value() as u64)
    }

    /// Read Jystck3YAxsLvrBckNgtvePosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_y_axs_lvr_bck_ngtve_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_y_axs_lvr_bck_ngtve_pos_status(&self) -> Jystck3YAxsLvrBckNgtvePosStatus2365446910 {
        Jystck3YAxsLvrBckNgtvePosStatus2365446910::from(self.jystck3_y_axs_lvr_bck_ngtve_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick3_y_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_y_axis_neutral_pos_status(&self) -> Joystick3YAxisNeutralPosStatus2365446910 {
        Joystick3YAxisNeutralPosStatus2365446910::from(self.joystick3_y_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick3_x_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck3XAxsLvrRghtPstvPosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_x_axs_lvr_rght_pstv_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_x_axs_lvr_rght_pstv_pos_status(&self) -> Jystck3XAxsLvrRghtPstvPosStatus2365446910 {
        Jystck3XAxsLvrRghtPstvPosStatus2365446910::from(self.jystck3_x_axs_lvr_rght_pstv_pos_status_raw_value() as u64)
    }

    /// Read Jystck3XAxsLvrLftNgtvePosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck3_x_axs_lvr_lft_ngtve_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck3_x_axs_lvr_lft_ngtve_pos_status(&self) -> Jystck3XAxsLvrLftNgtvePosStatus2365446910 {
        Jystck3XAxsLvrLftNgtvePosStatus2365446910::from(self.jystck3_x_axs_lvr_lft_ngtve_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick3_x_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_x_axis_neutral_pos_status(&self) -> Joystick3XAxisNeutralPosStatus2365446910 {
        Joystick3XAxisNeutralPosStatus2365446910::from(self.joystick3_x_axis_neutral_pos_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button5_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button5_pressed_status(&self) -> Joystick3Button5PressedStatus2365446910 {
        Joystick3Button5PressedStatus2365446910::from(self.joystick3_button5_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button6_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button6_pressed_status(&self) -> Joystick3Button6PressedStatus2365446910 {
        Joystick3Button6PressedStatus2365446910::from(self.joystick3_button6_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button7_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button7_pressed_status(&self) -> Joystick3Button7PressedStatus2365446910 {
        Joystick3Button7PressedStatus2365446910::from(self.joystick3_button7_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button8_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button8_pressed_status(&self) -> Joystick3Button8PressedStatus2365446910 {
        Joystick3Button8PressedStatus2365446910::from(self.joystick3_button8_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button1_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button1_pressed_status(&self) -> Joystick3Button1PressedStatus2365446910 {
        Joystick3Button1PressedStatus2365446910::from(self.joystick3_button1_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button2_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button2_pressed_status(&self) -> Joystick3Button2PressedStatus2365446910 {
        Joystick3Button2PressedStatus2365446910::from(self.joystick3_button2_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button3_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button3_pressed_status(&self) -> Joystick3Button3PressedStatus2365446910 {
        Joystick3Button3PressedStatus2365446910::from(self.joystick3_button3_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick3_button4_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick3_button4_pressed_status(&self) -> Joystick3Button4PressedStatus2365446910 {
        Joystick3Button4PressedStatus2365446910::from(self.joystick3_button4_pressed_status_raw_value() as u64)
    }
}

/// Basic Joystick Message 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bjm2 {
    frame_payload: Vec<u8>,
}

impl Bjm2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bjm2 {
        frame_payload.resize(8, 0);
        Bjm2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bjm2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217962750);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bjm2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick2_x_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_x_axis_detent_pos_status(&self) -> Joystick2XAxisDetentPosStatus2365446398 {
        Joystick2XAxisDetentPosStatus2365446398::from(self.joystick2_x_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick2_y_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_y_axis_detent_pos_status(&self) -> Joystick2YAxisDetentPosStatus2365446398 {
        Joystick2YAxisDetentPosStatus2365446398::from(self.joystick2_y_axis_detent_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick2_y_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck2YAxsLvrFrwrdPstvPsStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_y_axs_lvr_frwrd_pstv_ps_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_y_axs_lvr_frwrd_pstv_ps_status(&self) -> Jystck2YAxsLvrFrwrdPstvPsStatus2365446398 {
        Jystck2YAxsLvrFrwrdPstvPsStatus2365446398::from(self.jystck2_y_axs_lvr_frwrd_pstv_ps_status_raw_value() as u64)
    }

    /// Read Jystck2YAxsLvrBckNgtvePosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_y_axs_lvr_bck_ngtve_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_y_axs_lvr_bck_ngtve_pos_status(&self) -> Jystck2YAxsLvrBckNgtvePosStatus2365446398 {
        Jystck2YAxsLvrBckNgtvePosStatus2365446398::from(self.jystck2_y_axs_lvr_bck_ngtve_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick2_y_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_y_axis_neutral_pos_status(&self) -> Joystick2YAxisNeutralPosStatus2365446398 {
        Joystick2YAxisNeutralPosStatus2365446398::from(self.joystick2_y_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick2_x_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck2XAxsLvrRghtPstvPosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_x_axs_lvr_rght_pstv_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_x_axs_lvr_rght_pstv_pos_status(&self) -> Jystck2XAxsLvrRghtPstvPosStatus2365446398 {
        Jystck2XAxsLvrRghtPstvPosStatus2365446398::from(self.jystck2_x_axs_lvr_rght_pstv_pos_status_raw_value() as u64)
    }

    /// Read Jystck2XAxsLvrLftNgtvePosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck2_x_axs_lvr_lft_ngtve_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck2_x_axs_lvr_lft_ngtve_pos_status(&self) -> Jystck2XAxsLvrLftNgtvePosStatus2365446398 {
        Jystck2XAxsLvrLftNgtvePosStatus2365446398::from(self.jystck2_x_axs_lvr_lft_ngtve_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick2_x_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_x_axis_neutral_pos_status(&self) -> Joystick2XAxisNeutralPosStatus2365446398 {
        Joystick2XAxisNeutralPosStatus2365446398::from(self.joystick2_x_axis_neutral_pos_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button9_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button9_pressed_status(&self) -> Joystick2Button9PressedStatus2365446398 {
        Joystick2Button9PressedStatus2365446398::from(self.joystick2_button9_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button10_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button10_pressed_status(&self) -> Joystick2Button10PressedStatus2365446398 {
        Joystick2Button10PressedStatus2365446398::from(self.joystick2_button10_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button11_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button11_pressed_status(&self) -> Joystick2Button11PressedStatus2365446398 {
        Joystick2Button11PressedStatus2365446398::from(self.joystick2_button11_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button12_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button12_pressed_status(&self) -> Joystick2Button12PressedStatus2365446398 {
        Joystick2Button12PressedStatus2365446398::from(self.joystick2_button12_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button5_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button5_pressed_status(&self) -> Joystick2Button5PressedStatus2365446398 {
        Joystick2Button5PressedStatus2365446398::from(self.joystick2_button5_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button6_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button6_pressed_status(&self) -> Joystick2Button6PressedStatus2365446398 {
        Joystick2Button6PressedStatus2365446398::from(self.joystick2_button6_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button7_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button7_pressed_status(&self) -> Joystick2Button7PressedStatus2365446398 {
        Joystick2Button7PressedStatus2365446398::from(self.joystick2_button7_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button8_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button8_pressed_status(&self) -> Joystick2Button8PressedStatus2365446398 {
        Joystick2Button8PressedStatus2365446398::from(self.joystick2_button8_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button1_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button1_pressed_status(&self) -> Joystick2Button1PressedStatus2365446398 {
        Joystick2Button1PressedStatus2365446398::from(self.joystick2_button1_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button2_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button2_pressed_status(&self) -> Joystick2Button2PressedStatus2365446398 {
        Joystick2Button2PressedStatus2365446398::from(self.joystick2_button2_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button3_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button3_pressed_status(&self) -> Joystick2Button3PressedStatus2365446398 {
        Joystick2Button3PressedStatus2365446398::from(self.joystick2_button3_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick2_button4_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick2_button4_pressed_status(&self) -> Joystick2Button4PressedStatus2365446398 {
        Joystick2Button4PressedStatus2365446398::from(self.joystick2_button4_pressed_status_raw_value() as u64)
    }
}

/// Basic Joystick Message 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bjm1 {
    frame_payload: Vec<u8>,
}

impl Bjm1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bjm1 {
        frame_payload.resize(8, 0);
        Bjm1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bjm1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217962238);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bjm1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick1_x_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_x_axis_detent_pos_status(&self) -> Joystick1XAxisDetentPosStatus2365445886 {
        Joystick1XAxisDetentPosStatus2365445886::from(self.joystick1_x_axis_detent_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the detent position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick1_y_axis_detent_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_y_axis_detent_pos_status(&self) -> Joystick1YAxisDetentPosStatus2365445886 {
        Joystick1YAxisDetentPosStatus2365445886::from(self.joystick1_y_axis_detent_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick1_y_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Read Jystck1YAxsLvrFrwrdPstvPsStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_y_axs_lvr_frwrd_pstv_ps_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_y_axs_lvr_frwrd_pstv_ps_status(&self) -> Jystck1YAxsLvrFrwrdPstvPsStatus2365445886 {
        Jystck1YAxsLvrFrwrdPstvPsStatus2365445886::from(self.jystck1_y_axs_lvr_frwrd_pstv_ps_status_raw_value() as u64)
    }

    /// Read Jystck1YAxsLvrBckNgtvePosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_y_axs_lvr_bck_ngtve_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_y_axs_lvr_bck_ngtve_pos_status(&self) -> Jystck1YAxsLvrBckNgtvePosStatus2365445886 {
        Jystck1YAxsLvrBckNgtvePosStatus2365445886::from(self.jystck1_y_axs_lvr_bck_ngtve_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick1_y_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_y_axis_neutral_pos_status(&self) -> Joystick1YAxisNeutralPosStatus2365445886 {
        Joystick1YAxisNeutralPosStatus2365445886::from(self.joystick1_y_axis_neutral_pos_status_raw_value() as u64)
    }

    /// The position of the joystick in the relative motion of travel from the neutral position.
    /// Unit: %
    #[allow(dead_code)]
    pub fn joystick1_x_axis_pos_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3FF) as f64 * 0.100000).round() as u16
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button9_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button9_pressed_status(&self) -> Joystick1Button9PressedStatus2365445886 {
        Joystick1Button9PressedStatus2365445886::from(self.joystick1_button9_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button10_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button10_pressed_status(&self) -> Joystick1Button10PressedStatus2365445886 {
        Joystick1Button10PressedStatus2365445886::from(self.joystick1_button10_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button11_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button11_pressed_status(&self) -> Joystick1Button11PressedStatus2365445886 {
        Joystick1Button11PressedStatus2365445886::from(self.joystick1_button11_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button12_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button12_pressed_status(&self) -> Joystick1Button12PressedStatus2365445886 {
        Joystick1Button12PressedStatus2365445886::from(self.joystick1_button12_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button5_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button5_pressed_status(&self) -> Joystick1Button5PressedStatus2365445886 {
        Joystick1Button5PressedStatus2365445886::from(self.joystick1_button5_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button6_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button6_pressed_status(&self) -> Joystick1Button6PressedStatus2365445886 {
        Joystick1Button6PressedStatus2365445886::from(self.joystick1_button6_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button7_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button7_pressed_status(&self) -> Joystick1Button7PressedStatus2365445886 {
        Joystick1Button7PressedStatus2365445886::from(self.joystick1_button7_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button8_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button8_pressed_status(&self) -> Joystick1Button8PressedStatus2365445886 {
        Joystick1Button8PressedStatus2365445886::from(self.joystick1_button8_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button1_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button1_pressed_status(&self) -> Joystick1Button1PressedStatus2365445886 {
        Joystick1Button1PressedStatus2365445886::from(self.joystick1_button1_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button2_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button2_pressed_status(&self) -> Joystick1Button2PressedStatus2365445886 {
        Joystick1Button2PressedStatus2365445886::from(self.joystick1_button2_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button3_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button3_pressed_status(&self) -> Joystick1Button3PressedStatus2365445886 {
        Joystick1Button3PressedStatus2365445886::from(self.joystick1_button3_pressed_status_raw_value() as u64)
    }

    /// Reports when the joystick button has been pressed.
    #[allow(dead_code)]
    pub fn joystick1_button4_pressed_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_button4_pressed_status(&self) -> Joystick1Button4PressedStatus2365445886 {
        Joystick1Button4PressedStatus2365445886::from(self.joystick1_button4_pressed_status_raw_value() as u64)
    }

    /// Read Jystck1XAxsLvrRghtPstvPosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_x_axs_lvr_rght_pstv_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_x_axs_lvr_rght_pstv_pos_status(&self) -> Jystck1XAxsLvrRghtPstvPosStatus2365445886 {
        Jystck1XAxsLvrRghtPstvPosStatus2365445886::from(self.jystck1_x_axs_lvr_rght_pstv_pos_status_raw_value() as u64)
    }

    /// Read Jystck1XAxsLvrLftNgtvePosStatus signal from can frame
    #[allow(dead_code)]
    pub fn jystck1_x_axs_lvr_lft_ngtve_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn jystck1_x_axs_lvr_lft_ngtve_pos_status(&self) -> Jystck1XAxsLvrLftNgtvePosStatus2365445886 {
        Jystck1XAxsLvrLftNgtvePosStatus2365445886::from(self.jystck1_x_axs_lvr_lft_ngtve_pos_status_raw_value() as u64)
    }

    /// Reports when the current joystick position is in the neutral position for that axis of travel.
    #[allow(dead_code)]
    pub fn joystick1_x_axis_neutral_pos_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn joystick1_x_axis_neutral_pos_status(&self) -> Joystick1XAxisNeutralPosStatus2365445886 {
        Joystick1XAxisNeutralPosStatus2365445886::from(self.joystick1_x_axis_neutral_pos_status_raw_value() as u64)
    }
}

/// Brakes
#[allow(dead_code)]
#[derive(Debug)]
pub struct B {
    frame_payload: Vec<u8>,
}

impl B {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> B {
        frame_payload.resize(8, 0);
        B { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<B, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419363582);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| B::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter commands the Parking Brake red optical warning signal.
    #[allow(dead_code)]
    pub fn parking_brake_red_warning_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn parking_brake_red_warning_signal(&self) -> ParkingBrakeRedWarningSignal2566847230 {
        ParkingBrakeRedWarningSignal2566847230::from(self.parking_brake_red_warning_signal_raw_value() as u64)
    }

    /// This parameter provides reports on the status of the Park Brake Release Inhibit function.
    #[allow(dead_code)]
    pub fn park_brake_release_inhibit_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn park_brake_release_inhibit_status(&self) -> ParkBrakeReleaseInhibitStatus2566847230 {
        ParkBrakeReleaseInhibitStatus2566847230::from(self.park_brake_release_inhibit_status_raw_value() as u64)
    }

    /// Signal which indicates the current state of the actuator(s) that control the parking brake (see also SPN 70).
    #[allow(dead_code)]
    pub fn parking_brake_actuator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn parking_brake_actuator(&self) -> ParkingBrakeActuator2566847230 {
        ParkingBrakeActuator2566847230::from(self.parking_brake_actuator_raw_value() as u64)
    }

    /// Gage pressure of air in the secondary, or service side, of the air brake system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brake_second_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Gage pressure of air in the primary, or supply side, of the air brake system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brake_primary_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Read BrakeAppPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn brake_app_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// Auxiliary Water Pump Pressure
#[allow(dead_code)]
#[derive(Debug)]
pub struct Awpp {
    frame_payload: Vec<u8>,
}

impl Awpp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Awpp {
        frame_payload.resize(8, 0);
        Awpp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Awpp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419364606);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Awpp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Gage pressure of auxiliary water pump driven as a PTO device.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_pump_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 16.000000).round() as u8
    }
}

/// Anti-theft Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ats {
    frame_payload: Vec<u8>,
}

impl Ats {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ats {
        frame_payload.resize(8, 0);
        Ats { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ats, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(484245246);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ats::new(frame.data().to_vec())));
        Ok(f)
    }

    /// A seven byte random numeric code provided by the component in response to an anti-theft request.
    #[allow(dead_code)]
    pub fn antitheft_random_number_raw_value(&self) -> u64 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFFFFFFFFFFFF)) as u64
    }

    /// Indicates whether or not the component can be started.
    #[allow(dead_code)]
    pub fn antitheft_component_status_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn antitheft_component_status_states(&self) -> AntitheftComponentStatusStates2631728894 {
        AntitheftComponentStatusStates2631728894::from(self.antitheft_component_status_states_raw_value() as u64)
    }

    /// Indicates the presence of the encryption seed random number.
    #[allow(dead_code)]
    pub fn antthft_encryptn_sd_prsnt_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn antthft_encryptn_sd_prsnt_indicator(&self) -> AntthftEncryptnSdPrsntIndicator2631728894 {
        AntthftEncryptnSdPrsntIndicator2631728894::from(self.antthft_encryptn_sd_prsnt_indicator_raw_value() as u64)
    }

    /// Read AntitheftModifyPwdStates signal from can frame
    #[allow(dead_code)]
    pub fn antitheft_modify_pwd_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn antitheft_modify_pwd_states(&self) -> AntitheftModifyPwdStates2631728894 {
        AntitheftModifyPwdStates2631728894::from(self.antitheft_modify_pwd_states_raw_value() as u64)
    }

    /// Indicates the presence of a validated password.
    #[allow(dead_code)]
    pub fn antitheft_pwd_valid_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn antitheft_pwd_valid_indicator(&self) -> AntitheftPwdValidIndicator2631728894 {
        AntitheftPwdValidIndicator2631728894::from(self.antitheft_pwd_valid_indicator_raw_value() as u64)
    }
}

/// Anti-theft Request
#[allow(dead_code)]
#[derive(Debug)]
pub struct Atr {
    frame_payload: Vec<u8>,
}

impl Atr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Atr {
        frame_payload.resize(8, 0);
        Atr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Atr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(484310782);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Atr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter is the seven byte numeric code (i.
    #[allow(dead_code)]
    pub fn antitheft_password_representation_raw_value(&self) -> u64 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFFFFFFFFFFFF)) as u64
    }

    /// This parameter is used to identify the specific requests being sent to the component.
    #[allow(dead_code)]
    pub fn antitheft_cmd_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 5) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn antitheft_cmd_states(&self) -> AntitheftCmdStates2631794430 {
        AntitheftCmdStates2631794430::from(self.antitheft_cmd_states_raw_value() as u64)
    }

    /// Read AntitheftDesiredExitModeStates signal from can frame
    #[allow(dead_code)]
    pub fn antitheft_desired_exit_mode_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 3) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn antitheft_desired_exit_mode_states(&self) -> AntitheftDesiredExitModeStates2631794430 {
        AntitheftDesiredExitModeStates2631794430::from(self.antitheft_desired_exit_mode_states_raw_value() as u64)
    }

    /// Read AntthftEncryptonIndicatorStates signal from can frame
    #[allow(dead_code)]
    pub fn antthft_encrypton_indicator_states_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 1) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn antthft_encrypton_indicator_states(&self) -> AntthftEncryptonIndicatorStates2631794430 {
        AntthftEncryptonIndicatorStates2631794430::from(self.antthft_encrypton_indicator_states_raw_value() as u64)
    }
}

/// Alternator Temperature
#[allow(dead_code)]
#[derive(Debug)]
pub struct At {
    frame_payload: Vec<u8>,
}

impl At {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At {
        frame_payload.resize(8, 0);
        At { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486451198);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Temperature of the windings inside the alternator.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_alt_winding3_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Temperature of the windings inside the alternator.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_alt_winding2_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Temperature of the windings inside the alternator.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_alt_winding1_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Temperature of the bearing inside the alternator.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_alt_bearing2_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Temperature of the bearing inside the alternator.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_alt_bearing1_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Air Suspension Control 6
#[allow(dead_code)]
#[derive(Debug)]
pub struct Asc6 {
    frame_payload: Vec<u8>,
}

impl Asc6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Asc6 {
        frame_payload.resize(8, 0);
        Asc6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Asc6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(215088894);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Asc6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Set value for nominal level 'preset level' at the right side of the rear axle.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn level_preset_rear_axle_right_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Set value for nominal level 'preset level' at the left side of the rear axle.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn level_preset_rear_axle_left_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Set value for nominal level 'preset level' at the right side of the front axle.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn level_preset_front_axle_right_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Set value for nominal level 'preset level' at the left side of the front axle.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn level_preset_front_axle_left_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Air Suspension Control 5
#[allow(dead_code)]
#[derive(Debug)]
pub struct Asc5 {
    frame_payload: Vec<u8>,
}

impl Asc5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Asc5 {
        frame_payload.resize(8, 0);
        Asc5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Asc5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217995262);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Asc5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates the current mode of operation of the electronic shock absorber control at the lift/tag axle.
    #[allow(dead_code)]
    pub fn elctrnc_shck_absrbr_ctrl_md_lft_tg_axl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn elctrnc_shck_absrbr_ctrl_md_lft_tg_axl(&self) -> ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910 {
        ElctrncShckAbsrbrCtrlMdLftTgAxl2365478910::from(self.elctrnc_shck_absrbr_ctrl_md_lft_tg_axl_raw_value() as u64)
    }

    /// Signal which indicates the current mode of operation of the electronic shock absorber control at the rear axle.
    #[allow(dead_code)]
    pub fn elctrnc_shck_absrbr_ctrl_md_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn elctrnc_shck_absrbr_ctrl_md_rear_axle(&self) -> ElctrncShckAbsrbrCtrlMdRearAxle2365478910 {
        ElctrncShckAbsrbrCtrlMdRearAxle2365478910::from(self.elctrnc_shck_absrbr_ctrl_md_rear_axle_raw_value() as u64)
    }

    /// Signal which indicates the current mode of operation of the electronic shock absorber control at the front axle.
    #[allow(dead_code)]
    pub fn elctrnc_shck_absrbr_ctrl_md_frnt_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn elctrnc_shck_absrbr_ctrl_md_frnt_axle(&self) -> ElctrncShckAbsrbrCtrlMdFrntAxle2365478910 {
        ElctrncShckAbsrbrCtrlMdFrntAxle2365478910::from(self.elctrnc_shck_absrbr_ctrl_md_frnt_axle_raw_value() as u64)
    }

    /// Read DamperStiffnessLift_TagAxle signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn damper_stiffness_lift_tag_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read DamperStiffnessRearAxle signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn damper_stiffness_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read DamperStiffnessFrontAxle signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn damper_stiffness_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Air Suspension Control 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Asc4 {
    frame_payload: Vec<u8>,
}

impl Asc4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Asc4 {
        frame_payload.resize(8, 0);
        Asc4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Asc4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419322110);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Asc4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read BellowPressRearAxleRight signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn bellow_press_rear_axle_right_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read BellowPressRearAxleLeft signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn bellow_press_rear_axle_left_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read BellowPressFrontAxleRight signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn bellow_press_front_axle_right_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read BellowPressFrontAxleLeft signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn bellow_press_front_axle_left_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Air Suspension Control 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Asc3 {
    frame_payload: Vec<u8>,
}

impl Asc3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Asc3 {
        frame_payload.resize(8, 0);
        Asc3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Asc3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419322366);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Asc3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Information of the height at the left side of the rear axle referred to normal level 1.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn relative_level_rear_axle_right_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Information of the height at the left side of the rear axle referred to normal level 1.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn relative_level_rear_axle_left_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Information of the height at the right side of the front axle referred to normal level 1.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn relative_level_front_axle_right_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Information of the height at the left side of the front axle referred to normal level 1.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn relative_level_front_axle_left_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Air Suspension Control 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Asc2 {
    frame_payload: Vec<u8>,
}

impl Asc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Asc2 {
        frame_payload.resize(8, 0);
        Asc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Asc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(215154430);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Asc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter contains an external request to prohibit all air suspension control.
    #[allow(dead_code)]
    pub fn prohibit_air_suspension_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn prohibit_air_suspension_ctrl(&self) -> ProhibitAirSuspensionCtrl2362638078 {
        ProhibitAirSuspensionCtrl2362638078::from(self.prohibit_air_suspension_ctrl_raw_value() as u64)
    }

    /// Command signal to activate the kneeling functionality at the rear axle of the vehicle.
    #[allow(dead_code)]
    pub fn kneeling_cmd_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn kneeling_cmd_rear_axle(&self) -> KneelingCmdRearAxle2362638078 {
        KneelingCmdRearAxle2362638078::from(self.kneeling_cmd_rear_axle_raw_value() as u64)
    }

    /// Read KneelingCmdFrontAxle signal from can frame
    #[allow(dead_code)]
    pub fn kneeling_cmd_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn kneeling_cmd_front_axle(&self) -> KneelingCmdFrontAxle2362638078 {
        KneelingCmdFrontAxle2362638078::from(self.kneeling_cmd_front_axle_raw_value() as u64)
    }

    /// Read DamperStiffnessRqLift_TagAxle signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn damper_stiffness_rq_lift_tag_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Demand value for the shock absorber control at the rear axle.
    /// Unit: %
    #[allow(dead_code)]
    pub fn damper_stiffness_rq_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Demand value for the shock absorber control at the front axle.
    /// Unit: %
    #[allow(dead_code)]
    pub fn damper_stiffness_rq_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read LevelCtrlModeRq signal from can frame
    #[allow(dead_code)]
    pub fn level_ctrl_mode_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn level_ctrl_mode_rq(&self) -> LevelCtrlModeRq2362638078 {
        LevelCtrlModeRq2362638078::from(self.level_ctrl_mode_rq_raw_value() as u64)
    }

    /// Command signal to activate a level of the rear axle programmed and/or memorised in the ECU.
    #[allow(dead_code)]
    pub fn nominal_level_rq_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn nominal_level_rq_rear_axle(&self) -> NominalLevelRqRearAxle2362638078 {
        NominalLevelRqRearAxle2362638078::from(self.nominal_level_rq_rear_axle_raw_value() as u64)
    }

    /// Read NominalLevelRqFrontAxle signal from can frame
    #[allow(dead_code)]
    pub fn nominal_level_rq_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn nominal_level_rq_front_axle(&self) -> NominalLevelRqFrontAxle2362638078 {
        NominalLevelRqFrontAxle2362638078::from(self.nominal_level_rq_front_axle_raw_value() as u64)
    }

    /// Read KneelingCtrlModeRq signal from can frame
    #[allow(dead_code)]
    pub fn kneeling_ctrl_mode_rq_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn kneeling_ctrl_mode_rq(&self) -> KneelingCtrlModeRq2362638078 {
        KneelingCtrlModeRq2362638078::from(self.kneeling_ctrl_mode_rq_raw_value() as u64)
    }

    /// Read KneelingRqRightSide signal from can frame
    #[allow(dead_code)]
    pub fn kneeling_rq_right_side_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn kneeling_rq_right_side(&self) -> KneelingRqRightSide2362638078 {
        KneelingRqRightSide2362638078::from(self.kneeling_rq_right_side_raw_value() as u64)
    }

    /// Read KneelingRqLeftSide signal from can frame
    #[allow(dead_code)]
    pub fn kneeling_rq_left_side_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn kneeling_rq_left_side(&self) -> KneelingRqLeftSide2362638078 {
        KneelingRqLeftSide2362638078::from(self.kneeling_rq_left_side_raw_value() as u64)
    }

    /// Read AutomaticTractionHelp signal from can frame
    #[allow(dead_code)]
    pub fn automatic_traction_help_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn automatic_traction_help(&self) -> AutomaticTractionHelp2362638078 {
        AutomaticTractionHelp2362638078::from(self.automatic_traction_help_raw_value() as u64)
    }

    /// Signal to command the position / load condition of lift / tag axle #2.
    #[allow(dead_code)]
    pub fn lift_axle2_pos_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle2_pos_cmd(&self) -> LiftAxle2PosCmd2362638078 {
        LiftAxle2PosCmd2362638078::from(self.lift_axle2_pos_cmd_raw_value() as u64)
    }

    /// Signal to command the position/load condition of lift/tag axle #1.
    #[allow(dead_code)]
    pub fn lift_axle1_pos_cmd_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle1_pos_cmd(&self) -> LiftAxle1PosCmd2362638078 {
        LiftAxle1PosCmd2362638078::from(self.lift_axle1_pos_cmd_raw_value() as u64)
    }
}

/// Air Suspension Control 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Asc1 {
    frame_payload: Vec<u8>,
}

impl Asc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Asc1 {
        frame_payload.resize(8, 0);
        Asc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Asc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217996030);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Asc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal which indicates that the air suspension control cannot perform a request due to the operating conditions.
    #[allow(dead_code)]
    pub fn sspension_ctrl_refusal_information_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn sspension_ctrl_refusal_information(&self) -> SspensionCtrlRefusalInformation2365479678 {
        SspensionCtrlRefusalInformation2365479678::from(self.sspension_ctrl_refusal_information_raw_value() as u64)
    }

    /// Signal which indicates that the suspension system is controlled by remote control #2.
    #[allow(dead_code)]
    pub fn suspension_remote_ctrl2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn suspension_remote_ctrl2(&self) -> SuspensionRemoteCtrl22365479678 {
        SuspensionRemoteCtrl22365479678::from(self.suspension_remote_ctrl2_raw_value() as u64)
    }

    /// Signal which indicates that the suspension system is controlled by remote control #1.
    #[allow(dead_code)]
    pub fn suspension_remote_ctrl1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn suspension_remote_ctrl1(&self) -> SuspensionRemoteCtrl12365479678 {
        SuspensionRemoteCtrl12365479678::from(self.suspension_remote_ctrl1_raw_value() as u64)
    }

    /// Signal which indicates that the vehicle height at the rear axle (SPNs 1723 and 1724) is within the bumper range.
    #[allow(dead_code)]
    pub fn rear_axle_in_bumper_range_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn rear_axle_in_bumper_range(&self) -> RearAxleInBumperRange2365479678 {
        RearAxleInBumperRange2365479678::from(self.rear_axle_in_bumper_range_raw_value() as u64)
    }

    /// Signal which indicates that the vehicle height at the front axle (SPNs 1721 and 1722) is within the bumper range.
    #[allow(dead_code)]
    pub fn front_axle_in_bumper_range_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn front_axle_in_bumper_range(&self) -> FrontAxleInBumperRange2365479678 {
        FrontAxleInBumperRange2365479678::from(self.front_axle_in_bumper_range_raw_value() as u64)
    }

    /// Signal which indicates that the doors may be opened.
    #[allow(dead_code)]
    pub fn door_release_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn door_release(&self) -> DoorRelease2365479678 {
        DoorRelease2365479678::from(self.door_release_raw_value() as u64)
    }

    /// Signal which indicates whether vehicle motion is inhibited.
    #[allow(dead_code)]
    pub fn vehicle_motion_inhibit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vehicle_motion_inhibit(&self) -> VehicleMotionInhibit2365479678 {
        VehicleMotionInhibit2365479678::from(self.vehicle_motion_inhibit_raw_value() as u64)
    }

    /// The signal which indicates the status of the security device.
    #[allow(dead_code)]
    pub fn security_device_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn security_device(&self) -> SecurityDevice2365479678 {
        SecurityDevice2365479678::from(self.security_device_raw_value() as u64)
    }

    /// Read LevelCtrlMode signal from can frame
    #[allow(dead_code)]
    pub fn level_ctrl_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn level_ctrl_mode(&self) -> LevelCtrlMode2365479678 {
        LevelCtrlMode2365479678::from(self.level_ctrl_mode_raw_value() as u64)
    }

    /// Read KneelingInformation signal from can frame
    #[allow(dead_code)]
    pub fn kneeling_information_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn kneeling_information(&self) -> KneelingInformation2365479678 {
        KneelingInformation2365479678::from(self.kneeling_information_raw_value() as u64)
    }

    /// Read LiftingCtrlModeRearAxle signal from can frame
    #[allow(dead_code)]
    pub fn lifting_ctrl_mode_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lifting_ctrl_mode_rear_axle(&self) -> LiftingCtrlModeRearAxle2365479678 {
        LiftingCtrlModeRearAxle2365479678::from(self.lifting_ctrl_mode_rear_axle_raw_value() as u64)
    }

    /// Read LiftingCtrlModeFrontAxle signal from can frame
    #[allow(dead_code)]
    pub fn lifting_ctrl_mode_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lifting_ctrl_mode_front_axle(&self) -> LiftingCtrlModeFrontAxle2365479678 {
        LiftingCtrlModeFrontAxle2365479678::from(self.lifting_ctrl_mode_front_axle_raw_value() as u64)
    }

    /// Read LoweringCtrlModeRearAxle signal from can frame
    #[allow(dead_code)]
    pub fn lowering_ctrl_mode_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lowering_ctrl_mode_rear_axle(&self) -> LoweringCtrlModeRearAxle2365479678 {
        LoweringCtrlModeRearAxle2365479678::from(self.lowering_ctrl_mode_rear_axle_raw_value() as u64)
    }

    /// Read LoweringCtrlModeFrontAxle signal from can frame
    #[allow(dead_code)]
    pub fn lowering_ctrl_mode_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lowering_ctrl_mode_front_axle(&self) -> LoweringCtrlModeFrontAxle2365479678 {
        LoweringCtrlModeFrontAxle2365479678::from(self.lowering_ctrl_mode_front_axle_raw_value() as u64)
    }

    /// Signal which indicates whether the actual height of the rear axle is above the nominal (desired) level of the rear axle.
    #[allow(dead_code)]
    pub fn above_nominal_level_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn above_nominal_level_rear_axle(&self) -> AboveNominalLevelRearAxle2365479678 {
        AboveNominalLevelRearAxle2365479678::from(self.above_nominal_level_rear_axle_raw_value() as u64)
    }

    /// Signal which indicates whether the actual height of the front axle is above the nominal (desired) level of the front axle.
    #[allow(dead_code)]
    pub fn above_nominal_level_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn above_nominal_level_front_axle(&self) -> AboveNominalLevelFrontAxle2365479678 {
        AboveNominalLevelFrontAxle2365479678::from(self.above_nominal_level_front_axle_raw_value() as u64)
    }

    /// Signal which indicates whether the actual height of the rear axle is below the nominal (desired) level for the rear axle.
    #[allow(dead_code)]
    pub fn below_nominal_level_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn below_nominal_level_rear_axle(&self) -> BelowNominalLevelRearAxle2365479678 {
        BelowNominalLevelRearAxle2365479678::from(self.below_nominal_level_rear_axle_raw_value() as u64)
    }

    /// Signal which indicates whether the actual height of the front axle is below the nominal (desired) level for the front axle.
    #[allow(dead_code)]
    pub fn below_nominal_level_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn below_nominal_level_front_axle(&self) -> BelowNominalLevelFrontAxle2365479678 {
        BelowNominalLevelFrontAxle2365479678::from(self.below_nominal_level_front_axle_raw_value() as u64)
    }

    /// Signal which indicates the nominal (desired) height of the rear axle to be controlled by the suspension system.
    #[allow(dead_code)]
    pub fn nominal_level_rear_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn nominal_level_rear_axle(&self) -> NominalLevelRearAxle2365479678 {
        NominalLevelRearAxle2365479678::from(self.nominal_level_rear_axle_raw_value() as u64)
    }

    /// Signal which indicates the nominal (desired) height of the front axle to be controlled by the suspension system.
    #[allow(dead_code)]
    pub fn nominal_level_front_axle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn nominal_level_front_axle(&self) -> NominalLevelFrontAxle2365479678 {
        NominalLevelFrontAxle2365479678::from(self.nominal_level_front_axle_raw_value() as u64)
    }

    /// Signal which indicates the position / load condition of lift axle / tag axle #2.
    #[allow(dead_code)]
    pub fn lift_axle2_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle2_pos(&self) -> LiftAxle2Pos2365479678 {
        LiftAxle2Pos2365479678::from(self.lift_axle2_pos_raw_value() as u64)
    }

    /// Signal which indicates the position / load condition of lift axle / tag axle #1.
    #[allow(dead_code)]
    pub fn lift_axle1_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn lift_axle1_pos(&self) -> LiftAxle1Pos2365479678 {
        LiftAxle1Pos2365479678::from(self.lift_axle1_pos_raw_value() as u64)
    }
}

/// Alternator Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct As {
    frame_payload: Vec<u8>,
}

impl As {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> As {
        frame_payload.resize(8, 0);
        As { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<As, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419354110);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| As::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Alternator 4 operating status.
    #[allow(dead_code)]
    pub fn alt4_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn alt4_status(&self) -> Alt4Status2566837758 {
        Alt4Status2566837758::from(self.alt4_status_raw_value() as u64)
    }

    /// Alternator 3 operating status.
    #[allow(dead_code)]
    pub fn alt3_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn alt3_status(&self) -> Alt3Status2566837758 {
        Alt3Status2566837758::from(self.alt3_status_raw_value() as u64)
    }

    /// Alternator 2 operating status.
    #[allow(dead_code)]
    pub fn alt2_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn alt2_status(&self) -> Alt2Status2566837758 {
        Alt2Status2566837758::from(self.alt2_status_raw_value() as u64)
    }

    /// Alternator 1 operating status.
    #[allow(dead_code)]
    pub fn alt1_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn alt1_status(&self) -> Alt1Status2566837758 {
        Alt1Status2566837758::from(self.alt1_status_raw_value() as u64)
    }

    /// Actual rotation speed of the alternator.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn alt_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Auxiliary Pressures
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ap {
    frame_payload: Vec<u8>,
}

impl Ap {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ap {
        frame_payload.resize(8, 0);
        Ap { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ap, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486438910);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ap::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the current absolute pressure (relative to 0 pressure) that is configured uniquely per application.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_abs_press_reading_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// Identifies the current gage pressure (relative to atmosphere) that is configured uniquely per application.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_gage_press_reading1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.500000).round() as u16
    }

    /// Identifies the current vacuum pressure (relative to atmosphere) that is configured uniquely per application.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_vacuum_press_reading_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Ambient Conditions 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Amb2 {
    frame_payload: Vec<u8>,
}

impl Amb2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Amb2 {
        frame_payload.resize(8, 0);
        Amb2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Amb2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419291390);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Amb2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This is the maximum value which can be reported by the sensor for the solar intensity.
    /// Unit: mW/cm�
    #[allow(dead_code)]
    pub fn solar_sensor_max_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// This is the solar radiation (power density) falling on the vehicle in percent of the maximum sensor value (SPN 2611).
    /// Unit: %
    #[allow(dead_code)]
    pub fn solar_intensity_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }
}

/// Working Set Member
#[allow(dead_code)]
#[derive(Debug)]
pub struct Wsmem {
    frame_payload: Vec<u8>,
}

impl Wsmem {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Wsmem {
        frame_payload.resize(8, 0);
        Wsmem { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Wsmem, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486411518);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Wsmem::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ArbitraryAddressCapable signal from can frame
    #[allow(dead_code)]
    pub fn arbitrary_address_capable_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 63) & 0x1) == 1)
    }

    /// 0 = Global; 
    ///    1  = On-Highway; 
    ///    2  = Agricultural and Forestry; 
    ///    3  = Construction; 
    ///    4  = Marine;
    ///    5  = Industrial - Process
    ///           Control - Stationary (Gen-Sets)
    ///    6  = Reserve for SAE
    ///    7  = Reserve for SAE
    #[allow(dead_code)]
    pub fn industry_group_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn industry_group(&self) -> IndustryGroup2633895166 {
        IndustryGroup2633895166::from(self.industry_group_raw_value() as u64)
    }

    /// Read VehicleSystemInstance signal from can frame
    #[allow(dead_code)]
    pub fn vehicle_system_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    /// Read VehicleSystem signal from can frame
    #[allow(dead_code)]
    pub fn vehicle_system_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x7F)) as u8
    }

    /// Read Function signal from can frame
    #[allow(dead_code)]
    pub fn function_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Read FunctionInstance signal from can frame
    #[allow(dead_code)]
    pub fn function_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1F)) as u8
    }

    /// Read ECUInstance signal from can frame
    #[allow(dead_code)]
    pub fn ecu_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7)) as u8
    }

    /// Assigned by NMEA 2000 Committee
    #[allow(dead_code)]
    pub fn manufacturer_code_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 21) & 0x7FF)) as u16
    }

    /// Read IdentityNumber signal from can frame
    #[allow(dead_code)]
    pub fn identity_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x1FFFFF)) as u32
    }
}

/// Test results for non-continously monitored systems.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm8 {
    frame_payload: Vec<u8>,
}

impl Dm8 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm8 {
        frame_payload.resize(8, 0);
        Dm8 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm8, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419352830);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm8::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The threshold which the test value must be above to pass the test.
    #[allow(dead_code)]
    pub fn test_limit_minimum_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The threshold which the test value must be below to pass the test.
    #[allow(dead_code)]
    pub fn test_limit_maximum_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The test value collected during the test.
    #[allow(dead_code)]
    pub fn test_value_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Identifies the non-continously monitored component identifier that was tested.
    #[allow(dead_code)]
    pub fn test_type_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Designates the test to be run.
    #[allow(dead_code)]
    pub fn test_identifier_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Command non-continously monitored test
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm7 {
    frame_payload: Vec<u8>,
}

impl Dm7 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm7 {
        frame_payload.resize(8, 0);
        Dm7 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm7, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417595134);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm7::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Designates the test to be run.
    #[allow(dead_code)]
    pub fn test_identifier_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Pending DTCs
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm6 {
    frame_payload: Vec<u8>,
}

impl Dm6 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm6 {
        frame_payload.resize(8, 0);
        Dm6 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm6, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419352574);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm6::new(frame.data().to_vec())));
        Ok(f)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52566836222 {
        FailureModeIdentifier52566836222::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42566836222 {
        FailureModeIdentifier42566836222::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2566836222 {
        FlashRedStopLamp2566836222::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2566836222 {
        FlashProtectLamp2566836222::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2566836222 {
        FlashMalfuncIndicatorLamp2566836222::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2566836222 {
        FlashAmberWarningLamp2566836222::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32566836222 {
        FailureModeIdentifier32566836222::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22566836222 {
        FailureModeIdentifier22566836222::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566836222 {
        FailureModeIdentifier12566836222::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2566836222 {
        MalfunctionIndicatorLampStatus2566836222::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2566836222 {
        RedStopLampState2566836222::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2566836222 {
        AmberWarningLampStatus2566836222::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2566836222 {
        ProtectLampStatus2566836222::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// Diagnostic readiness 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm5 {
    frame_payload: Vec<u8>,
}

impl Dm5 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm5 {
        frame_payload.resize(8, 0);
        Dm5 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm5, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419352318);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm5::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read MisfireMonitoringSupport signal from can frame
    #[allow(dead_code)]
    pub fn misfire_monitoring_support_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn misfire_monitoring_support(&self) -> MisfireMonitoringSupport2566835966 {
        MisfireMonitoringSupport2566835966::from(self.misfire_monitoring_support_raw_value() as u64)
    }

    /// Identifies the OBD compliance capabilityof the responding controller.
    #[allow(dead_code)]
    pub fn obd_compliance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn obd_compliance(&self) -> ObdCompliance2566835966 {
        ObdCompliance2566835966::from(self.obd_compliance_raw_value() as u64)
    }

    /// Identifies the number of previously active trouble codes that are present in a specific controller.
    #[allow(dead_code)]
    pub fn previously_active_trouble_codes_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Identifies the number of active trouble codes that are present in a specific controller.
    #[allow(dead_code)]
    pub fn active_trouble_codes_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Read SecondAirSystemMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn second_air_system_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 51) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn second_air_system_mon_status(&self) -> SecondAirSystemMonStatus2566835966 {
        SecondAirSystemMonStatus2566835966::from(self.second_air_system_mon_status_raw_value() as u64)
    }

    /// Read EvaporativeSystemMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn evaporative_system_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn evaporative_system_mon_status(&self) -> EvaporativeSystemMonStatus2566835966 {
        EvaporativeSystemMonStatus2566835966::from(self.evaporative_system_mon_status_raw_value() as u64)
    }

    /// Read ACSystemRefrigerantMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_status(&self) -> AcSystemRefrigerantMonStatus2566835966 {
        AcSystemRefrigerantMonStatus2566835966::from(self.ac_system_refrigerant_mon_status_raw_value() as u64)
    }

    /// Read OxygenSensorHeaterMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_status(&self) -> OxygenSensorHeaterMonStatus2566835966 {
        OxygenSensorHeaterMonStatus2566835966::from(self.oxygen_sensor_heater_mon_status_raw_value() as u64)
    }

    /// Read OxygenSensorMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_status(&self) -> OxygenSensorMonStatus2566835966 {
        OxygenSensorMonStatus2566835966::from(self.oxygen_sensor_mon_status_raw_value() as u64)
    }

    /// Read EGRSystemMonitoringStatus signal from can frame
    #[allow(dead_code)]
    pub fn egr_system_monitoring_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 55) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn egr_system_monitoring_status(&self) -> EgrSystemMonitoringStatus2566835966 {
        EgrSystemMonitoringStatus2566835966::from(self.egr_system_monitoring_status_raw_value() as u64)
    }

    /// Read CatalystMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn catalyst_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn catalyst_mon_status(&self) -> CatalystMonStatus2566835966 {
        CatalystMonStatus2566835966::from(self.catalyst_mon_status_raw_value() as u64)
    }

    /// Read ColdStartAidSystemMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_status(&self) -> ColdStartAidSystemMonStatus2566835966 {
        ColdStartAidSystemMonStatus2566835966::from(self.cold_start_aid_system_mon_status_raw_value() as u64)
    }

    /// Read HeatedCatalystMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn heated_catalyst_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn heated_catalyst_mon_status(&self) -> HeatedCatalystMonStatus2566835966 {
        HeatedCatalystMonStatus2566835966::from(self.heated_catalyst_mon_status_raw_value() as u64)
    }

    /// Read CatalystMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn catalyst_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn catalyst_mon_supp(&self) -> CatalystMonSupp2566835966 {
        CatalystMonSupp2566835966::from(self.catalyst_mon_supp_raw_value() as u64)
    }

    /// Read ColdStartAidSystemMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn cold_start_aid_system_mon_supp(&self) -> ColdStartAidSystemMonSupp2566835966 {
        ColdStartAidSystemMonSupp2566835966::from(self.cold_start_aid_system_mon_supp_raw_value() as u64)
    }

    /// Read HeatedCatalystMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn heated_catalyst_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 33) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn heated_catalyst_mon_supp(&self) -> HeatedCatalystMonSupp2566835966 {
        HeatedCatalystMonSupp2566835966::from(self.heated_catalyst_mon_supp_raw_value() as u64)
    }

    /// Read EvaporativeSystemMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn evaporative_system_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn evaporative_system_mon_supp(&self) -> EvaporativeSystemMonSupp2566835966 {
        EvaporativeSystemMonSupp2566835966::from(self.evaporative_system_mon_supp_raw_value() as u64)
    }

    /// Read SecondAirSystemMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn second_air_system_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn second_air_system_mon_supp(&self) -> SecondAirSystemMonSupp2566835966 {
        SecondAirSystemMonSupp2566835966::from(self.second_air_system_mon_supp_raw_value() as u64)
    }

    /// Read ACSystemRefrigerantMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn ac_system_refrigerant_mon_supp(&self) -> AcSystemRefrigerantMonSupp2566835966 {
        AcSystemRefrigerantMonSupp2566835966::from(self.ac_system_refrigerant_mon_supp_raw_value() as u64)
    }

    /// Read OxygenSensorMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_mon_supp(&self) -> OxygenSensorMonSupp2566835966 {
        OxygenSensorMonSupp2566835966::from(self.oxygen_sensor_mon_supp_raw_value() as u64)
    }

    /// Read OxygenSensorHeaterMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn oxygen_sensor_heater_mon_supp(&self) -> OxygenSensorHeaterMonSupp2566835966 {
        OxygenSensorHeaterMonSupp2566835966::from(self.oxygen_sensor_heater_mon_supp_raw_value() as u64)
    }

    /// Read EGRSystemMonitoringSupp signal from can frame
    #[allow(dead_code)]
    pub fn egr_system_monitoring_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 39) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn egr_system_monitoring_supp(&self) -> EgrSystemMonitoringSupp2566835966 {
        EgrSystemMonitoringSupp2566835966::from(self.egr_system_monitoring_supp_raw_value() as u64)
    }

    /// Read MisfireMonitoringStatus signal from can frame
    #[allow(dead_code)]
    pub fn misfire_monitoring_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn misfire_monitoring_status(&self) -> MisfireMonitoringStatus2566835966 {
        MisfireMonitoringStatus2566835966::from(self.misfire_monitoring_status_raw_value() as u64)
    }

    /// Read ComprehensiveCompMonStatus signal from can frame
    #[allow(dead_code)]
    pub fn comprehensive_comp_mon_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn comprehensive_comp_mon_status(&self) -> ComprehensiveCompMonStatus2566835966 {
        ComprehensiveCompMonStatus2566835966::from(self.comprehensive_comp_mon_status_raw_value() as u64)
    }

    /// Read FuelSystemMonitoringStatus signal from can frame
    #[allow(dead_code)]
    pub fn fuel_system_monitoring_status_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 29) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn fuel_system_monitoring_status(&self) -> FuelSystemMonitoringStatus2566835966 {
        FuelSystemMonitoringStatus2566835966::from(self.fuel_system_monitoring_status_raw_value() as u64)
    }

    /// Read ComprehensiveComponentMonSupp signal from can frame
    #[allow(dead_code)]
    pub fn comprehensive_component_mon_supp_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn comprehensive_component_mon_supp(&self) -> ComprehensiveComponentMonSupp2566835966 {
        ComprehensiveComponentMonSupp2566835966::from(self.comprehensive_component_mon_supp_raw_value() as u64)
    }

    /// Read FuelSystemMonitoringSupport signal from can frame
    #[allow(dead_code)]
    pub fn fuel_system_monitoring_support_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 25) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn fuel_system_monitoring_support(&self) -> FuelSystemMonitoringSupport2566835966 {
        FuelSystemMonitoringSupport2566835966::from(self.fuel_system_monitoring_support_raw_value() as u64)
    }
}

/// Freeze frame parameters
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm4 {
    frame_payload: Vec<u8>,
}

impl Dm4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm4 {
        frame_payload.resize(8, 0);
        Dm4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419352062);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 39) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566835710 {
        FailureModeIdentifier12566835710::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF)) as u16
    }

    /// The freeze frame length shall be equal to the number of bytes in the required parameters plus the number of bytes in the
    /// manufacturer specific parameters.
    /// Unit: byte
    #[allow(dead_code)]
    pub fn freeze_frame_length_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Actual engine speed which is calculated over a minimum crankshaft angle of 720 degrees divided by the number of cylinders.
    /// Unit: rpm
    #[allow(dead_code)]
    pub fn eng_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFFFF) as f64 * 0.125000).round() as u16
    }

    /// State signal which indicates which engine torque mode is currently generating, limiting, or controlling the torque.
    #[allow(dead_code)]
    pub fn eng_torque_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn eng_torque_mode(&self) -> EngTorqueMode2566835710 {
        EngTorqueMode2566835710::from(self.eng_torque_mode_raw_value() as u64)
    }

    /// Gage pressure of air measured downstream on the compressor discharge side of the turbocharger.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_turbo_boost_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Speed of the vehicle as calculated from wheel or tailshaft speed.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn wheel_based_vehicle_speed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 88) & 0xFFFF) as f64 * 0.003906).round() as u16
    }

    /// Read EngPercentLoadAtCurrentSpeed signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_percent_load_at_current_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0xFF)) as u8
    }

    /// Read EngineCoolantTemperature signal from can frame
    /// Unit: �C
    #[allow(dead_code)]
    pub fn engine_coolant_temperature_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFF)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 29) & 0x7)) as u8
    }
}

/// Diagnostic data clear/reset of previously active DTCs.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm3 {
    frame_payload: Vec<u8>,
}

impl Dm3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm3 {
        frame_payload.resize(8, 0);
        Dm3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419351806);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm3::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Expanded freeze frame.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm25 {
    frame_payload: Vec<u8>,
}

impl Dm25 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm25 {
        frame_payload.resize(8, 0);
        Dm25 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm25, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419280894);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm25::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 39) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566764542 {
        FailureModeIdentifier12566764542::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF)) as u16
    }

    /// The freeze frame length shall be equal to the number of bytes in the required parameters plus the number of bytes in the
    /// manufacturer specific parameters.
    /// Unit: byte
    #[allow(dead_code)]
    pub fn expanded_freeze_frame_length_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 29) & 0x7)) as u8
    }
}

/// SPN Support. This message is used to identify those SPNs supported by the product for freeze frames and data stream messages.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm24 {
    frame_payload: Vec<u8>,
}

impl Dm24 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm24 {
        frame_payload.resize(8, 0);
        Dm24 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm24, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419280638);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm24::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter defines the SPN(s) that is/are supported for the freeze frame and/or data stream information.
    #[allow(dead_code)]
    pub fn spn_supported1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 21) & 0x7)) as u8
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_str3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 82) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_str3(&self) -> SpnSupportTypeStr32566764286 {
        SpnSupportTypeStr32566764286::from(self.spn_support_type_str3_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_str2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 81) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_str2(&self) -> SpnSupportTypeStr22566764286 {
        SpnSupportTypeStr22566764286::from(self.spn_support_type_str2_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_eff3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_eff3(&self) -> SpnSupportTypeEff32566764286 {
        SpnSupportTypeEff32566764286::from(self.spn_support_type_eff3_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_eff2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_eff2(&self) -> SpnSupportTypeEff22566764286 {
        SpnSupportTypeEff22566764286::from(self.spn_support_type_eff2_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_ds3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_ds3(&self) -> SpnSupportTypeDs32566764286 {
        SpnSupportTypeDs32566764286::from(self.spn_support_type_ds3_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_ds2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_ds2(&self) -> SpnSupportTypeDs22566764286 {
        SpnSupportTypeDs22566764286::from(self.spn_support_type_ds2_raw_value() as u64)
    }

    /// This parameter defines the SPN(s) that is/are supported for the freeze frame and/or data stream information.
    #[allow(dead_code)]
    pub fn spn_supported3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 85) & 0x7)) as u8
    }

    /// This parameter defines the SPN(s) that is/are supported for the freeze frame and/or data stream information.
    #[allow(dead_code)]
    pub fn spn_supported2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x7)) as u8
    }

    /// This parameter defines the SPN(s) that is/are supported for the freeze frame and/or data stream information.
    #[allow(dead_code)]
    pub fn spn_supported3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFF)) as u16
    }

    /// This parameter defines the SPN(s) that is/are supported for the freeze frame and/or data stream information.
    #[allow(dead_code)]
    pub fn spn_supported2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The number of data bytes associated with the SPN in the Freeze Frame.
    #[allow(dead_code)]
    pub fn spn_data_length3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 88) & 0xFF)) as u8
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_str1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_str1(&self) -> SpnSupportTypeStr12566764286 {
        SpnSupportTypeStr12566764286::from(self.spn_support_type_str1_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_ds1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 17) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_ds1(&self) -> SpnSupportTypeDs12566764286 {
        SpnSupportTypeDs12566764286::from(self.spn_support_type_ds1_raw_value() as u64)
    }

    /// This parameter defines whether the applicable parameter (that is the SPN) is supported in the freeze frame, the data stream or both the freeze frame and data stream.
    #[allow(dead_code)]
    pub fn spn_support_type_eff1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn spn_support_type_eff1(&self) -> SpnSupportTypeEff12566764286 {
        SpnSupportTypeEff12566764286::from(self.spn_support_type_eff1_raw_value() as u64)
    }

    /// The number of data bytes associated with the SPN in the Freeze Frame.
    #[allow(dead_code)]
    pub fn spn_data_length2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF)) as u8
    }

    /// The number of data bytes associated with the SPN in the Freeze Frame.
    #[allow(dead_code)]
    pub fn spn_data_length1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// This parameter defines the SPN(s) that is/are supported for the freeze frame and/or data stream information.
    #[allow(dead_code)]
    pub fn spn_supported1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Previously active emission related faults.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm23 {
    frame_payload: Vec<u8>,
}

impl Dm23 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm23 {
        frame_payload.resize(8, 0);
        Dm23 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm23, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(408092414);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm23::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2555576062 {
        FlashRedStopLamp2555576062::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2555576062 {
        FlashProtectLamp2555576062::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2555576062 {
        FlashMalfuncIndicatorLamp2555576062::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2555576062 {
        FlashAmberWarningLamp2555576062::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52555576062 {
        FailureModeIdentifier52555576062::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42555576062 {
        FailureModeIdentifier42555576062::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12555576062 {
        FailureModeIdentifier12555576062::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2555576062 {
        MalfunctionIndicatorLampStatus2555576062::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2555576062 {
        RedStopLampState2555576062::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2555576062 {
        AmberWarningLampStatus2555576062::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2555576062 {
        ProtectLampStatus2555576062::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32555576062 {
        FailureModeIdentifier32555576062::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22555576062 {
        FailureModeIdentifier22555576062::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// Individual Clear/Reset of active and previously active DTC.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm22 {
    frame_payload: Vec<u8>,
}

impl Dm22 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm22 {
        frame_payload.resize(8, 0);
        Dm22 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm22, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(415497982);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm22::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read IndividualDTCClearControlByte signal from can frame
    #[allow(dead_code)]
    pub fn individual_dtc_clear_control_byte_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Read CtrlByteIndicIndividualDTCClear signal from can frame
    #[allow(dead_code)]
    pub fn ctrl_byte_indic_individual_dtc_clear_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFF)) as u16
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 61) & 0x7)) as u8
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12562981630 {
        FailureModeIdentifier12562981630::from(self.failure_mode_identifier1_raw_value() as u64)
    }
}

/// Diagnostic readiness 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm21 {
    frame_payload: Vec<u8>,
}

impl Dm21 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm21 {
        frame_payload.resize(8, 0);
        Dm21 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm21, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(415366910);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm21::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Time accumulated since DTCs were cleared (via an external test equipment or possibly, a battery disconnect) (SPN=?).
    /// Unit: min
    #[allow(dead_code)]
    pub fn time_since_dt_cs_cleared_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Accumulated count (in minutes) while the MIL is activated (on) (SPN=?).
    /// Unit: min
    #[allow(dead_code)]
    pub fn minutes_run_by_engine_mil_activated_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Distance accumulated since DTCs were cleared (SPN=?).
    /// Unit: km
    #[allow(dead_code)]
    pub fn distance_since_dt_cs_cleared_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// The kilometers accumulated while the MIL is activated (SPN 3060).
    /// Unit: km
    #[allow(dead_code)]
    pub fn distance_while_mi_lis_activated_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Monitor Performance Ratio
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm20 {
    frame_payload: Vec<u8>,
}

impl Dm20 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm20 {
        frame_payload.resize(8, 0);
        Dm20 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm20, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(415432446);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm20::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The number of times a vehicle has been operated that constitutes a driving cycle where this Applicable System Monitor could be operated per regulatory requirements (SPN 3068).
    #[allow(dead_code)]
    pub fn appl_sys_monitor_denominator_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0xFFFF)) as u16
    }

    /// The number of times a vehicle has been operated such that all conditions necessary for the Applicable System Monitor to detect a malfunction have been encountered (SPN 3067).
    #[allow(dead_code)]
    pub fn appl_sys_monitor_numerator_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFFFF)) as u16
    }

    /// Contain the SPN of the system monitor for which Monitor ratio is being reported (SPN 3066).
    #[allow(dead_code)]
    pub fn sp_nof_appl_sys_monitor_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFF)) as u32
    }

    /// Displays the number of times that the vehicle has been operated in the specified OBD monitoring conditions (SPN 3049).
    #[allow(dead_code)]
    pub fn obd_monitoring_cond_encountered_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// A single counter that defines the number of ignition cycles (SPN 3048).
    #[allow(dead_code)]
    pub fn ignition_cycle_counter_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Previously active diagnostic trouble codes
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm2 {
    frame_payload: Vec<u8>,
}

impl Dm2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm2 {
        frame_payload.resize(8, 0);
        Dm2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419351550);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52566835198 {
        FailureModeIdentifier52566835198::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42566835198 {
        FailureModeIdentifier42566835198::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566835198 {
        FailureModeIdentifier12566835198::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2566835198 {
        MalfunctionIndicatorLampStatus2566835198::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2566835198 {
        RedStopLampState2566835198::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2566835198 {
        AmberWarningLampStatus2566835198::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2566835198 {
        ProtectLampStatus2566835198::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32566835198 {
        FailureModeIdentifier32566835198::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2566835198 {
        FlashRedStopLamp2566835198::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2566835198 {
        FlashProtectLamp2566835198::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2566835198 {
        FlashMalfuncIndicatorLamp2566835198::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2566835198 {
        FlashAmberWarningLamp2566835198::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22566835198 {
        FailureModeIdentifier22566835198::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// Calibration Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm19 {
    frame_payload: Vec<u8>,
}

impl Dm19 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm19 {
        frame_payload.resize(8, 0);
        Dm19 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm19, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416546558);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm19::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read CalibrationID4 signal from can frame
    #[allow(dead_code)]
    pub fn calibration_id4_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF)) as u32
    }

    /// Read CalibrationID3 signal from can frame
    #[allow(dead_code)]
    pub fn calibration_id3_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF)) as u32
    }

    /// Read CalibrationID2 signal from can frame
    #[allow(dead_code)]
    pub fn calibration_id2_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF)) as u32
    }

    /// Read CalibrationID1 signal from can frame
    #[allow(dead_code)]
    pub fn calibration_id1_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Read CalibrationVerificationNumber signal from can frame
    #[allow(dead_code)]
    pub fn calibration_verification_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Boot Load Data
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm17 {
    frame_payload: Vec<u8>,
}

impl Dm17 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm17 {
        frame_payload.resize(8, 0);
        Dm17 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm17, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416743166);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm17::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Binary Data Transfer
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm16 {
    frame_payload: Vec<u8>,
}

impl Dm16 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm16 {
        frame_payload.resize(8, 0);
        Dm16 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm16, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416808702);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm16::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Number of occurance of raw binary data
    #[allow(dead_code)]
    pub fn number_of_occurance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Memory Access Response
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm15 {
    frame_payload: Vec<u8>,
}

impl Dm15 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm15 {
        frame_payload.resize(8, 0);
        Dm15 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm15, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416874238);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm15::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read NumberAllowed signal from can frame
    #[allow(dead_code)]
    pub fn number_allowed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Read Seed signal from can frame
    #[allow(dead_code)]
    pub fn seed_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    #[allow(dead_code)]
    pub fn seed(&self) -> Seed2564357886 {
        Seed2564357886::from(self.seed_raw_value() as u64)
    }

    /// Read EDCP_Extension signal from can frame
    #[allow(dead_code)]
    pub fn edcp_extension_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn edcp_extension(&self) -> EdcpExtension2564357886 {
        EdcpExtension2564357886::from(self.edcp_extension_raw_value() as u64)
    }

    /// Error Indicator/EDC Parameter
    #[allow(dead_code)]
    pub fn error_indicator_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFFFF)) as u32
    }

    #[allow(dead_code)]
    pub fn error_indicator(&self) -> ErrorIndicator2564357886 {
        ErrorIndicator2564357886::from(self.error_indicator_raw_value() as u64)
    }

    /// Read Status signal from can frame
    #[allow(dead_code)]
    pub fn status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 9) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn status(&self) -> Status2564357886 {
        Status2564357886::from(self.status_raw_value() as u64)
    }

    /// Read NumberAllowedHigh signal from can frame
    #[allow(dead_code)]
    pub fn number_allowed_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 13) & 0x7)) as u8
    }
}

/// Memory Access Request
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm14 {
    frame_payload: Vec<u8>,
}

impl Dm14 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm14 {
        frame_payload.resize(8, 0);
        Dm14 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm14, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(416939774);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm14::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Key/User Level
    #[allow(dead_code)]
    pub fn key_or_user_level_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    #[allow(dead_code)]
    pub fn key_or_user_level(&self) -> KeyOrUserLevel2564423422 {
        KeyOrUserLevel2564423422::from(self.key_or_user_level_raw_value() as u64)
    }

    /// Read PointerExtension signal from can frame
    #[allow(dead_code)]
    pub fn pointer_extension_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn pointer_extension(&self) -> PointerExtension2564423422 {
        PointerExtension2564423422::from(self.pointer_extension_raw_value() as u64)
    }

    /// Read Pointer signal from can frame
    #[allow(dead_code)]
    pub fn pointer_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFFFF)) as u32
    }

    /// Read Command signal from can frame
    #[allow(dead_code)]
    pub fn command_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 9) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn command(&self) -> Command2564423422 {
        Command2564423422::from(self.command_raw_value() as u64)
    }

    /// Read PointerType signal from can frame
    #[allow(dead_code)]
    pub fn pointer_type_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x1) == 1)
    }

    #[allow(dead_code)]
    pub fn pointer_type(&self) -> PointerType2564423422 {
        PointerType2564423422::from(self.pointer_type_raw_value() as u64)
    }

    /// Length/Number Requested
    #[allow(dead_code)]
    pub fn number_requested_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// Length/Number Requested
    #[allow(dead_code)]
    pub fn number_requested_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 13) & 0x7)) as u8
    }
}

/// Stop start broadcast
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm13 {
    frame_payload: Vec<u8>,
}

impl Dm13 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm13 {
        frame_payload.resize(8, 0);
        Dm13 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm13, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417332990);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm13::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicator to all nodes that the communication ports that have been acted upon by the 'Stop start broadcast'
    /// PGN are remaining in the modified state.
    #[allow(dead_code)]
    pub fn hold_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn hold_signal(&self) -> HoldSignal2564816638 {
        HoldSignal2564816638::from(self.hold_signal_raw_value() as u64)
    }

    /// Identifies the action to be performed on the SAE J1939 Network #3.
    #[allow(dead_code)]
    pub fn j1939_network3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn j1939_network3(&self) -> J1939Network32564816638 {
        J1939Network32564816638::from(self.j1939_network3_raw_value() as u64)
    }

    /// Identifies the action to be performed on the SAE J1939 Network #2.
    #[allow(dead_code)]
    pub fn j1939_network2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn j1939_network2(&self) -> J1939Network22564816638 {
        J1939Network22564816638::from(self.j1939_network2_raw_value() as u64)
    }

    /// Identifies the action to be performed on the ISO9141 communications port.
    #[allow(dead_code)]
    pub fn iso9141_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn iso9141(&self) -> Iso91412564816638 {
        Iso91412564816638::from(self.iso9141_raw_value() as u64)
    }

    /// Identifies the action to be performed on the SAE J1850 communications port.
    #[allow(dead_code)]
    pub fn sae_j1850_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sae_j1850(&self) -> SaeJ18502564816638 {
        SaeJ18502564816638::from(self.sae_j1850_raw_value() as u64)
    }

    /// Identifies the action to be performed on 'Other, manufacturer specific port' communications port.
    #[allow(dead_code)]
    pub fn manufacturer_specific_port_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn manufacturer_specific_port(&self) -> ManufacturerSpecificPort2564816638 {
        ManufacturerSpecificPort2564816638::from(self.manufacturer_specific_port_raw_value() as u64)
    }

    /// Identifies the action to be performed on the communications port that this parameter was received.
    #[allow(dead_code)]
    pub fn current_data_link_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn current_data_link(&self) -> CurrentDataLink2564816638 {
        CurrentDataLink2564816638::from(self.current_data_link_raw_value() as u64)
    }

    /// Identifies the action to be performed on the SAE J1587 communications port.
    #[allow(dead_code)]
    pub fn sae_j1587_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sae_j1587(&self) -> SaeJ15872564816638 {
        SaeJ15872564816638::from(self.sae_j1587_raw_value() as u64)
    }

    /// Identifies the action to be performed on the SAE J1922 communications port.
    #[allow(dead_code)]
    pub fn sae_j1922_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn sae_j1922(&self) -> SaeJ19222564816638 {
        SaeJ19222564816638::from(self.sae_j1922_raw_value() as u64)
    }

    /// Identifies the action to be performed on the SAE J1939 Network #1, Primary vehicle communications port.
    #[allow(dead_code)]
    pub fn j1939_network1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn j1939_network1(&self) -> J1939Network12564816638 {
        J1939Network12564816638::from(self.j1939_network1_raw_value() as u64)
    }

    /// Read SuspendSignal signal from can frame
    #[allow(dead_code)]
    pub fn suspend_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn suspend_signal(&self) -> SuspendSignal2564816638 {
        SuspendSignal2564816638::from(self.suspend_signal_raw_value() as u64)
    }

    /// Read SuspendDuration signal from can frame
    /// Unit: seconds
    #[allow(dead_code)]
    pub fn suspend_duration_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }
}

/// Emissions-related active diagnostic trouble codes.
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm12 {
    frame_payload: Vec<u8>,
}

impl Dm12 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm12 {
        frame_payload.resize(8, 0);
        Dm12 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm12, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419353854);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm12::new(frame.data().to_vec())));
        Ok(f)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2566837502 {
        FlashRedStopLamp2566837502::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2566837502 {
        FlashProtectLamp2566837502::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52566837502 {
        FailureModeIdentifier52566837502::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42566837502 {
        FailureModeIdentifier42566837502::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32566837502 {
        FailureModeIdentifier32566837502::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566837502 {
        FailureModeIdentifier12566837502::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2566837502 {
        MalfunctionIndicatorLampStatus2566837502::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2566837502 {
        RedStopLampState2566837502::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2566837502 {
        AmberWarningLampStatus2566837502::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2566837502 {
        ProtectLampStatus2566837502::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2566837502 {
        FlashMalfuncIndicatorLamp2566837502::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2566837502 {
        FlashAmberWarningLamp2566837502::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22566837502 {
        FailureModeIdentifier22566837502::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// Diagnostic data clear/Reset for active DTCs
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm11 {
    frame_payload: Vec<u8>,
}

impl Dm11 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm11 {
        frame_payload.resize(8, 0);
        Dm11 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm11, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419353598);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm11::new(frame.data().to_vec())));
        Ok(f)
    }
}

/// Non-continously monitored systems test identifiers support
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm10 {
    frame_payload: Vec<u8>,
}

impl Dm10 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm10 {
        frame_payload.resize(8, 0);
        Dm10 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm10, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419353342);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm10::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates the test identifiers that the controller supports.
    #[allow(dead_code)]
    pub fn test_identifier_supported_raw_value(&self) -> u64 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFFFFFFFFFE)) as u64
    }
}

/// Active diagnostic trouble codes
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm1 {
    frame_payload: Vec<u8>,
}

impl Dm1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm1 {
        frame_payload.resize(8, 0);
        Dm1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419351294);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52566834942 {
        FailureModeIdentifier52566834942::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42566834942 {
        FailureModeIdentifier42566834942::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32566834942 {
        FailureModeIdentifier32566834942::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2566834942 {
        FlashRedStopLamp2566834942::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2566834942 {
        FlashProtectLamp2566834942::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2566834942 {
        FlashMalfuncIndicatorLamp2566834942::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2566834942 {
        FlashAmberWarningLamp2566834942::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2566834942 {
        MalfunctionIndicatorLampStatus2566834942::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2566834942 {
        AmberWarningLampStatus2566834942::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566834942 {
        FailureModeIdentifier12566834942::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2566834942 {
        RedStopLampState2566834942::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2566834942 {
        ProtectLampStatus2566834942::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22566834942 {
        FailureModeIdentifier22566834942::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// Utility Total AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Utacr {
    frame_payload: Vec<u8>,
}

impl Utacr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Utacr {
        frame_payload.resize(8, 0);
        Utacr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Utacr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419297278);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Utacr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for utility incomer average power factor.
    #[allow(dead_code)]
    pub fn utlity_overall_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The average power factor of the utility incomer.
    #[allow(dead_code)]
    pub fn utility_overall_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The total reactive power delivered by the utility incomer
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_total_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Total AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Utacp {
    frame_payload: Vec<u8>,
}

impl Utacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Utacp {
        frame_payload.resize(8, 0);
        Utacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Utacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419297534);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Utacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The total apparent power delivered by the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_total_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Total real power delivered by the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_total_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Total AC Energy
#[allow(dead_code)]
#[derive(Debug)]
pub struct Utace {
    frame_payload: Vec<u8>,
}

impl Utace {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Utace {
        frame_payload.resize(8, 0);
        Utace { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Utace, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419294718);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Utace::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The total kilowatt-hours that have been imported by the utility incomer.
    /// Unit: kWh
    #[allow(dead_code)]
    pub fn utility_total_kw_hours_import_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The total kilowatt-hours that have been exported by the utility incomer.
    /// Unit: kWh
    #[allow(dead_code)]
    pub fn utility_total_kw_hours_export_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase C AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upcacr {
    frame_payload: Vec<u8>,
}

impl Upcacr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upcacr {
        frame_payload.resize(8, 0);
        Upcacr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upcacr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419294974);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upcacr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for utility incomer phase C power factor.
    #[allow(dead_code)]
    pub fn utility_phase_c_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The power factor of phases C of the utility incomer.
    #[allow(dead_code)]
    pub fn utility_phase_c_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The reactive power delivered by phase C of the utility incomer
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_c_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase C AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upcacp {
    frame_payload: Vec<u8>,
}

impl Upcacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upcacp {
        frame_payload.resize(8, 0);
        Upcacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upcacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419295230);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upcacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The apparent power delivered by phase C of the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_c_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The real power delivered by phase C of the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_c_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase C AC Basic Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upcac {
    frame_payload: Vec<u8>,
}

impl Upcac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upcac {
        frame_payload.resize(8, 0);
        Upcac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upcac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419295486);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upcac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// RMS current measured at the utility incomer phase C.
    /// Unit: A
    #[allow(dead_code)]
    pub fn utility_phase_cacrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// AC frequency measured at the utility incomer phase C.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn utility_phase_cac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at the utility incomer phase C.
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_phs_c_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at the utility incomer phase CA.
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_phse_ca_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Utility Phase B AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upbacr {
    frame_payload: Vec<u8>,
}

impl Upbacr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upbacr {
        frame_payload.resize(8, 0);
        Upbacr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upbacr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419295742);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upbacr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for utility incomer phase B power factor.
    #[allow(dead_code)]
    pub fn utility_phase_b_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The power factor of phases B of the utility incomer.
    #[allow(dead_code)]
    pub fn utility_phase_b_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The reactive power delivered by phase B of the utility incomer
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_b_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase B AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upbacp {
    frame_payload: Vec<u8>,
}

impl Upbacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upbacp {
        frame_payload.resize(8, 0);
        Upbacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upbacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419295998);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upbacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The apparent power delivered by phase B of the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_b_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The real power delivered by phase B of the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_b_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase B AC Basic Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upbac {
    frame_payload: Vec<u8>,
}

impl Upbac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upbac {
        frame_payload.resize(8, 0);
        Upbac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upbac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419296254);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upbac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// RMS current measured at the utility incomer phase B.
    /// Unit: A
    #[allow(dead_code)]
    pub fn utility_phase_bacrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// AC frequency measured at the utility incomer phase B.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn utility_phase_bac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at the utility incomer phase B.
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_phs_b_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at the utility incomer phase BC.
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_phse_bc_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Utility Phase A  AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upaccr {
    frame_payload: Vec<u8>,
}

impl Upaccr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upaccr {
        frame_payload.resize(8, 0);
        Upaccr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upaccr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419296510);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upaccr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for utility incomer phase A power factor.
    #[allow(dead_code)]
    pub fn utility_phase_a_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The power factor of phase A of the utility incomer.
    #[allow(dead_code)]
    pub fn utility_phase_a_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The reactive power delivered by phase A of the utility incomer
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_a_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase A  AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upaacp {
    frame_payload: Vec<u8>,
}

impl Upaacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upaacp {
        frame_payload.resize(8, 0);
        Upaacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upaacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419296766);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upaacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The apparent power delivered by phase A of the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_a_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The real power delivered by phase A of the utility incomer.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn utility_phase_a_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Utility Phase A Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Upaac {
    frame_payload: Vec<u8>,
}

impl Upaac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Upaac {
        frame_payload.resize(8, 0);
        Upaac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Upaac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419297022);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Upaac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// RMS current measured at the utility incomer phase A.
    /// Unit: A
    #[allow(dead_code)]
    pub fn utility_phase_aacrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// AC frequency measured at the utility incomer phase A.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn utility_phase_aac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at the utility incomer phase A.
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_phs_a_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at the utility incomer phase AB.
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_phse_ab_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Utility Average Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Uaac {
    frame_payload: Vec<u8>,
}

impl Uaac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Uaac {
        frame_payload.resize(8, 0);
        Uaac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Uaac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419297790);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Uaac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Average RMS current measured at the utility incomer.
    /// Unit: A
    #[allow(dead_code)]
    pub fn utility_average_acrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Average AC frequency measured at the utility incomer.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn utility_average_ac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The average Line to Neutral AC RMS voltage measured at the utility incomer .
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_avrg_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Average Line to Line RMS voltage measured at the utility incomer .
    /// Unit: V
    #[allow(dead_code)]
    pub fn utlty_avrage_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Generator Total AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gtacr {
    frame_payload: Vec<u8>,
}

impl Gtacr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gtacr {
        frame_payload.resize(8, 0);
        Gtacr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gtacr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419300606);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gtacr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for generator average power factor.
    #[allow(dead_code)]
    pub fn gnrtor_overall_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The average power factor of the generator.
    #[allow(dead_code)]
    pub fn generator_overall_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The total reactive power delivered by the generator
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_total_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Total AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gtacp {
    frame_payload: Vec<u8>,
}

impl Gtacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gtacp {
        frame_payload.resize(8, 0);
        Gtacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gtacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419300862);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gtacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The total apparent power delivered by the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_total_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Total real power delivered by the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_total_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Total AC Energy
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gtace {
    frame_payload: Vec<u8>,
}

impl Gtace {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gtace {
        frame_payload.resize(8, 0);
        Gtace { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gtace, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419298046);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gtace::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The total kilowatt-hours that have been imported by the generator.
    /// Unit: kWh
    #[allow(dead_code)]
    pub fn generator_total_kw_hours_import_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The total kilowatt-hours that have been exported by the generator.
    /// Unit: kWh
    #[allow(dead_code)]
    pub fn generator_total_kw_hours_export_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase C AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpcacr {
    frame_payload: Vec<u8>,
}

impl Gpcacr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpcacr {
        frame_payload.resize(8, 0);
        Gpcacr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpcacr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419298302);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpcacr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for generator phase C power factor.
    #[allow(dead_code)]
    pub fn gnrator_phase_c_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The power factor of phases C of the generator.
    #[allow(dead_code)]
    pub fn generator_phase_c_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The reactive power delivered by phase C of the generator
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_c_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase C AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpcacp {
    frame_payload: Vec<u8>,
}

impl Gpcacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpcacp {
        frame_payload.resize(8, 0);
        Gpcacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpcacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419298558);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpcacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The apparent power delivered by phase C of the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_c_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The real power delivered by phase C of the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_c_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase C Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpcac {
    frame_payload: Vec<u8>,
}

impl Gpcac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpcac {
        frame_payload.resize(8, 0);
        Gpcac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpcac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419298814);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpcac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// RMS current measured at the generator phase C output.
    /// Unit: A
    #[allow(dead_code)]
    pub fn generator_phase_cacrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// AC frequency measured at the generator phase C output.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn generator_phase_cac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at the generator phase C output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_phs_c_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at the generator phase CA output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_phse_ca_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Generator Phase B AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpbacrp {
    frame_payload: Vec<u8>,
}

impl Gpbacrp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpbacrp {
        frame_payload.resize(8, 0);
        Gpbacrp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpbacrp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419299070);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpbacrp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for generator phase B power factor.
    #[allow(dead_code)]
    pub fn gnrator_phase_b_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The power factor of phases B of the generator.
    #[allow(dead_code)]
    pub fn generator_phase_b_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The reactive power delivered by phase B of the generator
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_b_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase B AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpbacp {
    frame_payload: Vec<u8>,
}

impl Gpbacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpbacp {
        frame_payload.resize(8, 0);
        Gpbacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpbacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419299326);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpbacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The apparent power delivered by phase B of the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_b_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The real power delivered by phase B of the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_b_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase B Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpbac {
    frame_payload: Vec<u8>,
}

impl Gpbac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpbac {
        frame_payload.resize(8, 0);
        Gpbac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpbac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419299582);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpbac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// RMS current measured at the generator phase B output.
    /// Unit: A
    #[allow(dead_code)]
    pub fn generator_phase_bacrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// AC frequency measured at the generator phase B output.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn generator_phase_bac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at the generator phase B output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_phs_b_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at the generator phase BC output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_phse_bc_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Generator Phase A AC Reactive Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpaacr {
    frame_payload: Vec<u8>,
}

impl Gpaacr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpaacr {
        frame_payload.resize(8, 0);
        Gpaacr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpaacr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419299838);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpaacr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Lead/lag status for generator phase A power factor.
    #[allow(dead_code)]
    pub fn gnrator_phase_a_power_factor_lagging_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    /// The power factor of phase A of the generator.
    #[allow(dead_code)]
    pub fn generator_phase_a_power_factor_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The reactive power delivered by phase A of the generator
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_a_reactive_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase A AC Power
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpaacp {
    frame_payload: Vec<u8>,
}

impl Gpaacp {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpaacp {
        frame_payload.resize(8, 0);
        Gpaacp { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpaacp, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419300094);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpaacp::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The apparent power delivered by phase A of the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_a_apparent_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// The real power delivered by phase A of the generator.
    /// Unit: VA
    #[allow(dead_code)]
    pub fn generator_phase_a_real_power_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF)) as u32
    }
}

/// Generator Phase A Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gpaac {
    frame_payload: Vec<u8>,
}

impl Gpaac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gpaac {
        frame_payload.resize(8, 0);
        Gpaac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gpaac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419300350);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gpaac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// RMS current measured at the generator phase A output.
    /// Unit: A
    #[allow(dead_code)]
    pub fn generator_phase_aacrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// AC frequency measured at the generator phase A output.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn generator_phase_aac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at the generator phase A output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_phs_a_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at the generator phase AB output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_phse_ab_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Generator Average Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Gaac {
    frame_payload: Vec<u8>,
}

impl Gaac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Gaac {
        frame_payload.resize(8, 0);
        Gaac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Gaac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419301118);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Gaac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Average RMS current measured at the generator output.
    /// Unit: A
    #[allow(dead_code)]
    pub fn generator_average_acrms_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Average AC frequency measured at the generator output.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn generator_average_ac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The average Line to Neutral AC RMS voltage measured at the Generator output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_avrg_lne_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Average Line to Line RMS voltage measured at the generator output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn gnrtr_avrage_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Bus #1/Utility Sync Check Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Busc {
    frame_payload: Vec<u8>,
}

impl Busc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Busc {
        frame_payload.resize(8, 0);
        Busc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Busc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419293182);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Busc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The phase difference between the Bus #1 voltage and Utility voltage.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn bus1_utility_ac_phase_difference_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Indicator of whether Bus #1 and Utility are properly synchronized for paralleling. This indicator will be based on parameters such as Voltage Match, Frequency Match, and Phase Match.
    #[allow(dead_code)]
    pub fn bus1_utility_in_sync_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    /// Indicator of whether voltage difference between Bus #1 and Utility is adequate for paralleling. This indicator will be based on the measured AC voltages qualified using parameters such as Voltage Tolerance.
    #[allow(dead_code)]
    pub fn bus1_utility_voltage_match_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    /// Indicator of whether frequency difference between Bus #1 and Utility is adequate for paralleling. This indicator will be based on the measured AC frequencies qualified using parameters such as Frequency Tolerance, Phase Tolerance, and Dwell Time.
    #[allow(dead_code)]
    pub fn bus1_utility_frequency_match_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    /// Indicator of whether phase difference between Bus #1 and Utility is adequate for paralleling. This indicator will be based on the measured AC phase difference qualified using parameters such as Phase Tolerance and Dwell Time.
    #[allow(dead_code)]
    pub fn bus1_utility_phase_match_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    /// Indicator of whether Bus #1 is considered dead for closing to the utility. This indicator will be based on parameters such as Bus #1 Voltage and dead bus threshold values.
    #[allow(dead_code)]
    pub fn bus1_utility_dead_bus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }
}

/// Bus #1 Phase C  Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bpcac {
    frame_payload: Vec<u8>,
}

impl Bpcac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bpcac {
        frame_payload.resize(8, 0);
        Bpcac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bpcac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419293694);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bpcac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// AC frequency measured at bus #1 phase C.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn bus1_phase_cac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at bus #1 phase C.
    /// Unit: V
    #[allow(dead_code)]
    pub fn bs1_phse_c_line_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at bus #1 phase CA.
    /// Unit: V
    #[allow(dead_code)]
    pub fn bus1_phase_ca_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Bus #1 Phase B  Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bpbac {
    frame_payload: Vec<u8>,
}

impl Bpbac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bpbac {
        frame_payload.resize(8, 0);
        Bpbac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bpbac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419293950);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bpbac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// AC frequency measured at bus #1 phase B.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn bus1_phase_bac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at bus #1 phase B.
    /// Unit: V
    #[allow(dead_code)]
    pub fn bs1_phse_b_line_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at bus #1 phase BC.
    /// Unit: V
    #[allow(dead_code)]
    pub fn bus1_phase_bc_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Bus #1 Phase A  Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bpaac {
    frame_payload: Vec<u8>,
}

impl Bpaac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bpaac {
        frame_payload.resize(8, 0);
        Bpaac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bpaac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419294206);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bpaac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// AC frequency measured at bus #1 phase A.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn bus1_phase_aac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// Line to Neutral RMS voltage measured at bus #1 phase A.
    /// Unit: V
    #[allow(dead_code)]
    pub fn bs1_phse_a_line_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Line to Line RMS voltage measured at bus #1 phase AB.
    /// Unit: V
    #[allow(dead_code)]
    pub fn bus1_phase_ab_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Bus #1/Generator Sync Check Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bgsc {
    frame_payload: Vec<u8>,
}

impl Bgsc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bgsc {
        frame_payload.resize(8, 0);
        Bgsc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bgsc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419293438);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bgsc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The phase difference between the Bus #1 voltage and Generator voltage.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn bus1_generator_ac_phase_difference_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Indicator of whether Bus #1 and Generator are properly synchronized for paralleling. This indicator will be based on parameters such as Voltage Match, Frequency Match, and Phase Match.
    #[allow(dead_code)]
    pub fn bus1_generator_in_sync_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    /// Indicator of whether voltage difference between Bus #1 and Generator is adequate for paralleling. This indicator will be based on the measured AC voltages qualified using parameters such as Voltage Tolerance.
    #[allow(dead_code)]
    pub fn bus1_generator_voltage_match_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    /// Indicator of whether frequency difference between Bus #1 and Generator is adequate for paralleling. This indicator will be based on the measured AC frequencies qualified using parameters such as Frequency Tolerance, Phase Tolerance, and Dwell Time.
    #[allow(dead_code)]
    pub fn bus1_generator_frequency_match_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    /// Indicator of whether phase difference between Bus #1 and Generator is adequate for paralleling. This indicator will be based on the measured AC phase difference qualified using parameters such as Phase Tolerance and Dwell Time.
    #[allow(dead_code)]
    pub fn bus1_generator_phase_match_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    /// Indicator of whether Bus #1 is considered dead for closing to the generator. This indicator will be based on parameters such as Bus #1 Voltage and dead bus threshold values.
    #[allow(dead_code)]
    pub fn bus1_generator_dead_bus_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }
}

/// Bus #1 Average Basic AC Quantities
#[allow(dead_code)]
#[derive(Debug)]
pub struct Baac {
    frame_payload: Vec<u8>,
}

impl Baac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Baac {
        frame_payload.resize(8, 0);
        Baac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Baac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419294462);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Baac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Average AC frequency measured at bus #1.
    /// Unit: Hz
    #[allow(dead_code)]
    pub fn bus1_average_ac_frequency_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }

    /// The average Line to Neutral AC RMS voltage measured at bus #1 .
    /// Unit: V
    #[allow(dead_code)]
    pub fn bs1_avrge_line_neutral_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// Average Line to Line RMS voltage measured at bus #1 .
    /// Unit: V
    #[allow(dead_code)]
    pub fn bus1_average_line_line_acrms_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF)) as u16
    }
}

/// Working Set Master
#[allow(dead_code)]
#[derive(Debug)]
pub struct Wsmstr {
    frame_payload: Vec<u8>,
}

impl Wsmstr {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Wsmstr {
        frame_payload.resize(8, 0);
        Wsmstr { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Wsmstr, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486411774);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Wsmstr::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read NumberOfMembers signal from can frame
    #[allow(dead_code)]
    pub fn number_of_members_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Commanded Address
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ca {
    frame_payload: Vec<u8>,
}

impl Ca {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ca {
        frame_payload.resize(8, 0);
        Ca { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ca, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419354878);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ca::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ArbitraryAddressCapable signal from can frame
    #[allow(dead_code)]
    pub fn arbitrary_address_capable_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 63) & 0x1) == 1)
    }

    /// 0 = Global; 
    ///    1  = On-Highway; 
    ///    2  = Agricultural and Forestry; 
    ///    3  = Construction; 
    ///    4  = Marine;
    ///    5  = Industrial - Process
    ///           Control - Stationary (Gen-Sets)
    ///    6  = Reserve for SAE
    ///    7  = Reserve for SAE
    #[allow(dead_code)]
    pub fn industry_group_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn industry_group(&self) -> IndustryGroup2566838526 {
        IndustryGroup2566838526::from(self.industry_group_raw_value() as u64)
    }

    /// Read VehicleSystemInstance signal from can frame
    #[allow(dead_code)]
    pub fn vehicle_system_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    /// Read VehicleSystem signal from can frame
    #[allow(dead_code)]
    pub fn vehicle_system_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x7F)) as u8
    }

    /// Read Function signal from can frame
    #[allow(dead_code)]
    pub fn function_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Read FunctionInstance signal from can frame
    #[allow(dead_code)]
    pub fn function_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1F)) as u8
    }

    /// Read ECUInstance signal from can frame
    #[allow(dead_code)]
    pub fn ecu_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7)) as u8
    }

    /// Assigned by NMEA 2000 Committee
    #[allow(dead_code)]
    pub fn manufacturer_code_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 21) & 0x7FF)) as u16
    }

    /// Read IdentityNumber signal from can frame
    #[allow(dead_code)]
    pub fn identity_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x1FFFFF)) as u32
    }

    /// The source address that is to be assigned to the CA that has the NAME corresponding to the one conveyed in the first eight bytes of this Commanded Address message.
    #[allow(dead_code)]
    pub fn address_assignment_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFF)) as u8
    }
}

/// Address Claimed
#[allow(dead_code)]
#[derive(Debug)]
pub struct Acl {
    frame_payload: Vec<u8>,
}

impl Acl {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Acl {
        frame_payload.resize(8, 0);
        Acl { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Acl, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418316030);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Acl::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ArbitraryAddressCapable signal from can frame
    #[allow(dead_code)]
    pub fn arbitrary_address_capable_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 63) & 0x1) == 1)
    }

    /// 0 = Global; 
    ///    1  = On-Highway; 
    ///    2  = Agricultural and Forestry; 
    ///    3  = Construction; 
    ///    4  = Marine;
    ///    5  = Industrial - Process
    ///           Control - Stationary (Gen-Sets)
    ///    6  = Reserve for SAE
    ///    7  = Reserve for SAE
    #[allow(dead_code)]
    pub fn industry_group_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn industry_group(&self) -> IndustryGroup2565799678 {
        IndustryGroup2565799678::from(self.industry_group_raw_value() as u64)
    }

    /// Read VehicleSystemInstance signal from can frame
    #[allow(dead_code)]
    pub fn vehicle_system_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    /// Read VehicleSystem signal from can frame
    #[allow(dead_code)]
    pub fn vehicle_system_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 49) & 0x7F)) as u8
    }

    /// Read Function signal from can frame
    #[allow(dead_code)]
    pub fn function_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Read FunctionInstance signal from can frame
    #[allow(dead_code)]
    pub fn function_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 35) & 0x1F)) as u8
    }

    /// Read ECUInstance signal from can frame
    #[allow(dead_code)]
    pub fn ecu_instance_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x7)) as u8
    }

    /// Assigned by NMEA 2000 Committee
    #[allow(dead_code)]
    pub fn manufacturer_code_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 21) & 0x7FF)) as u16
    }

    /// Read IdentityNumber signal from can frame
    #[allow(dead_code)]
    pub fn identity_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x1FFFFF)) as u32
    }
}

/// Transfer
#[allow(dead_code)]
#[derive(Debug)]
pub struct Xfer {
    frame_payload: Vec<u8>,
}

impl Xfer {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Xfer {
        frame_payload.resize(8, 0);
        Xfer { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Xfer, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(415956734);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Xfer::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Short name of reporting device of the requested PGN via the Transfer PGN.
    /// Unit: (2^32 - 1)
    #[allow(dead_code)]
    pub fn shrt_name_of_actual_reporting_device_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Length of data reported with the associated PGN via the Transfer PGN.
    #[allow(dead_code)]
    pub fn length_of_data_for_the_reported_pgn_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// PGN associated with this transfer message
    #[allow(dead_code)]
    pub fn pg_nof_requsted_information_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFF)) as u32
    }
}

/// Transport Protocol - Data Transfer
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tpdt {
    frame_payload: Vec<u8>,
}

impl Tpdt {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tpdt {
        frame_payload.resize(8, 0);
        Tpdt { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tpdt, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418119422);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tpdt::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read SequenceNumber signal from can frame
    #[allow(dead_code)]
    pub fn sequence_number_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Transport Protocol - Connection Management
#[allow(dead_code)]
#[derive(Debug)]
pub struct Tpcm {
    frame_payload: Vec<u8>,
}

impl Tpcm {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Tpcm {
        frame_payload.resize(8, 0);
        Tpcm { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Tpcm, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418184958);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Tpcm::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read PGNumber signal from can frame
    #[allow(dead_code)]
    pub fn pg_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFFFF)) as u32
    }

    #[allow(dead_code)]
    pub fn pg_number(&self) -> PgNumber2565668606 {
        PgNumber2565668606::from(self.pg_number_raw_value() as u64)
    }
}

/// Request 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rqst2 {
    frame_payload: Vec<u8>,
}

impl Rqst2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rqst2 {
        frame_payload.resize(8, 0);
        Rqst2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rqst2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(415891198);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rqst2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Requester is to respond via the Transfer PGN
    #[allow(dead_code)]
    pub fn use_transfer_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn use_transfer_mode(&self) -> UseTransferMode2563374846 {
        UseTransferMode2563374846::from(self.use_transfer_mode_raw_value() as u64)
    }

    /// PGN which is requested by Request2 message
    #[allow(dead_code)]
    pub fn parameter_group_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFF)) as u32
    }
}

/// Request
#[allow(dead_code)]
#[derive(Debug)]
pub struct Rqst {
    frame_payload: Vec<u8>,
}

impl Rqst {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Rqst {
        frame_payload.resize(8, 0);
        Rqst { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Rqst, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418053886);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Rqst::new(frame.data().to_vec())));
        Ok(f)
    }

    /// PGN which is requested by Request2 message
    #[allow(dead_code)]
    pub fn parameter_group_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFF)) as u32
    }
}

/// DTC Counts
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm29 {
    frame_payload: Vec<u8>,
}

impl Dm29 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm29 {
        frame_payload.resize(8, 0);
        Dm29 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm29, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(413073150);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm29::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the current number of permanent DTCs
    #[allow(dead_code)]
    pub fn permanent_dt_cs_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// Identifies the current number of previously MIL-On DTCs
    #[allow(dead_code)]
    pub fn previously_mil_on_dt_cs_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Identifies the current number of MIL-On DTCs
    #[allow(dead_code)]
    pub fn mil_on_dt_cs_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Identifies the current total number of pending DTCs, including emission related
    #[allow(dead_code)]
    pub fn all_pending_dt_cs_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Identifies the current number of emission related pending DTCs
    #[allow(dead_code)]
    pub fn pending_dt_cs_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Permanent DTCs
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm28 {
    frame_payload: Vec<u8>,
}

impl Dm28 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm28 {
        frame_payload.resize(8, 0);
        Dm28 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm28, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419266814);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm28::new(frame.data().to_vec())));
        Ok(f)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52566750462 {
        FailureModeIdentifier52566750462::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42566750462 {
        FailureModeIdentifier42566750462::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32566750462 {
        FailureModeIdentifier32566750462::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2566750462 {
        FlashRedStopLamp2566750462::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2566750462 {
        FlashProtectLamp2566750462::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2566750462 {
        FlashMalfuncIndicatorLamp2566750462::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2566750462 {
        FlashAmberWarningLamp2566750462::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2566750462 {
        MalfunctionIndicatorLampStatus2566750462::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2566750462 {
        AmberWarningLampStatus2566750462::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566750462 {
        FailureModeIdentifier12566750462::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2566750462 {
        RedStopLampState2566750462::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2566750462 {
        ProtectLampStatus2566750462::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22566750462 {
        FailureModeIdentifier22566750462::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// All Pending DTCs
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dm27 {
    frame_payload: Vec<u8>,
}

impl Dm27 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dm27 {
        frame_payload.resize(8, 0);
        Dm27 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dm27, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419267326);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dm27::new(frame.data().to_vec())));
        Ok(f)
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 144) & 0xFFFF)) as u16
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 112) & 0xFFFF)) as u16
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 80) & 0xFFFF)) as u16
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier5(&self) -> FailureModeIdentifier52566750974 {
        FailureModeIdentifier52566750974::from(self.failure_mode_identifier5_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier4(&self) -> FailureModeIdentifier42566750974 {
        FailureModeIdentifier42566750974::from(self.failure_mode_identifier4_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier3(&self) -> FailureModeIdentifier32566750974 {
        FailureModeIdentifier32566750974::from(self.failure_mode_identifier3_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the RSL (SPN 3039).
    #[allow(dead_code)]
    pub fn flash_red_stop_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_red_stop_lamp(&self) -> FlashRedStopLamp2566750974 {
        FlashRedStopLamp2566750974::from(self.flash_red_stop_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the engine protect lamp (SPN 3041).
    #[allow(dead_code)]
    pub fn flash_protect_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_protect_lamp(&self) -> FlashProtectLamp2566750974 {
        FlashProtectLamp2566750974::from(self.flash_protect_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the MIL (SPN 3038).
    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_malfunc_indicator_lamp(&self) -> FlashMalfuncIndicatorLamp2566750974 {
        FlashMalfuncIndicatorLamp2566750974::from(self.flash_malfunc_indicator_lamp_raw_value() as u64)
    }

    /// This parameter provides the capability to flash the AWL (SPN 3040). 
    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn flash_amber_warning_lamp(&self) -> FlashAmberWarningLamp2566750974 {
        FlashAmberWarningLamp2566750974::from(self.flash_amber_warning_lamp_raw_value() as u64)
    }

    /// A lamp used to relay only emissions-related trouble code information.
    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn malfunction_indicator_lamp_status(&self) -> MalfunctionIndicatorLampStatus2566750974 {
        MalfunctionIndicatorLampStatus2566750974::from(self.malfunction_indicator_lamp_status_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code information that is reporting a problem with the vehicle system but the vehicle need
    /// not be immediately stopped.
    #[allow(dead_code)]
    pub fn amber_warning_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn amber_warning_lamp_status(&self) -> AmberWarningLampStatus2566750974 {
        AmberWarningLampStatus2566750974::from(self.amber_warning_lamp_status_raw_value() as u64)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x7F)) as u8
    }

    /// Read SPNConversionMethod1 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method1_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 47) & 0x1) == 1)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier1(&self) -> FailureModeIdentifier12566750974 {
        FailureModeIdentifier12566750974::from(self.failure_mode_identifier1_raw_value() as u64)
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF)) as u16
    }

    /// This lamp is uesed to relay trouble code information that is of a severe enought condition that it warrants stopping the vehicle.
    #[allow(dead_code)]
    pub fn red_stop_lamp_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn red_stop_lamp_state(&self) -> RedStopLampState2566750974 {
        RedStopLampState2566750974::from(self.red_stop_lamp_state_raw_value() as u64)
    }

    /// This lamp is used to relay trouble code informatio that is reporting a problem with a vehicle system that is most
    /// probably not electronic subsystem related.
    #[allow(dead_code)]
    pub fn protect_lamp_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn protect_lamp_status(&self) -> ProtectLampStatus2566750974 {
        ProtectLampStatus2566750974::from(self.protect_lamp_status_raw_value() as u64)
    }

    /// The FMI defines the type of failure detected in the subsystem identified by an SPN.
    #[allow(dead_code)]
    pub fn failure_mode_identifier2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0x1F)) as u8
    }

    #[allow(dead_code)]
    pub fn failure_mode_identifier2(&self) -> FailureModeIdentifier22566750974 {
        FailureModeIdentifier22566750974::from(self.failure_mode_identifier2_raw_value() as u64)
    }

    /// Read SPNConversionMethod5 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method5_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 175) & 0x1) == 1)
    }

    /// Read SPNConversionMethod4 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method4_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 143) & 0x1) == 1)
    }

    /// Read SPNConversionMethod3 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method3_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 111) & 0x1) == 1)
    }

    /// Read SPNConversionMethod2 signal from can frame
    #[allow(dead_code)]
    pub fn spn_conversion_method2_raw_value(&self) -> bool {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 79) & 0x1) == 1)
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count5_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 168) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count4_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 136) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count3_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 104) & 0x7F)) as u8
    }

    /// The 7 bit occurence count field contains the number of times a fault has gone from active to previously active.
    #[allow(dead_code)]
    pub fn occurence_count2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 72) & 0x7F)) as u8
    }

    /// SPN #5 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn5_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 165) & 0x7)) as u8
    }

    /// SPN #4 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn4_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 133) & 0x7)) as u8
    }

    /// SPN #3 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn3_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 101) & 0x7)) as u8
    }

    /// SPN #2 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn2_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 69) & 0x7)) as u8
    }

    /// SPN #1 (Conversion Version 4)
    #[allow(dead_code)]
    pub fn spn1_high_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 37) & 0x7)) as u8
    }
}

/// Aftertreatment 2 Trip Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ati2 {
    frame_payload: Vec<u8>,
}

impl Ati2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ati2 {
        frame_payload.resize(8, 0);
        Ati2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ati2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419264766);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ati2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total amount of time that aftertreatment device 2 has been in passive regeneration during the current trip period.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_trp_pssv_rgnration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF)) as u32
    }

    /// Total number of passive regenerations by aftertreatment device 2 during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_trp_nmbr_of_pssv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0xFFFFFFFF)) as u32
    }

    /// Total number of active regenerations by aftertreatment device 2 during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_trp_nmbr_of_actv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF)) as u32
    }

    /// Total number of aftertreatment device 2 active regeneration manual requests by the operator during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_trp_nmbr_of_actv_rgnrtn_mn_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 224) & 0xFFFFFFFF)) as u32
    }

    /// Total number of aftertreatment device 2 active regeneration inhibit requests by the operator during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_trp_nmbr_of_actv_rgnrtn_in_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 192) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of time that aftertreatment device 2 has been in active regeneration during the current trip period.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_trp_actv_rgnration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of fuel used by aftertreatment device 2 during the current trip period.
    /// Unit: L
    #[allow(dead_code)]
    pub fn aftertreatment2_trip_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Total amount of time that aftertreatment 2 regeneration has been manually disabled during the current trip period.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftertreatment2_trip_disabled_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF)) as u32
    }
}

/// Aftertreatment 1 Trip Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ati1 {
    frame_payload: Vec<u8>,
}

impl Ati1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ati1 {
        frame_payload.resize(8, 0);
        Ati1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ati1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419265022);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ati1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Total amount of time that aftertreatment device 1 has been in passive regeneration during the current trip period.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_trp_pssv_rgnration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 128) & 0xFFFFFFFF)) as u32
    }

    /// Total number of passive regenerations by Aftertreatment device 1 during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_trp_nmbr_of_pssv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 160) & 0xFFFFFFFF)) as u32
    }

    /// Total number of active regenerations by Aftertreatment device 1 during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_trp_nmbr_of_actv_rgnrtns_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 96) & 0xFFFFFFFF)) as u32
    }

    /// Total number of Aftertreatment device 1 active regeneration manual requests by the operator during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_trp_nmbr_of_actv_rgnrtn_mn_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 224) & 0xFFFFFFFF)) as u32
    }

    /// Total number of aftertreatment device 1 active regeneration inhibit requests by the operator during the current trip period.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_trp_nmbr_of_actv_rgnrtn_in_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 192) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of time that aftertreatment device 1 has been in active regeneration during the current trip period.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_trp_actv_rgnration_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFFFFFF)) as u32
    }

    /// Total amount of fuel used by aftertreatment device 1 during the current trip period.
    /// Unit: L
    #[allow(dead_code)]
    pub fn aftertreatment1_trip_fuel_used_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFFFFFF) as f64 * 0.500000).round() as u32
    }

    /// Total amount of time that aftertreatment 1 regeneration has been manually disabled during the current trip period.
    /// Unit: s
    #[allow(dead_code)]
    pub fn aftertreatment1_trip_disabled_time_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 64) & 0xFFFFFFFF)) as u32
    }
}

/// Aftertreatment Air Control 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Aac3 {
    frame_payload: Vec<u8>,
}

impl Aac3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Aac3 {
        frame_payload.resize(8, 0);
        Aac3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Aac3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419261950);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Aac3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftertreatment1SecondAirPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment1_second_air_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Indicates the secondary air mass flow for aftertreatment 1.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn aftrtreatment1_second_air_mass_flow_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.200000).round() as u16
    }

    /// Indicates the secondary air temperature for aftertreatment 1.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment1_second_air_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Indicates the secondary air differential pressure for aftertreatment 1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftrtratment1_second_air_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Aftertreatment Air Control 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Aac4 {
    frame_payload: Vec<u8>,
}

impl Aac4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Aac4 {
        frame_payload.resize(8, 0);
        Aac4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Aac4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419261694);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Aac4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftertreatment2SecondAirPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftertreatment2_second_air_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Indicates the secondary air mass flow for aftertreatment 2.
    /// Unit: kg/h
    #[allow(dead_code)]
    pub fn aftrtreatment2_second_air_mass_flow_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.200000).round() as u16
    }

    /// Indicates the secondary air temperature for aftertreatment 2.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment2_second_air_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Indicates the secondary air differential pressure for aftertreatment 2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftrtratment2_second_air_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.007812).round() as u16
    }
}

/// Advertised Engine Torque Curve
#[allow(dead_code)]
#[derive(Debug)]
pub struct Aetc {
    frame_payload: Vec<u8>,
}

impl Aetc {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Aetc {
        frame_payload.resize(8, 0);
        Aetc { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Aetc, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419270910);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Aetc::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates the number of speed / torque data points contained in the Advertised Engine Torque Curve broadcast (AETC).
    #[allow(dead_code)]
    pub fn number_of_aetc_data_points_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0xF)) as u8
    }

    /// Indicates the standardized method by which torque data was obtained for the Advertised Engine Torque Curve (AETC).
    #[allow(dead_code)]
    pub fn aetc_data_collection_standard_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn aetc_data_collection_standard(&self) -> AetcDataCollectionStandard2566754558 {
        AetcDataCollectionStandard2566754558::from(self.aetc_data_collection_standard_raw_value() as u64)
    }
}

/// Adaptive Front-Lighting System Status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Afss {
    frame_payload: Vec<u8>,
}

impl Afss {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Afss {
        frame_payload.resize(8, 0);
        Afss { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Afss, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419266302);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Afss::new(frame.data().to_vec())));
        Ok(f)
    }

    /// This parameter indicates what kind of light distribution is set by the AFS system for the right headlamp.
    #[allow(dead_code)]
    pub fn right_headlamp_light_distribution_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn right_headlamp_light_distribution(&self) -> RightHeadlampLightDistribution2566749950 {
        RightHeadlampLightDistribution2566749950::from(self.right_headlamp_light_distribution_raw_value() as u64)
    }

    /// This parameter indicates what kind of light distribution is set by the AFS system for the left headlamp.
    #[allow(dead_code)]
    pub fn left_headlamp_light_distribution_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn left_headlamp_light_distribution(&self) -> LeftHeadlampLightDistribution2566749950 {
        LeftHeadlampLightDistribution2566749950::from(self.left_headlamp_light_distribution_raw_value() as u64)
    }

    /// This parameter indicates whether the dynamic bending light of the left headlamp is working properly.
    #[allow(dead_code)]
    pub fn rght_headlamp_dynamic_bending_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 3) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn rght_headlamp_dynamic_bending_light(&self) -> RghtHeadlampDynamicBendingLight2566749950 {
        RghtHeadlampDynamicBendingLight2566749950::from(self.rght_headlamp_dynamic_bending_light_raw_value() as u64)
    }

    /// This parameter indicates whether the dynamic bending light of the left headlamp is working properly.
    #[allow(dead_code)]
    pub fn left_headlamp_dynamic_bending_light_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn left_headlamp_dynamic_bending_light(&self) -> LeftHeadlampDynamicBendingLight2566749950 {
        LeftHeadlampDynamicBendingLight2566749950::from(self.left_headlamp_dynamic_bending_light_raw_value() as u64)
    }
}

/// Aftertreatment 1 Intake Gas 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct At1i1 {
    frame_payload: Vec<u8>,
}

impl At1i1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At1i1 {
        frame_payload.resize(8, 0);
        At1i1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At1i1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418385662);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At1i1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt1IntkOxygnSnsrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_oxygn_snsr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt1IntkNOxSnsrPrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_n_ox_snsr_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Indicates the heater status in the warm-up process.
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_gs_snsr_heater_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 45) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_gs_snsr_heater_ctrl(&self) -> Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310 {
        Aftrtrtmnt1IntkGsSnsrHeaterCtrl2565869310::from(self.aftrtrtmnt1_intk_gs_snsr_heater_ctrl_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1IntkGsSnsrHtrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_gs_snsr_htr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt1IntkWdRngO2RdngStble signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_wd_rng_o2_rdng_stble_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_wd_rng_o2_rdng_stble(&self) -> Aftrtrtmnt1IntkWdRngO2RdngStble2565869310 {
        Aftrtrtmnt1IntkWdRngO2RdngStble2565869310::from(self.aftrtrtmnt1_intk_wd_rng_o2_rdng_stble_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1IntkNOxReadingStable signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_n_ox_reading_stable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_n_ox_reading_stable(&self) -> Aftrtrtmnt1IntkNOxReadingStable2565869310 {
        Aftrtrtmnt1IntkNOxReadingStable2565869310::from(self.aftrtrtmnt1_intk_n_ox_reading_stable_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1IntkeGasSensorAtTemp signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intke_gas_sensor_at_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    /// Read Aftrtrtmnt1IntkGsSnsrPwrInRange signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_gs_snsr_pwr_in_range_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_intk_gs_snsr_pwr_in_range(&self) -> Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310 {
        Aftrtrtmnt1IntkGsSnsrPwrInRange2565869310::from(self.aftrtrtmnt1_intk_gs_snsr_pwr_in_range_raw_value() as u64)
    }

    /// The actual oxidation factor (%O2) of the gas within the exhaust stream.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment1_intake_o2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.000514).round() as u16
    }

    /// Read Aftertreatment1IntakeNOx signal from can frame
    /// Unit: ppm
    #[allow(dead_code)]
    pub fn aftertreatment1_intake_n_ox_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Aftertreatment 1 Intake Gas 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct At1i2 {
    frame_payload: Vec<u8>,
}

impl At1i2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At1i2 {
        frame_payload.resize(8, 0);
        At1i2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At1i2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419280126);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At1i2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt1PrtcltTrpIntkGsTmpPrl signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_prtclt_trp_intk_gs_tmp_prl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt1ExhstGsTmp1PrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_exhst_gs_tmp1_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    /// Temperature of engine combustion byproducts entering the particulate trap in exhaust bank 1.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_prtclt_trp_intk_gas_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// The reading from the exhaust gas temperature sensor located farthest upstream in the aftertreatment system in exhaust bank 1.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment1_exhaust_gas_temp1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Aftertreatment 1 Outlet Gas 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct At1o1 {
    frame_payload: Vec<u8>,
}

impl At1o1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At1o1 {
        frame_payload.resize(8, 0);
        At1o1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At1o1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418385918);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At1o1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt1OtltOxygnSnsrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_oxygn_snsr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt1OtltNOxSnsrPrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_n_ox_snsr_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Indicates the heater status in the warm-up process.
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_gs_snsr_heater_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 45) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_gs_snsr_heater_ctrl(&self) -> Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566 {
        Aftrtrtmnt1OtltGsSnsrHeaterCtrl2565869566::from(self.aftrtrtmnt1_otlt_gs_snsr_heater_ctrl_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1OtltGsSnsrHtrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_gs_snsr_htr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt1OtltWdRngO2RdngStble signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_wd_rng_o2_rdng_stble_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_wd_rng_o2_rdng_stble(&self) -> Aftrtrtmnt1OtltWdRngO2RdngStble2565869566 {
        Aftrtrtmnt1OtltWdRngO2RdngStble2565869566::from(self.aftrtrtmnt1_otlt_wd_rng_o2_rdng_stble_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1OtltNOxReadingStable signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_n_ox_reading_stable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_n_ox_reading_stable(&self) -> Aftrtrtmnt1OtltNOxReadingStable2565869566 {
        Aftrtrtmnt1OtltNOxReadingStable2565869566::from(self.aftrtrtmnt1_otlt_n_ox_reading_stable_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1OtletGasSensorAtTemp signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlet_gas_sensor_at_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlet_gas_sensor_at_temp(&self) -> Aftrtrtmnt1OtletGasSensorAtTemp2565869566 {
        Aftrtrtmnt1OtletGasSensorAtTemp2565869566::from(self.aftrtrtmnt1_otlet_gas_sensor_at_temp_raw_value() as u64)
    }

    /// Read Aftrtrtmnt1OtltGsSnsrPwrInRange signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_gs_snsr_pwr_in_range_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt1_otlt_gs_snsr_pwr_in_range(&self) -> Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566 {
        Aftrtrtmnt1OtltGsSnsrPwrInRange2565869566::from(self.aftrtrtmnt1_otlt_gs_snsr_pwr_in_range_raw_value() as u64)
    }

    /// The actual oxidation factor (%O2) of the gas within the exhaust stream.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment1_outlet_o2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.000514).round() as u16
    }

    /// Read Aftertreatment1OutletNOx signal from can frame
    /// Unit: ppm
    #[allow(dead_code)]
    pub fn aftertreatment1_outlet_n_ox_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Aftertreatment 1 Outlet Gas 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct At1o2 {
    frame_payload: Vec<u8>,
}

impl At1o2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At1o2 {
        frame_payload.resize(8, 0);
        At1o2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At1o2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419279870);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At1o2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt1PrtcltTrpOtltExhstGsT signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_prtclt_trp_otlt_exhst_gs_t_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt1ExhstGsTmp3PrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_exhst_gs_tmp3_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    /// Temperature of engine combustion byproducts leaving the particulate trap exhaust in exhaust bank 1.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftrtrtmnt1_prtclt_trp_otlt_gas_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read Aftertreatment1ExhaustGasTemp3 signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment1_exhaust_gas_temp3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Aftertreatment 2 Intake Gas 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct At2i1 {
    frame_payload: Vec<u8>,
}

impl At2i1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At2i1 {
        frame_payload.resize(8, 0);
        At2i1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At2i1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418386174);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At2i1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt2IntkOxygnSnsrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_oxygn_snsr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2IntkNOxSnsrPrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_n_ox_snsr_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Indicates the heater status in the warm-up process.
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_gs_snsr_heater_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 45) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_gs_snsr_heater_ctrl(&self) -> Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822 {
        Aftrtrtmnt2IntkGsSnsrHeaterCtrl2565869822::from(self.aftrtrtmnt2_intk_gs_snsr_heater_ctrl_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2IntkGsSnsrHtrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_gs_snsr_htr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2IntkWdRngO2RdngStble signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_wd_rng_o2_rdng_stble_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_wd_rng_o2_rdng_stble(&self) -> Aftrtrtmnt2IntkWdRngO2RdngStble2565869822 {
        Aftrtrtmnt2IntkWdRngO2RdngStble2565869822::from(self.aftrtrtmnt2_intk_wd_rng_o2_rdng_stble_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2IntkNOxReadingStable signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_n_ox_reading_stable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_n_ox_reading_stable(&self) -> Aftrtrtmnt2IntkNOxReadingStable2565869822 {
        Aftrtrtmnt2IntkNOxReadingStable2565869822::from(self.aftrtrtmnt2_intk_n_ox_reading_stable_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2IntkeGasSensorAtTemp signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intke_gas_sensor_at_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intke_gas_sensor_at_temp(&self) -> Aftrtrtmnt2IntkeGasSensorAtTemp2565869822 {
        Aftrtrtmnt2IntkeGasSensorAtTemp2565869822::from(self.aftrtrtmnt2_intke_gas_sensor_at_temp_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2IntkGsSnsrPwrInRange signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_gs_snsr_pwr_in_range_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_intk_gs_snsr_pwr_in_range(&self) -> Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822 {
        Aftrtrtmnt2IntkGsSnsrPwrInRange2565869822::from(self.aftrtrtmnt2_intk_gs_snsr_pwr_in_range_raw_value() as u64)
    }

    /// The actual oxidation factor (%O2) of the gas within the exhaust stream.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment2_intake_o2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.000514).round() as u16
    }

    /// Read Aftertreatment2IntakeNOx signal from can frame
    /// Unit: ppm
    #[allow(dead_code)]
    pub fn aftertreatment2_intake_n_ox_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Aftertreatment 2 Intake Gas 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct At2i2 {
    frame_payload: Vec<u8>,
}

impl At2i2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At2i2 {
        frame_payload.resize(8, 0);
        At2i2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At2i2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419279358);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At2i2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt2PrtcltTrpIntkGsTmpPrl signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclt_trp_intk_gs_tmp_prl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2ExhstGsTmp1PrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_exhst_gs_tmp1_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    /// Temperature of engine combustion byproducts entering the particulate trap in exhaust bank 2.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclt_trp_intk_gas_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// The reading from the exhaust gas temperature sensor located farthest upstream in the aftertreatment system in exhaust bank 2.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment2_exhaust_gas_temp1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Aftertreatment 2 Outlet Gas 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct At2o1 {
    frame_payload: Vec<u8>,
}

impl At2o1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At2o1 {
        frame_payload.resize(8, 0);
        At2o1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At2o1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418386430);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At2o1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt2OtltOxygnSnsrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_oxygn_snsr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2OtltNOxSnsrPrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_n_ox_snsr_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Indicates the heater status in the warm-up process.
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_gs_snsr_heater_ctrl_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 45) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_gs_snsr_heater_ctrl(&self) -> Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078 {
        Aftrtrtmnt2OtltGsSnsrHeaterCtrl2565870078::from(self.aftrtrtmnt2_otlt_gs_snsr_heater_ctrl_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2OtltGsSnsrHtrPrlmnryF signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_gs_snsr_htr_prlmnry_f_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2OtltWdRngO2RdngStble signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_wd_rng_o2_rdng_stble_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_wd_rng_o2_rdng_stble(&self) -> Aftrtrtmnt2OtltWdRngO2RdngStble2565870078 {
        Aftrtrtmnt2OtltWdRngO2RdngStble2565870078::from(self.aftrtrtmnt2_otlt_wd_rng_o2_rdng_stble_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2OtltNOxReadingStable signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_n_ox_reading_stable_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_n_ox_reading_stable(&self) -> Aftrtrtmnt2OtltNOxReadingStable2565870078 {
        Aftrtrtmnt2OtltNOxReadingStable2565870078::from(self.aftrtrtmnt2_otlt_n_ox_reading_stable_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2OtletGasSensorAtTemp signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlet_gas_sensor_at_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlet_gas_sensor_at_temp(&self) -> Aftrtrtmnt2OtletGasSensorAtTemp2565870078 {
        Aftrtrtmnt2OtletGasSensorAtTemp2565870078::from(self.aftrtrtmnt2_otlet_gas_sensor_at_temp_raw_value() as u64)
    }

    /// Read Aftrtrtmnt2OtltGsSnsrPwrInRange signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_gs_snsr_pwr_in_range_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aftrtrtmnt2_otlt_gs_snsr_pwr_in_range(&self) -> Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078 {
        Aftrtrtmnt2OtltGsSnsrPwrInRange2565870078::from(self.aftrtrtmnt2_otlt_gs_snsr_pwr_in_range_raw_value() as u64)
    }

    /// The actual oxidation factor (%O2) of the gas within the exhaust stream.
    /// Unit: %
    #[allow(dead_code)]
    pub fn aftertreatment2_outlet_o2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.000514).round() as u16
    }

    /// Read Aftertreatment2OutletNOx signal from can frame
    /// Unit: ppm
    #[allow(dead_code)]
    pub fn aftertreatment2_outlet_n_ox_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}

/// Aftertreatment 2 Outlet Gas 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct At2o2 {
    frame_payload: Vec<u8>,
}

impl At2o2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> At2o2 {
        frame_payload.resize(8, 0);
        At2o2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<At2o2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419279102);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| At2o2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt2PrtcltTrpExhstGsTmpPr signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclt_trp_exhst_gs_tmp_pr_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2ExhstGsTmp3PrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_exhst_gs_tmp3_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x1F)) as u8
    }

    /// Temperature of engine combustion byproducts leaving the particulate trap exhaust in exhaust bank 2.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclt_trp_otlt_gas_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read Aftertreatment2ExhaustGasTemp3 signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment2_exhaust_gas_temp3_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Aftertreatment 1 Gas Parameters
#[allow(dead_code)]
#[derive(Debug)]
pub struct Atgp1 {
    frame_payload: Vec<u8>,
}

impl Atgp1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Atgp1 {
        frame_payload.resize(8, 0);
        Atgp1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Atgp1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419269886);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Atgp1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ParticulateTrapOutletPress1 signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn particulate_trap_outlet_press1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read ParticulateTrapIntakePress1 signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn particulate_trap_intake_press1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Aftertreatment 2 Gas Parameters
#[allow(dead_code)]
#[derive(Debug)]
pub struct Atgp2 {
    frame_payload: Vec<u8>,
}

impl Atgp2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Atgp2 {
        frame_payload.resize(8, 0);
        Atgp2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Atgp2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419269630);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Atgp2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read ParticulateTrapOutletPress2 signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn particulate_trap_outlet_press2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read ParticulateTrapIntakePress2 signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn particulate_trap_intake_press2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.100000).round() as u16
    }
}

/// Aftertreatment 2 Intermediate Gas
#[allow(dead_code)]
#[derive(Debug)]
pub struct Atm2 {
    frame_payload: Vec<u8>,
}

impl Atm2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Atm2 {
        frame_payload.resize(8, 0);
        Atm2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Atm2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419278846);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Atm2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read Aftrtrtmnt2PrtcltTrpDltPrssPrlmn signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclt_trp_dlt_prss_prlmn_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x1F)) as u8
    }

    /// Read Aftrtrtmnt2ExhstGsTmp2PrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_exhst_gs_tmp2_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Exhaust differential pressure measured between the intake and exhaust of a particulate trap in exhaust bank 2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclte_trap_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Read Aftrtrtmnt2PrtcltTrpIntrmdtGsTmp signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftrtrtmnt2_prtclt_trp_intrmdt_gs_tmp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read Aftertreatment2ExhaustGasTemp2 signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aftertreatment2_exhaust_gas_temp2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Aftertreatment 1 Service
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ats1 {
    frame_payload: Vec<u8>,
}

impl Ats1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ats1 {
        frame_payload.resize(8, 0);
        Ats1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ats1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419265534);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ats1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates the time since the last active regeneration event of particulate trap 1.
    /// Unit: s
    #[allow(dead_code)]
    pub fn prtclt_trp1_tm_snc_lst_actv_rgnration_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFFFFFF)) as u32
    }

    /// Indicates the ash load percent of particulate trap 1.
    /// Unit: %
    #[allow(dead_code)]
    pub fn particulate_trap1_ash_load_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn particulate_trap1_ash_load_percent(&self) -> ParticulateTrap1AshLoadPercent2566749182 {
        ParticulateTrap1AshLoadPercent2566749182::from(self.particulate_trap1_ash_load_percent_raw_value() as u64)
    }

    /// Indicates the soot load percent of particulate trap 1.
    /// Unit: %
    #[allow(dead_code)]
    pub fn particulate_trap1_soot_load_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn particulate_trap1_soot_load_percent(&self) -> ParticulateTrap1SootLoadPercent2566749182 {
        ParticulateTrap1SootLoadPercent2566749182::from(self.particulate_trap1_soot_load_percent_raw_value() as u64)
    }
}

/// Aftertreatment 2 Service
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ats2 {
    frame_payload: Vec<u8>,
}

impl Ats2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ats2 {
        frame_payload.resize(8, 0);
        Ats2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ats2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419265278);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ats2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates the time since the last active regeneration event of particulate trap 2.
    /// Unit: s
    #[allow(dead_code)]
    pub fn prtclt_trp2_tm_snc_lst_actv_rgnration_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFFFFFF)) as u32
    }

    /// Indicates the ash load percent of particulate trap 2.
    /// Unit: %
    #[allow(dead_code)]
    pub fn particulate_trap2_ash_load_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn particulate_trap2_ash_load_percent(&self) -> ParticulateTrap2AshLoadPercent2566748926 {
        ParticulateTrap2AshLoadPercent2566748926::from(self.particulate_trap2_ash_load_percent_raw_value() as u64)
    }

    /// Indicates the soot load percent of particulate trap 2.
    /// Unit: %
    #[allow(dead_code)]
    pub fn particulate_trap2_soot_load_percent_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn particulate_trap2_soot_load_percent(&self) -> ParticulateTrap2SootLoadPercent2566748926 {
        ParticulateTrap2SootLoadPercent2566748926::from(self.particulate_trap2_soot_load_percent_raw_value() as u64)
    }
}

/// Auxiliary Input/Output Status 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Auxio1 {
    frame_payload: Vec<u8>,
}

impl Auxio1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Auxio1 {
        frame_payload.resize(8, 0);
        Auxio1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Auxio1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419355134);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Auxio1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Auxiliary channel of data (16 bit) read by the ECU.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aux_i_o_channel2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF)) as u16
    }

    /// Auxiliary channel of data (16 bit) read by the ECU.
    /// Unit: counts
    #[allow(dead_code)]
    pub fn aux_i_o_channel1_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF)) as u16
    }
}

/// Auxiliary Input/Output Status 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Auxio2 {
    frame_payload: Vec<u8>,
}

impl Auxio2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Auxio2 {
        frame_payload.resize(8, 0);
        Auxio2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Auxio2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(413662974);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Auxio2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o45_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o45(&self) -> AuxIO452561146622 {
        AuxIO452561146622::from(self.aux_i_o45_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o46_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o46(&self) -> AuxIO462561146622 {
        AuxIO462561146622::from(self.aux_i_o46_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o47_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o47(&self) -> AuxIO472561146622 {
        AuxIO472561146622::from(self.aux_i_o47_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o48_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o48(&self) -> AuxIO482561146622 {
        AuxIO482561146622::from(self.aux_i_o48_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o41_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o41(&self) -> AuxIO412561146622 {
        AuxIO412561146622::from(self.aux_i_o41_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o42_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o42(&self) -> AuxIO422561146622 {
        AuxIO422561146622::from(self.aux_i_o42_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o43_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o43(&self) -> AuxIO432561146622 {
        AuxIO432561146622::from(self.aux_i_o43_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o44_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o44(&self) -> AuxIO442561146622 {
        AuxIO442561146622::from(self.aux_i_o44_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o37_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o37(&self) -> AuxIO372561146622 {
        AuxIO372561146622::from(self.aux_i_o37_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o38_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o38(&self) -> AuxIO382561146622 {
        AuxIO382561146622::from(self.aux_i_o38_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o39_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o39(&self) -> AuxIO392561146622 {
        AuxIO392561146622::from(self.aux_i_o39_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o40_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o40(&self) -> AuxIO402561146622 {
        AuxIO402561146622::from(self.aux_i_o40_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o33_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o33(&self) -> AuxIO332561146622 {
        AuxIO332561146622::from(self.aux_i_o33_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o34_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o34(&self) -> AuxIO342561146622 {
        AuxIO342561146622::from(self.aux_i_o34_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o35_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o35(&self) -> AuxIO352561146622 {
        AuxIO352561146622::from(self.aux_i_o35_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o36_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o36(&self) -> AuxIO362561146622 {
        AuxIO362561146622::from(self.aux_i_o36_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o29_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o29(&self) -> AuxIO292561146622 {
        AuxIO292561146622::from(self.aux_i_o29_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o30_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o30(&self) -> AuxIO302561146622 {
        AuxIO302561146622::from(self.aux_i_o30_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o31_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o31(&self) -> AuxIO312561146622 {
        AuxIO312561146622::from(self.aux_i_o31_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o32_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o32(&self) -> AuxIO322561146622 {
        AuxIO322561146622::from(self.aux_i_o32_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o25_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o25(&self) -> AuxIO252561146622 {
        AuxIO252561146622::from(self.aux_i_o25_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o26_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o26(&self) -> AuxIO262561146622 {
        AuxIO262561146622::from(self.aux_i_o26_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o27_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o27(&self) -> AuxIO272561146622 {
        AuxIO272561146622::from(self.aux_i_o27_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o28_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o28(&self) -> AuxIO282561146622 {
        AuxIO282561146622::from(self.aux_i_o28_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o21_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o21(&self) -> AuxIO212561146622 {
        AuxIO212561146622::from(self.aux_i_o21_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o22_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o22(&self) -> AuxIO222561146622 {
        AuxIO222561146622::from(self.aux_i_o22_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o23_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o23(&self) -> AuxIO232561146622 {
        AuxIO232561146622::from(self.aux_i_o23_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o24_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o24(&self) -> AuxIO242561146622 {
        AuxIO242561146622::from(self.aux_i_o24_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o17_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o17(&self) -> AuxIO172561146622 {
        AuxIO172561146622::from(self.aux_i_o17_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o18_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o18(&self) -> AuxIO182561146622 {
        AuxIO182561146622::from(self.aux_i_o18_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o19_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o19(&self) -> AuxIO192561146622 {
        AuxIO192561146622::from(self.aux_i_o19_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o20_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o20(&self) -> AuxIO202561146622 {
        AuxIO202561146622::from(self.aux_i_o20_raw_value() as u64)
    }
}

/// Auxiliary Input/Output Status 3
#[allow(dead_code)]
#[derive(Debug)]
pub struct Auxio3 {
    frame_payload: Vec<u8>,
}

impl Auxio3 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Auxio3 {
        frame_payload.resize(8, 0);
        Auxio3 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Auxio3, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(413597438);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Auxio3::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o77_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o77(&self) -> AuxIO772561081086 {
        AuxIO772561081086::from(self.aux_i_o77_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o78_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o78(&self) -> AuxIO782561081086 {
        AuxIO782561081086::from(self.aux_i_o78_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o79_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o79(&self) -> AuxIO792561081086 {
        AuxIO792561081086::from(self.aux_i_o79_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o80_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o80(&self) -> AuxIO802561081086 {
        AuxIO802561081086::from(self.aux_i_o80_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o73_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o73(&self) -> AuxIO732561081086 {
        AuxIO732561081086::from(self.aux_i_o73_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o74_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o74(&self) -> AuxIO742561081086 {
        AuxIO742561081086::from(self.aux_i_o74_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o75_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o75(&self) -> AuxIO752561081086 {
        AuxIO752561081086::from(self.aux_i_o75_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o76_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o76(&self) -> AuxIO762561081086 {
        AuxIO762561081086::from(self.aux_i_o76_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o69_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o69(&self) -> AuxIO692561081086 {
        AuxIO692561081086::from(self.aux_i_o69_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o70_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o70(&self) -> AuxIO702561081086 {
        AuxIO702561081086::from(self.aux_i_o70_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o71_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o71(&self) -> AuxIO712561081086 {
        AuxIO712561081086::from(self.aux_i_o71_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o72_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o72(&self) -> AuxIO722561081086 {
        AuxIO722561081086::from(self.aux_i_o72_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o65_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o65(&self) -> AuxIO652561081086 {
        AuxIO652561081086::from(self.aux_i_o65_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o66_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o66(&self) -> AuxIO662561081086 {
        AuxIO662561081086::from(self.aux_i_o66_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o67_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o67(&self) -> AuxIO672561081086 {
        AuxIO672561081086::from(self.aux_i_o67_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o68_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o68(&self) -> AuxIO682561081086 {
        AuxIO682561081086::from(self.aux_i_o68_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o61_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o61(&self) -> AuxIO612561081086 {
        AuxIO612561081086::from(self.aux_i_o61_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o62_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o62(&self) -> AuxIO622561081086 {
        AuxIO622561081086::from(self.aux_i_o62_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o63_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o63(&self) -> AuxIO632561081086 {
        AuxIO632561081086::from(self.aux_i_o63_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o64_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o64(&self) -> AuxIO642561081086 {
        AuxIO642561081086::from(self.aux_i_o64_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o57_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o57(&self) -> AuxIO572561081086 {
        AuxIO572561081086::from(self.aux_i_o57_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o58_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o58(&self) -> AuxIO582561081086 {
        AuxIO582561081086::from(self.aux_i_o58_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o59_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o59(&self) -> AuxIO592561081086 {
        AuxIO592561081086::from(self.aux_i_o59_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o60_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o60(&self) -> AuxIO602561081086 {
        AuxIO602561081086::from(self.aux_i_o60_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o53_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o53(&self) -> AuxIO532561081086 {
        AuxIO532561081086::from(self.aux_i_o53_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o54_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o54(&self) -> AuxIO542561081086 {
        AuxIO542561081086::from(self.aux_i_o54_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o55_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o55(&self) -> AuxIO552561081086 {
        AuxIO552561081086::from(self.aux_i_o55_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o56_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o56(&self) -> AuxIO562561081086 {
        AuxIO562561081086::from(self.aux_i_o56_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o49_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o49(&self) -> AuxIO492561081086 {
        AuxIO492561081086::from(self.aux_i_o49_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o50_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o50(&self) -> AuxIO502561081086 {
        AuxIO502561081086::from(self.aux_i_o50_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o51_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o51(&self) -> AuxIO512561081086 {
        AuxIO512561081086::from(self.aux_i_o51_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o52_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o52(&self) -> AuxIO522561081086 {
        AuxIO522561081086::from(self.aux_i_o52_raw_value() as u64)
    }
}

/// Auxiliary Input/Output Status 4
#[allow(dead_code)]
#[derive(Debug)]
pub struct Auxio4 {
    frame_payload: Vec<u8>,
}

impl Auxio4 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Auxio4 {
        frame_payload.resize(8, 0);
        Auxio4 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Auxio4, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(413531902);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Auxio4::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o92_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o92(&self) -> AuxIO922561015550 {
        AuxIO922561015550::from(self.aux_i_o92_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o85_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 14) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o85(&self) -> AuxIO852561015550 {
        AuxIO852561015550::from(self.aux_i_o85_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o86_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o86(&self) -> AuxIO862561015550 {
        AuxIO862561015550::from(self.aux_i_o86_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o87_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o87(&self) -> AuxIO872561015550 {
        AuxIO872561015550::from(self.aux_i_o87_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o88_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o88(&self) -> AuxIO882561015550 {
        AuxIO882561015550::from(self.aux_i_o88_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o81_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o81(&self) -> AuxIO812561015550 {
        AuxIO812561015550::from(self.aux_i_o81_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o82_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o82(&self) -> AuxIO822561015550 {
        AuxIO822561015550::from(self.aux_i_o82_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o83_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 2) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o83(&self) -> AuxIO832561015550 {
        AuxIO832561015550::from(self.aux_i_o83_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o84_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o84(&self) -> AuxIO842561015550 {
        AuxIO842561015550::from(self.aux_i_o84_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o109_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 62) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o109(&self) -> AuxIO1092561015550 {
        AuxIO1092561015550::from(self.aux_i_o109_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o110_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o110(&self) -> AuxIO1102561015550 {
        AuxIO1102561015550::from(self.aux_i_o110_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o111_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o111(&self) -> AuxIO1112561015550 {
        AuxIO1112561015550::from(self.aux_i_o111_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o112_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o112(&self) -> AuxIO1122561015550 {
        AuxIO1122561015550::from(self.aux_i_o112_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o105_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o105(&self) -> AuxIO1052561015550 {
        AuxIO1052561015550::from(self.aux_i_o105_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o106_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o106(&self) -> AuxIO1062561015550 {
        AuxIO1062561015550::from(self.aux_i_o106_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o107_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o107(&self) -> AuxIO1072561015550 {
        AuxIO1072561015550::from(self.aux_i_o107_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o108_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o108(&self) -> AuxIO1082561015550 {
        AuxIO1082561015550::from(self.aux_i_o108_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o101_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 46) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o101(&self) -> AuxIO1012561015550 {
        AuxIO1012561015550::from(self.aux_i_o101_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o102_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 44) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o102(&self) -> AuxIO1022561015550 {
        AuxIO1022561015550::from(self.aux_i_o102_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o103_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o103(&self) -> AuxIO1032561015550 {
        AuxIO1032561015550::from(self.aux_i_o103_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o104_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o104(&self) -> AuxIO1042561015550 {
        AuxIO1042561015550::from(self.aux_i_o104_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o97_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 38) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o97(&self) -> AuxIO972561015550 {
        AuxIO972561015550::from(self.aux_i_o97_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o98_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o98(&self) -> AuxIO982561015550 {
        AuxIO982561015550::from(self.aux_i_o98_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o99_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 34) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o99(&self) -> AuxIO992561015550 {
        AuxIO992561015550::from(self.aux_i_o99_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o100_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o100(&self) -> AuxIO1002561015550 {
        AuxIO1002561015550::from(self.aux_i_o100_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o93_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o93(&self) -> AuxIO932561015550 {
        AuxIO932561015550::from(self.aux_i_o93_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o94_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 28) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o94(&self) -> AuxIO942561015550 {
        AuxIO942561015550::from(self.aux_i_o94_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o95_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 26) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o95(&self) -> AuxIO952561015550 {
        AuxIO952561015550::from(self.aux_i_o95_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o96_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o96(&self) -> AuxIO962561015550 {
        AuxIO962561015550::from(self.aux_i_o96_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o89_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 22) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o89(&self) -> AuxIO892561015550 {
        AuxIO892561015550::from(self.aux_i_o89_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o90_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 20) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o90(&self) -> AuxIO902561015550 {
        AuxIO902561015550::from(self.aux_i_o90_raw_value() as u64)
    }

    /// Identifies the current status of auxiliary input/output functions that are configured uniquely per application.
    #[allow(dead_code)]
    pub fn aux_i_o91_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn aux_i_o91(&self) -> AuxIO912561015550 {
        AuxIO912561015550::from(self.aux_i_o91_raw_value() as u64)
    }
}

/// Brake actuator stroke status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Bsa {
    frame_payload: Vec<u8>,
}

impl Bsa {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Bsa {
        frame_payload.resize(8, 0);
        Bsa { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Bsa, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419262974);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Bsa::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Brake stroke status for right brake actuator on trailer axle 5.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle5_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 57) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle5_right(&self) -> TrailerBrakeStrokeAxle5Right2566746622 {
        TrailerBrakeStrokeAxle5Right2566746622::from(self.trailer_brake_stroke_axle5_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on trailer axle 5.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle5_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle5_left(&self) -> TrailerBrakeStrokeAxle5Left2566746622 {
        TrailerBrakeStrokeAxle5Left2566746622::from(self.trailer_brake_stroke_axle5_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on trailer axle 4.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle4_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 51) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle4_right(&self) -> TrailerBrakeStrokeAxle4Right2566746622 {
        TrailerBrakeStrokeAxle4Right2566746622::from(self.trailer_brake_stroke_axle4_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on trailer axle 4.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle4_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle4_left(&self) -> TrailerBrakeStrokeAxle4Left2566746622 {
        TrailerBrakeStrokeAxle4Left2566746622::from(self.trailer_brake_stroke_axle4_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on trailer axle 3.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle3_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 45) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle3_right(&self) -> TrailerBrakeStrokeAxle3Right2566746622 {
        TrailerBrakeStrokeAxle3Right2566746622::from(self.trailer_brake_stroke_axle3_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on trailer axle 3.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle3_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 42) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle3_left(&self) -> TrailerBrakeStrokeAxle3Left2566746622 {
        TrailerBrakeStrokeAxle3Left2566746622::from(self.trailer_brake_stroke_axle3_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on trailer axle 2.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle2_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 39) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle2_right(&self) -> TrailerBrakeStrokeAxle2Right2566746622 {
        TrailerBrakeStrokeAxle2Right2566746622::from(self.trailer_brake_stroke_axle2_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on trailer axle 2.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle2_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 36) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle2_left(&self) -> TrailerBrakeStrokeAxle2Left2566746622 {
        TrailerBrakeStrokeAxle2Left2566746622::from(self.trailer_brake_stroke_axle2_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on trailer axle 1.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle1_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 33) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle1_right(&self) -> TrailerBrakeStrokeAxle1Right2566746622 {
        TrailerBrakeStrokeAxle1Right2566746622::from(self.trailer_brake_stroke_axle1_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on trailerr axle 1.
    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle1_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 30) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn trailer_brake_stroke_axle1_left(&self) -> TrailerBrakeStrokeAxle1Left2566746622 {
        TrailerBrakeStrokeAxle1Left2566746622::from(self.trailer_brake_stroke_axle1_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on tractor axle 5.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle5_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 27) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle5_right(&self) -> TractorBrakeStrokeAxle5Right2566746622 {
        TractorBrakeStrokeAxle5Right2566746622::from(self.tractor_brake_stroke_axle5_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on tractor axle 5.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle5_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle5_left(&self) -> TractorBrakeStrokeAxle5Left2566746622 {
        TractorBrakeStrokeAxle5Left2566746622::from(self.tractor_brake_stroke_axle5_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on tractor axle 4.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle4_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 21) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle4_right(&self) -> TractorBrakeStrokeAxle4Right2566746622 {
        TractorBrakeStrokeAxle4Right2566746622::from(self.tractor_brake_stroke_axle4_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on tractor axle 4.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle4_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 18) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle4_left(&self) -> TractorBrakeStrokeAxle4Left2566746622 {
        TractorBrakeStrokeAxle4Left2566746622::from(self.tractor_brake_stroke_axle4_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on tractor axle 3.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle3_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 15) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle3_right(&self) -> TractorBrakeStrokeAxle3Right2566746622 {
        TractorBrakeStrokeAxle3Right2566746622::from(self.tractor_brake_stroke_axle3_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on tractor axle 3.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle3_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 12) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle3_left(&self) -> TractorBrakeStrokeAxle3Left2566746622 {
        TractorBrakeStrokeAxle3Left2566746622::from(self.tractor_brake_stroke_axle3_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on tractor axle 2.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle2_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 9) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle2_right(&self) -> TractorBrakeStrokeAxle2Right2566746622 {
        TractorBrakeStrokeAxle2Right2566746622::from(self.tractor_brake_stroke_axle2_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on tractor axle 2.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle2_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle2_left(&self) -> TractorBrakeStrokeAxle2Left2566746622 {
        TractorBrakeStrokeAxle2Left2566746622::from(self.tractor_brake_stroke_axle2_left_raw_value() as u64)
    }

    /// Brake stroke status for right brake actuator on tractor axle 1.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle1_right_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 3) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle1_right(&self) -> TractorBrakeStrokeAxle1Right2566746622 {
        TractorBrakeStrokeAxle1Right2566746622::from(self.tractor_brake_stroke_axle1_right_raw_value() as u64)
    }

    /// Brake stroke status for left brake actuator on tractor axle 1.
    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle1_left_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn tractor_brake_stroke_axle1_left(&self) -> TractorBrakeStrokeAxle1Left2566746622 {
        TractorBrakeStrokeAxle1Left2566746622::from(self.tractor_brake_stroke_axle1_left_raw_value() as u64)
    }
}

/// Ambient Conditions
#[allow(dead_code)]
#[derive(Debug)]
pub struct Amb {
    frame_payload: Vec<u8>,
}

impl Amb {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Amb {
        frame_payload.resize(8, 0);
        Amb { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Amb, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419362302);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Amb::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicated temperature of road surface over which vehicle is operating.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn road_surface_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of air entering vehicle air induction system.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn eng_air_inlet_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF)) as u8
    }

    /// Temperature of air surrounding vehicle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn ambient_air_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Temperature of air inside the part of the vehicle that encloses the driver and vehicle operating controls.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn cab_interior_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Absolute air pressure of the atmosphere.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn barometric_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.500000).round() as u8
    }
}

/// Air Start Pressure
#[allow(dead_code)]
#[derive(Debug)]
pub struct Air2 {
    frame_payload: Vec<u8>,
}

impl Air2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Air2 {
        frame_payload.resize(8, 0);
        Air2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Air2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419356414);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Air2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read EngAirStartPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_air_start_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 4.000000).round() as u8
    }
}

/// Air Supply Pressure
#[allow(dead_code)]
#[derive(Debug)]
pub struct Air1 {
    frame_payload: Vec<u8>,
}

impl Air1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Air1 {
        frame_payload.resize(8, 0);
        Air1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Air1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419344126);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Air1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates whether the air compressor is actively compressing air.
    #[allow(dead_code)]
    pub fn air_compressor_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn air_compressor_status(&self) -> AirCompressorStatus2566827774 {
        AirCompressorStatus2566827774::from(self.air_compressor_status_raw_value() as u64)
    }

    /// The pneumatic pressure in the circuit for the electronically controlled air suspension system.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn air_suspension_supply_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// The pneumatic pressure in the auxiliary circuit.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_equipment_supply_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// The pneumatic pressure in the service brake circuit or reservoir #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn service_brake_air_press_circuit2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// The pneumatic pressure in the service brake circuit or reservoir #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn service_brake_air_press_circuit1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// The pneumatic pressure in the circuit or reservoir for the parking brake and/or the trailer supply.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn parking_and_or_trailer_air_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 8.000000).round() as u8
    }

    /// The pneumatic pressure in the main reservoir, sometimes referred to as the wet tank.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn pneumatic_supply_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 8.000000).round() as u8
    }
}

/// Axle Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ai {
    frame_payload: Vec<u8>,
}

impl Ai {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ai {
        frame_payload.resize(8, 0);
        Ai { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ai, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419363326);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ai::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The steering axle lubricant pressure.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn steer_axle_lube_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Temperature of lubricant in steering axle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn steer_axle_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    /// The drive axle lubricant pressure with location determined by Drive Axle Location (SPN 930).
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn drive_axle_lube_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// Temperature of axle lubricant in drive axle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn drive_axle_temp_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF)) as u8
    }

    /// Gage pressure of air in system that utilizes compressed air to provide force between axle and frame.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn drive_axle_lift_air_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 4.000000).round() as u8
    }

    /// To identify to which of several similar devices (such as tires or fuel tanks) the information applies.
    #[allow(dead_code)]
    pub fn drive_axle_location_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }
}

/// Alternate Fuel 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Af2 {
    frame_payload: Vec<u8>,
}

impl Af2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Af2 {
        frame_payload.resize(8, 0);
        Af2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Af2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486451966);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Af2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The position of the turbocharger wastegate valve (not the electronic wastegate control valve).
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_turbo_wastegate_valve_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read EngGsMssFlwSnsrFelingCorrection signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_gs_mss_flw_snsr_feling_correction_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    /// The desired absolute intake manifold pressure of the engine.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_dsired_abs_intake_manifold_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// A correction to a predefined gaseous fuel energy (expressed in energy per unit volume) represented as a percentage.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_gas_fuel_correction_factor_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Adaptive Cruise Control, Operator Input
#[allow(dead_code)]
#[derive(Debug)]
pub struct Acc2 {
    frame_payload: Vec<u8>,
}

impl Acc2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Acc2 {
        frame_payload.resize(8, 0);
        Acc2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Acc2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419320318);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Acc2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The Requested Distance Control Mode to the ACC system from the operators interface.
    #[allow(dead_code)]
    pub fn rqed_acc_distance_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 5) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn rqed_acc_distance_mode(&self) -> RqedAccDistanceMode2566803966 {
        RqedAccDistanceMode2566803966::from(self.rqed_acc_distance_mode_raw_value() as u64)
    }
}

/// Adaptive Cruise Control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Acc1 {
    frame_payload: Vec<u8>,
}

impl Acc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Acc1 {
        frame_payload.resize(8, 0);
        Acc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Acc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(285110270);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Acc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Signal to indicate to the operator that the ACC system is not able to maintain the distance to the target.
    #[allow(dead_code)]
    pub fn acc_distance_alert_signal_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn acc_distance_alert_signal(&self) -> AccDistanceAlertSignal2432593918 {
        AccDistanceAlertSignal2432593918::from(self.acc_distance_alert_signal_raw_value() as u64)
    }

    /// Signal to warn the driver of system deactivation due to non-driver actions.
    #[allow(dead_code)]
    pub fn acc_system_shutoff_warning_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn acc_system_shutoff_warning(&self) -> AccSystemShutoffWarning2432593918 {
        AccSystemShutoffWarning2432593918::from(self.acc_system_shutoff_warning_raw_value() as u64)
    }

    /// Signal to indicate to the driver that the ACC system has detected a target.
    #[allow(dead_code)]
    pub fn acc_target_detected_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn acc_target_detected(&self) -> AccTargetDetected2432593918 {
        AccTargetDetected2432593918::from(self.acc_target_detected_raw_value() as u64)
    }

    /// Estimated value of the current road curvature for use by the adaptive cruise control system.
    /// Unit: 1/km
    #[allow(dead_code)]
    pub fn road_curvature_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.007812).round() as u16
    }

    /// Selected distance mode for adaptive cruise control.
    #[allow(dead_code)]
    pub fn adptve_cruise_ctrl_set_distance_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 27) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn adptve_cruise_ctrl_set_distance_mode(&self) -> AdptveCruiseCtrlSetDistanceMode2432593918 {
        AdptveCruiseCtrlSetDistanceMode2432593918::from(self.adptve_cruise_ctrl_set_distance_mode_raw_value() as u64)
    }

    /// This parameter is used to indicate the current state, or mode, of operation by the Adaptive Cruise Control (ACC) device.
    #[allow(dead_code)]
    pub fn adaptive_cruise_ctrl_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn adaptive_cruise_ctrl_mode(&self) -> AdaptiveCruiseCtrlMode2432593918 {
        AdaptiveCruiseCtrlMode2432593918::from(self.adaptive_cruise_ctrl_mode_raw_value() as u64)
    }

    /// Value of the desired (chosen) velocity of the adaptive cruise control system.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn adaptive_cruise_ctrl_set_speed_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    /// Distance to the preceding vehicle situated within 250 m in the same lane and moving in the same direction.
    /// Unit: m
    #[allow(dead_code)]
    pub fn distance_to_forward_vehicle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Absolute velocity of the preceding vehicle situated within 250 m in the same lane and moving in the same direction.
    /// Unit: km/h
    #[allow(dead_code)]
    pub fn speed_of_forward_vehicle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Articulation Control
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ac {
    frame_payload: Vec<u8>,
}

impl Ac {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ac {
        frame_payload.resize(8, 0);
        Ac { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ac, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486451454);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ac::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Angle of deflection of an articulated transit vehicle.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn articulation_angle_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Auxiliary Analog Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Aai {
    frame_payload: Vec<u8>,
}

impl Aai {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Aai {
        frame_payload.resize(8, 0);
        Aai { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Aai, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486444286);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Aai::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Level measured by a sensor.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn aux_level_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Pressure measured by auxiliary pressure sensor #2.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_press2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 16.000000).round() as u8
    }

    /// Pressure measured by auxiliary pressure sensor #1.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn aux_press1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 16.000000).round() as u8
    }

    /// Temperature measured by auxiliary temperature sensor #2.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aux_temp2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Temperature measured by auxiliary temperature sensor #1.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn aux_temp1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Alternate Fuel 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct A1 {
    frame_payload: Vec<u8>,
}

impl A1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> A1 {
        frame_payload.resize(8, 0);
        A1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<A1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419364350);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| A1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Relative position of the blower bypass valve.
    /// Unit: %
    #[allow(dead_code)]
    pub fn eng_blower_bypass_valve_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Gage pressure of gas supply to fuel metering device.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn eng_gas_supply_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFFFF) as f64 * 0.500000).round() as u16
    }
}

/// Acknowledgment Message
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ackm {
    frame_payload: Vec<u8>,
}

impl Ackm {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ackm {
        frame_payload.resize(8, 0);
        Ackm { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ackm, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(417922814);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ackm::new(frame.data().to_vec())));
        Ok(f)
    }

    /// PGN which is requested by Request2 message
    #[allow(dead_code)]
    pub fn parameter_group_number_raw_value(&self) -> u32 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 40) & 0xFFFFFF)) as u32
    }

    /// Group Function of PGN being acknowledged. This field identifies for a device the specific group function of a PGN being acknowledged or declined.  This field is not used if the PGN being acknowledged or declined is not a group function PGN.
    #[allow(dead_code)]
    pub fn group_function_value_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }
}

/// After Treatment Intermediate Gas 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Atm1 {
    frame_payload: Vec<u8>,
}

impl Atm1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Atm1 {
        frame_payload.resize(8, 0);
        Atm1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Atm1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419279614);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Atm1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read PrtcltTrpIntrmdtGsTmpPrlmnryFMI signal from can frame
    #[allow(dead_code)]
    pub fn prtclt_trp_intrmdt_gs_tmp_prlmnry_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 58) & 0x1F)) as u8
    }

    /// Read PrtcltTrpDltPressPreliminaryFMI signal from can frame
    #[allow(dead_code)]
    pub fn prtclt_trp_dlt_press_preliminary_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 53) & 0x1F)) as u8
    }

    /// Read ExhaustGasTemp2PreliminaryFMI signal from can frame
    #[allow(dead_code)]
    pub fn exhaust_gas_temp2_preliminary_fmi_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x1F)) as u8
    }

    /// Exhaust differential pressure measured between the intake and exhaust of a particulate trap.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn particulate_trap_diff_press_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Temperature of engine combustion byproducts at a mid-point in the particulate trap.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn prtclate_trap_intermediate_gas_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Read ExhaustGasTemp2 signal from can frame
    /// Unit: deg
    #[allow(dead_code)]
    pub fn exhaust_gas_temp2_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.031250).round() as u16
    }
}

/// Door Control 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Dc1 {
    frame_payload: Vec<u8>,
}

impl Dc1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Dc1 {
        frame_payload.resize(8, 0);
        Dc1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Dc1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419319550);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Dc1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Composite indication of all bus door statuses.
    #[allow(dead_code)]
    pub fn status2_of_doors_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn status2_of_doors(&self) -> Status2OfDoors2566803198 {
        Status2OfDoors2566803198::from(self.status2_of_doors_raw_value() as u64)
    }

    /// Signal which indicates the actual position of the ramp / wheel chair lift.
    #[allow(dead_code)]
    pub fn ramp_wheel_chair_lift_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ramp_wheel_chair_lift_pos(&self) -> RampWheelChairLiftPos2566803198 {
        RampWheelChairLiftPos2566803198::from(self.ramp_wheel_chair_lift_pos_raw_value() as u64)
    }

    /// Signal which indicates the actual position of the doors.
    #[allow(dead_code)]
    pub fn pos_of_doors_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn pos_of_doors(&self) -> PosOfDoors2566803198 {
        PosOfDoors2566803198::from(self.pos_of_doors_raw_value() as u64)
    }
}

/// Fifth Wheel Smart Systems 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fwss1 {
    frame_payload: Vec<u8>,
}

impl Fwss1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fwss1 {
        frame_payload.resize(8, 0);
        Fwss1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fwss1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(418386686);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fwss1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates to the vehicle operator that the roll moment has exceeded a preset limit.
    #[allow(dead_code)]
    pub fn fifth_wheel_roll_warning_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fifth_wheel_roll_warning_indicator(&self) -> FifthWheelRollWarningIndicator2565870334 {
        FifthWheelRollWarningIndicator2565870334::from(self.fifth_wheel_roll_warning_indicator_raw_value() as u64)
    }

    /// Fifth wheel roll moment force.
    /// Unit: N
    #[allow(dead_code)]
    pub fn fifth_wheel_roll_moment_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 10.000000).round() as u16
    }

    /// Fifth wheel drawbar force.
    /// Unit: N
    #[allow(dead_code)]
    pub fn fifth_wheel_drawbar_force_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 10.000000).round() as u16
    }

    /// Fifth wheel vertical force.
    /// Unit: N
    #[allow(dead_code)]
    pub fn fifth_wheel_vertical_force_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 5.000000).round() as u16
    }
}

/// Fifth Wheel Smart Systems 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Fwss2 {
    frame_payload: Vec<u8>,
}

impl Fwss2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Fwss2 {
        frame_payload.resize(8, 0);
        Fwss2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Fwss2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419278590);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Fwss2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Indicates to vehicle operator that the fifth wheel slider is in position and locked.
    #[allow(dead_code)]
    pub fn fifth_wheel_slider_lock_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn fifth_wheel_slider_lock_indicator(&self) -> FifthWheelSliderLockIndicator2566762238 {
        FifthWheelSliderLockIndicator2566762238::from(self.fifth_wheel_slider_lock_indicator_raw_value() as u64)
    }

    /// Slider position measurement.
    /// Unit: mm
    #[allow(dead_code)]
    pub fn fifth_wheel_slider_pos_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 10.000000).round() as u8
    }

    /// Indicates results of coupling operation to the vehicle operator.
    #[allow(dead_code)]
    pub fn ffth_whl_lck_couple_status_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ffth_whl_lck_couple_status_indicator(&self) -> FfthWhlLckCoupleStatusIndicator2566762238 {
        FfthWhlLckCoupleStatusIndicator2566762238::from(self.ffth_whl_lck_couple_status_indicator_raw_value() as u64)
    }

    /// Indicates to the vehicle operator that the fifth wheel lock is open and ready to couple.
    #[allow(dead_code)]
    pub fn ffth_whl_lck_rady_to_couple_indicator_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 4) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn ffth_whl_lck_rady_to_couple_indicator(&self) -> FfthWhlLckRadyToCoupleIndicator2566762238 {
        FfthWhlLckRadyToCoupleIndicator2566762238::from(self.ffth_whl_lck_rady_to_couple_indicator_raw_value() as u64)
    }

    /// Fifth wheel error state conveys information when coupling status is incomplete or bad.
    #[allow(dead_code)]
    pub fn fifth_wheel_error_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn fifth_wheel_error_status(&self) -> FifthWheelErrorStatus2566762238 {
        FifthWheelErrorStatus2566762238::from(self.fifth_wheel_error_status_raw_value() as u64)
    }
}

/// Slope Sensor Information
#[allow(dead_code)]
#[derive(Debug)]
pub struct Ssi {
    frame_payload: Vec<u8>,
}

impl Ssi {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Ssi {
        frame_payload.resize(8, 0);
        Ssi { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Ssi, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217060350);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Ssi::new(frame.data().to_vec())));
        Ok(f)
    }

    /// The estimated measurement latency of the measurement.
    /// Unit: ms
    #[allow(dead_code)]
    pub fn roll_and_pitch_measurement_latency_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xFF) as f64 * 0.500000).round() as u8
    }

    /// Compensated mode for the pitch and roll measurements.
    #[allow(dead_code)]
    pub fn pitch_and_roll_compensated_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 54) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pitch_and_roll_compensated(&self) -> PitchAndRollCompensated2364543998 {
        PitchAndRollCompensated2364543998::from(self.pitch_and_roll_compensated_raw_value() as u64)
    }

    /// Figure of merit for the pitch rate measurement.
    #[allow(dead_code)]
    pub fn pitch_rate_figure_of_merit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 52) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pitch_rate_figure_of_merit(&self) -> PitchRateFigureOfMerit2364543998 {
        PitchRateFigureOfMerit2364543998::from(self.pitch_rate_figure_of_merit_raw_value() as u64)
    }

    /// Figure of merit for roll angle measurement.
    #[allow(dead_code)]
    pub fn roll_angle_figure_of_merit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 50) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn roll_angle_figure_of_merit(&self) -> RollAngleFigureOfMerit2364543998 {
        RollAngleFigureOfMerit2364543998::from(self.roll_angle_figure_of_merit_raw_value() as u64)
    }

    /// Figure of merit for pitch angle measurement.
    #[allow(dead_code)]
    pub fn pitch_angle_figure_of_merit_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn pitch_angle_figure_of_merit(&self) -> PitchAngleFigureOfMerit2364543998 {
        PitchAngleFigureOfMerit2364543998::from(self.pitch_angle_figure_of_merit_raw_value() as u64)
    }

    /// Read PitchRate signal from can frame
    /// Unit: deg/sec
    #[allow(dead_code)]
    pub fn pitch_rate_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.002000).round() as u16
    }

    /// The angle between the vehicle y-axis and the ground plane.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn roll_angle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.002000).round() as u16
    }

    /// The angle between the vehicle x-axis and the ground plane.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn pitch_angle_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.002000).round() as u16
    }
}

/// Transmission Fluids 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Trf1 {
    frame_payload: Vec<u8>,
}

impl Trf1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Trf1 {
        frame_payload.resize(8, 0);
        Trf1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Trf1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419363070);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Trf1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read TransOilLevelMeasurementStatus signal from can frame
    #[allow(dead_code)]
    pub fn trans_oil_level_measurement_status_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 60) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_oil_level_measurement_status(&self) -> TransOilLevelMeasurementStatus2566846718 {
        TransOilLevelMeasurementStatus2566846718::from(self.trans_oil_level_measurement_status_raw_value() as u64)
    }

    /// Read TransOilLevelCountdownTimer signal from can frame
    #[allow(dead_code)]
    pub fn trans_oil_level_countdown_timer_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 56) & 0xF)) as u8
    }

    #[allow(dead_code)]
    pub fn trans_oil_level_countdown_timer(&self) -> TransOilLevelCountdownTimer2566846718 {
        TransOilLevelCountdownTimer2566846718::from(self.trans_oil_level_countdown_timer_raw_value() as u64)
    }

    /// Amount of current volume of transmission sump oil compared to recommended volume.
    /// Unit: L
    #[allow(dead_code)]
    pub fn trans_oil_level_high_low_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFF) as f64 * 0.500000).round() as u8
    }

    /// Temperature of the transmission lubricant.
    /// Unit: deg
    #[allow(dead_code)]
    pub fn trans_oil_temp_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.031250).round() as u16
    }

    /// Gage pressure of lubrication fluid in transmission, measured after pump.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn trans_oil_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 16.000000).round() as u8
    }

    /// Read TransFilterDiffPress signal from can frame
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn trans_filter_diff_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF) as f64 * 2.000000).round() as u8
    }

    /// Ratio of volume of transmission sump oil to recommended volume.
    /// Unit: %
    #[allow(dead_code)]
    pub fn trans_oil_level_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Gage pressure of oil within a wet clutch.
    /// Unit: kPa
    #[allow(dead_code)]
    pub fn clutch_press_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF) as f64 * 16.000000).round() as u8
    }
}

/// Vehicle Electrical Power #1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vep1 {
    frame_payload: Vec<u8>,
}

impl Vep1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vep1 {
        frame_payload.resize(8, 0);
        Vep1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vep1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419362814);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vep1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Electrical potential measured at the input of the electronic control unit supplied through a switching device.
    /// Unit: V
    #[allow(dead_code)]
    pub fn battery_potential_switched_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 48) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Measured electrical potential of the battery.
    /// Unit: V
    #[allow(dead_code)]
    pub fn electrical_potential_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Electrical potential measured at the charging system output.
    /// Unit: V
    #[allow(dead_code)]
    pub fn charging_system_potential_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Measure of electrical current flow from the alternator.
    /// Unit: A
    #[allow(dead_code)]
    pub fn alt_current_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    /// Net flow of electrical current into/out of the battery or batteries.
    /// Unit: A
    #[allow(dead_code)]
    pub fn net_battery_current_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }
}

/// Wireless Communications Message 2
#[allow(dead_code)]
#[derive(Debug)]
pub struct Wcm2 {
    frame_payload: Vec<u8>,
}

impl Wcm2 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Wcm2 {
        frame_payload.resize(8, 0);
        Wcm2 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Wcm2, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419277054);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Wcm2::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read WrlessCommunicationNetworkType2 signal from can frame
    #[allow(dead_code)]
    pub fn wrless_communication_network_type2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn wrless_communication_network_type2(&self) -> WrlessCommunicationNetworkType22566760702 {
        WrlessCommunicationNetworkType22566760702::from(self.wrless_communication_network_type2_raw_value() as u64)
    }

    /// Indicates the signal strength for the wireless communications network type.
    /// Unit: %
    #[allow(dead_code)]
    pub fn network_signal_strength2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read NetworkAntennaStatus2 signal from can frame
    #[allow(dead_code)]
    pub fn network_antenna_status2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn network_antenna_status2(&self) -> NetworkAntennaStatus22566760702 {
        NetworkAntennaStatus22566760702::from(self.network_antenna_status2_raw_value() as u64)
    }

    /// Read NetworkServiceStatus2 signal from can frame
    #[allow(dead_code)]
    pub fn network_service_status2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn network_service_status2(&self) -> NetworkServiceStatus22566760702 {
        NetworkServiceStatus22566760702::from(self.network_service_status2_raw_value() as u64)
    }

    /// Read NetworkTransceiverStatus2 signal from can frame
    #[allow(dead_code)]
    pub fn network_transceiver_status2_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn network_transceiver_status2(&self) -> NetworkTransceiverStatus22566760702 {
        NetworkTransceiverStatus22566760702::from(self.network_transceiver_status2_raw_value() as u64)
    }
}

/// Wireless Communications Message 1
#[allow(dead_code)]
#[derive(Debug)]
pub struct Wcm1 {
    frame_payload: Vec<u8>,
}

impl Wcm1 {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Wcm1 {
        frame_payload.resize(8, 0);
        Wcm1 { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Wcm1, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(419277310);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Wcm1::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read WrlessCommunicationNetworkType1 signal from can frame
    #[allow(dead_code)]
    pub fn wrless_communication_network_type1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn wrless_communication_network_type1(&self) -> WrlessCommunicationNetworkType12566760958 {
        WrlessCommunicationNetworkType12566760958::from(self.wrless_communication_network_type1_raw_value() as u64)
    }

    /// Indicates the signal strength for the wireless communications network type.
    /// Unit: %
    #[allow(dead_code)]
    pub fn network_signal_strength1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 24) & 0xFF) as f64 * 0.400000).round() as u8
    }

    /// Read NetworkAntennaStatus1 signal from can frame
    #[allow(dead_code)]
    pub fn network_antenna_status1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn network_antenna_status1(&self) -> NetworkAntennaStatus12566760958 {
        NetworkAntennaStatus12566760958::from(self.network_antenna_status1_raw_value() as u64)
    }

    /// Read NetworkServiceStatus1 signal from can frame
    #[allow(dead_code)]
    pub fn network_service_status1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn network_service_status1(&self) -> NetworkServiceStatus12566760958 {
        NetworkServiceStatus12566760958::from(self.network_service_status1_raw_value() as u64)
    }

    /// Read NetworkTransceiverStatus1 signal from can frame
    #[allow(dead_code)]
    pub fn network_transceiver_status1_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFF)) as u8
    }

    #[allow(dead_code)]
    pub fn network_transceiver_status1(&self) -> NetworkTransceiverStatus12566760958 {
        NetworkTransceiverStatus12566760958::from(self.network_transceiver_status1_raw_value() as u64)
    }
}

/// Voltage Regulator Operating Mode
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vrom {
    frame_payload: Vec<u8>,
}

impl Vrom {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vrom {
        frame_payload.resize(8, 0);
        Vrom { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vrom, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(486385662);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vrom::new(frame.data().to_vec())));
        Ok(f)
    }

    /// State signal indicating the Voltage regulator enabled.
    #[allow(dead_code)]
    pub fn voltage_regulator_enabled_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 10) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn voltage_regulator_enabled(&self) -> VoltageRegulatorEnabled2633869310 {
        VoltageRegulatorEnabled2633869310::from(self.voltage_regulator_enabled_raw_value() as u64)
    }

    /// State signal indicating the mode of the Voltage regulator soft start function.
    #[allow(dead_code)]
    pub fn voltage_regulator_soft_start_state_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 8) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn voltage_regulator_soft_start_state(&self) -> VoltageRegulatorSoftStartState2633869310 {
        VoltageRegulatorSoftStartState2633869310::from(self.voltage_regulator_soft_start_state_raw_value() as u64)
    }

    /// State signal indicating the operating mode for underfrequency compensation.
    #[allow(dead_code)]
    pub fn vltg_rgltr_undrfrqncy_cmpnstn_enbld_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 6) & 0x3)) as u8
    }

    #[allow(dead_code)]
    pub fn vltg_rgltr_undrfrqncy_cmpnstn_enbld(&self) -> VltgRgltrUndrfrqncyCmpnstnEnbld2633869310 {
        VltgRgltrUndrfrqncyCmpnstnEnbld2633869310::from(self.vltg_rgltr_undrfrqncy_cmpnstn_enbld_raw_value() as u64)
    }

    /// Read VltgRgltrVAr_PwrFctrOprtingMode signal from can frame
    #[allow(dead_code)]
    pub fn vltg_rgltr_v_ar_pwr_fctr_oprting_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 3) & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn vltg_rgltr_v_ar_pwr_fctr_oprting_mode(&self) -> VltgRgltrVArPwrFctrOprtingMode2633869310 {
        VltgRgltrVArPwrFctrOprtingMode2633869310::from(self.vltg_rgltr_v_ar_pwr_fctr_oprting_mode_raw_value() as u64)
    }

    /// State signal indicating the voltage regulator load compensation mode.
    #[allow(dead_code)]
    pub fn vltg_rglator_load_compensation_mode_raw_value(&self) -> u8 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0x7)) as u8
    }

    #[allow(dead_code)]
    pub fn vltg_rglator_load_compensation_mode(&self) -> VltgRglatorLoadCompensationMode2633869310 {
        VltgRglatorLoadCompensationMode2633869310::from(self.vltg_rglator_load_compensation_mode_raw_value() as u64)
    }
}

/// Voltage regulator excitation status
#[allow(dead_code)]
#[derive(Debug)]
pub struct Vrep {
    frame_payload: Vec<u8>,
}

impl Vrep {
    #[allow(dead_code)]
    pub fn new(mut frame_payload: Vec<u8>) -> Vrep {
        frame_payload.resize(8, 0);
        Vrep { frame_payload }
    }

    #[allow(dead_code)]
    pub fn stream(can_interface: &str, ival1: &std::time::Duration, ival2: &std::time::Duration) -> std::io::Result<impl Stream<Item = Result<Vrep, std::io::Error>>> {
        let socket = BCMSocket::open_nb(&can_interface)?;
        let message_id = CANMessageId::EFF(217949950);
        let frame_stream = socket.filter_id_incoming_frames(message_id, ival1.clone(), ival2.clone())?.compat();
        let f = frame_stream.map(|frame| frame.map(|frame| Vrep::new(frame.data().to_vec())));
        Ok(f)
    }

    /// Read GnrtrOtputVoltageBiasPercentage signal from can frame
    /// Unit: %
    #[allow(dead_code)]
    pub fn gnrtr_otput_voltage_bias_percentage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 32) & 0xFFFF) as f64 * 0.100000).round() as u16
    }

    /// Measured signal that represents the generator excitation field current.
    /// Unit: A
    #[allow(dead_code)]
    pub fn generator_excitation_field_current_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        (((frame_payload >> 16) & 0xFFFF) as f64 * 0.050000).round() as u16
    }

    /// Measured signal that represents the generator excitation field voltage.
    /// Unit: V
    #[allow(dead_code)]
    pub fn generator_excitation_field_voltage_raw_value(&self) -> u16 {
        let frame_payload: u64 = LE::read_u64(&self.frame_payload);
        ((frame_payload & 0xFFFF) as f64 * 0.050000).round() as u16
    }
}
