diff --git a/.editorconfig b/.editorconfig index e8b218d..c7ba7f0 100644 --- a/.editorconfig +++ b/.editorconfig @@ -7,9 +7,9 @@ charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true -[*.md] -trim_trailing_whitespace = false - -[*.yml] -indent_style = space +[*.{yml,yaml}] indent_size = 2 + +[tests-snapshots*/**] +trim_trailing_whitespace = unset +insert_final_newline = unset diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ac2e2de..2611966 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -33,6 +33,7 @@ jobs: steps: - name: Checkout repository uses: actions/checkout@v6 + with: { submodules: 'recursive' } - name: Cache cargo registry uses: actions/cache@v5 diff --git a/.gitignore b/.gitignore index 25a0453..1f45b29 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +**/*.bak **/*.rs.bk *.pdb .envrc @@ -8,6 +9,8 @@ target/ temp/ tmp/ venv/ +tests-snapshots/opendbc/**/*.snap +tests-snapshots/opendbc/**/*.rs # FIXME: This is a library, we may consider removing the lock file #Cargo.lock diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..cfff995 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "tests/fixtures/shared-test-files"] + path = tests/fixtures/shared-test-files + url = https://github.com/oxibus/shared-test-files +[submodule "tests/fixtures/opendbc"] + path = tests/fixtures/opendbc + url = https://github.com/commaai/opendbc.git diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 6cb4eb6..59baf82 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,6 +3,7 @@ exclude: | (?x)^( .+\.(dbc|DBC) + | (.*/)?tests-snapshots.*/.* )$ repos: diff --git a/Cargo.lock b/Cargo.lock index 84f5fa5..02535aa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -47,7 +47,7 @@ version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a64c907d4e79225ac72e2a354c9ce84d50ebb4586dee56c82b3ee73004f537f5" dependencies = [ - "windows-sys", + "windows-sys 0.52.0", ] [[package]] @@ -57,7 +57,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19" dependencies = [ "anstyle", - "windows-sys", + "windows-sys 0.52.0", ] [[package]] @@ -279,6 +279,18 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422" +[[package]] +name = "console" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" +dependencies = [ + "encode_unicode", + "libc", + "once_cell", + "windows-sys 0.59.0", +] + [[package]] name = "cpufeatures" version = "0.2.17" @@ -303,10 +315,15 @@ name = "dbc-codegen" version = "0.3.0" dependencies = [ "anyhow", + "bitvec", "can-dbc", "embedded-can", "heck", + "insta", + "test_each_file", + "trybuild", "typed-builder", + "walkdir", ] [[package]] @@ -376,6 +393,12 @@ dependencies = [ "nb", ] +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + [[package]] name = "encoding_rs" version = "0.8.35" @@ -385,12 +408,34 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.59.0", +] + [[package]] name = "exitcode" version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "de853764b47027c2e862a995c34978ffa63c1501f2e15f987ba11bd4f9bba193" +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + [[package]] name = "find-msvc-tools" version = "0.1.6" @@ -413,18 +458,58 @@ dependencies = [ "version_check", ] +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", +] + [[package]] name = "glob" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" + [[package]] name = "heck" version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "indexmap" +version = "2.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "insta" +version = "1.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b66886d14d18d420ab5052cbff544fc5d34d0b2cdd35eb5976aaa10a4a472e5" +dependencies = [ + "console", + "once_cell", + "similar", + "tempfile", +] + [[package]] name = "is_terminal_polyfill" version = "1.70.0" @@ -440,6 +525,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" + [[package]] name = "libc" version = "0.2.177" @@ -456,6 +547,12 @@ dependencies = [ "windows-targets", ] +[[package]] +name = "linux-raw-sys" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + [[package]] name = "log" version = "0.4.21" @@ -499,6 +596,12 @@ dependencies = [ "autocfg", ] +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + [[package]] name = "pest" version = "2.8.3" @@ -592,6 +695,12 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + [[package]] name = "radium" version = "0.7.0" @@ -642,26 +751,80 @@ version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" +[[package]] +name = "rustix" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +dependencies = [ + "bitflags 2.5.0", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.59.0", +] + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + [[package]] name = "serde" -version = "1.0.210" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.210" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", "syn", ] +[[package]] +name = "serde_json" +version = "1.0.149" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_spanned" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776" +dependencies = [ + "serde_core", +] + [[package]] name = "sha2" version = "0.10.9" @@ -679,6 +842,12 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "similar" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" + [[package]] name = "strsim" version = "0.11.1" @@ -702,6 +871,46 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" +[[package]] +name = "target-triple" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b" + +[[package]] +name = "tempfile" +version = "3.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c" +dependencies = [ + "fastrand", + "getrandom", + "once_cell", + "rustix", + "windows-sys 0.59.0", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "test_each_file" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2de773517ee4367314c7918f6c9ef69c201ba72bfdbffb00234c22c50a153b73" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "unicode-ident", +] + [[package]] name = "thiserror" version = "2.0.17" @@ -722,6 +931,60 @@ dependencies = [ "syn", ] +[[package]] +name = "toml" +version = "0.9.10+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0825052159284a1a8b4d6c0c86cbc801f2da5afd2b225fa548c72f2e74002f48" +dependencies = [ + "indexmap", + "serde_core", + "serde_spanned", + "toml_datetime", + "toml_parser", + "toml_writer", + "winnow", +] + +[[package]] +name = "toml_datetime" +version = "0.7.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_parser" +version = "1.0.6+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44" +dependencies = [ + "winnow", +] + +[[package]] +name = "toml_writer" +version = "1.0.6+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607" + +[[package]] +name = "trybuild" +version = "1.0.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335" +dependencies = [ + "glob", + "serde", + "serde_derive", + "serde_json", + "target-triple", + "termcolor", + "toml", +] + [[package]] name = "typed-builder" version = "0.23.2" @@ -772,6 +1035,34 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasip2" +version = "1.0.1+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.59.0", +] + [[package]] name = "windows-sys" version = "0.52.0" @@ -781,11 +1072,20 @@ dependencies = [ "windows-targets", ] +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + [[package]] name = "windows-targets" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ "windows_aarch64_gnullvm", "windows_aarch64_msvc", @@ -799,51 +1099,63 @@ dependencies = [ [[package]] name = "windows_aarch64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_i686_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_x86_64_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winnow" +version = "0.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" + +[[package]] +name = "wit-bindgen" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" [[package]] name = "wyz" @@ -853,3 +1165,9 @@ checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" dependencies = [ "tap", ] + +[[package]] +name = "zmij" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fc5a66a20078bf1251bde995aa2fdcc4b800c70b5d92dd2c62abc5c60f679f8" diff --git a/Cargo.toml b/Cargo.toml index 5fed55c..c7d1217 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,12 @@ authors = [ "Andres Vahter ", ] edition = "2021" +exclude = [ + "fuzz/*", + "testing/*", + "tests/*", + "tests-snapshots/*", +] license = "MIT OR Apache-2.0" repository = "https://github.com/oxibus/dbc-codegen" rust-version = "1.81.0" @@ -22,6 +28,13 @@ embedded-can = "0.4.1" heck = "0.5.0" typed-builder = "0.23.2" +[dev-dependencies] +bitvec = "1.0.1" +insta = "1.46.0" +test_each_file = "0.3.6" +trybuild = "1.0.114" +walkdir = "2.5.0" + [workspace] members = [ ".", diff --git a/justfile b/justfile index ab9d212..4178020 100755 --- a/justfile +++ b/justfile @@ -18,13 +18,21 @@ export RUST_BACKTRACE := env('RUST_BACKTRACE', if ci_mode == '1' {'1'} else {'0' @_default: {{just}} --list -# Run integration tests and save its output as the new expected output -bless *args: (cargo-install 'cargo-insta') - cargo insta test --accept --unreferenced=delete --all-features {{args}} +# Run all tests and save its output as the new expected output. +bless: bless-generate bless-compile -bless-all: (cargo-install 'cargo-insta') - rm -rf tests/snapshots - FORCE_INSTA=1 {{just}} bless +# Run code generation tests and save its output as the new expected output +bless-generate: (cargo-install 'cargo-insta') + cargo insta test --accept --include-ignored --unreferenced=delete --all-features -- --skip compile_test + +# Compile generated code tests and save its output as the new expected output +bless-compile: + TRYBUILD=overwrite cargo test --all-features -- --test compile_test + +# Generate all snapshots, including forced (.gitignore-d) ones +bless-generate-all: + rm -rf tests-snapshots + FORCE_INSTA=1 {{just}} bless-generate # Build the project build: @@ -38,7 +46,7 @@ build-diagram: # Quick compile without building a binary check: cargo check --workspace --all-features --all-targets - cargo check --all-targets --no-default-features --workspace + cargo check --workspace --no-default-features --all-targets # Generate code coverage report to upload to codecov.io ci-coverage: env-info && \ @@ -50,7 +58,12 @@ ci-coverage: env-info && \ ci-test: env-info test-fmt check clippy test test-doc deny && assert-git-is-clean # Run minimal subset of tests to ensure compatibility with MSRV -ci-test-msrv: env-info check test +ci-test-msrv: + if [ ! -f Cargo.lock.bak ]; then mv Cargo.lock Cargo.lock.bak ; fi + cp Cargo.lock.msrv Cargo.lock + {{just}} env-info check test + rm Cargo.lock + mv Cargo.lock.bak Cargo.lock # Clean all build artifacts clean: @@ -105,7 +118,19 @@ get-msrv package=main_crate: (get-crate-field 'rust_version' package) # Find the minimum supported Rust version (MSRV) using cargo-msrv extension, and update Cargo.toml msrv: (cargo-install 'cargo-msrv') - cargo msrv find --write-msrv --ignore-lockfile --all-features + cargo msrv find --write-msrv --all-features -- {{just}} ci-test-msrv + +# Initialize Cargo.lock file with minimal versions of dependencies. +msrv-init: (cargo-install 'cargo-minimal-versions') + rm -f Cargo.lock.msrv Cargo.lock + @if ! cargo minimal-versions check --workspace ; then \ + echo "ERROR: Could not generate minimal Cargo.lock.msrv" ;\ + echo " fix the lock file with 'cargo update ... --precise ...'" ;\ + echo " make sure it passes 'just check' " ;\ + echo " once done, rename Cargo.lock to Cargo.lock.msrv" ;\ + exit 1 ;\ + fi + mv Cargo.lock Cargo.lock.msrv # Run cargo-release release *args='': (cargo-install 'release-plz') @@ -120,6 +145,10 @@ test: cargo test --workspace --all-features --all-targets cargo test --doc --workspace --all-features +# Run all tests with insta forced mode - generating ignored snapshots +test-all: + FORCE_INSTA=1 {{just}} test + # Test documentation generation test-doc: (docs '') diff --git a/src/lib.rs b/src/lib.rs index 3fb81d7..97db8f1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -417,8 +417,8 @@ fn render_message(mut w: impl Write, config: &Config<'_>, msg: &Message, dbc: &D if *message_id != msg.id { return None; } - let signal = dbc.signal_by_name(*message_id, name).unwrap(); - Some((signal, value_descriptions)) + dbc.signal_by_name(*message_id, name) + .map(|v| (v, value_descriptions)) } else { None } diff --git a/tests-snapshots/canpy/DBC_template.snap b/tests-snapshots/canpy/DBC_template.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/canpy/DBC_template.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/canpy/DBC_template.snap.rs b/tests-snapshots/canpy/DBC_template.snap.rs new file mode 100644 index 0000000..62d4ddc --- /dev/null +++ b/tests-snapshots/canpy/DBC_template.snap.rs @@ -0,0 +1,639 @@ +// Generated code! +// +// Message definitions from file `DBC_template` +// Version: 1.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// CANMultiplexed + CanMultiplexed(CanMultiplexed), + /// CANMessage + CanMessage(CanMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + CanMultiplexed::MESSAGE_ID => Messages::CanMultiplexed(CanMultiplexed::try_from(payload)?), + CanMessage::MESSAGE_ID => Messages::CanMessage(CanMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// CANMultiplexed +/// +/// - Extended ID: 4321 (0x10e1) +/// - Size: 2 bytes +/// - Transmitter: Node0 +/// +/// Multiplexed CAN-Message +#[derive(Clone, Copy)] +pub struct CanMultiplexed { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CanMultiplexed { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x10e1)}); + + pub const VALUE1_MIN: u8 = 0_u8; + pub const VALUE1_MAX: u8 = 0_u8; + pub const VALUE0_MIN: u8 = 0_u8; + pub const VALUE0_MAX: u8 = 0_u8; + pub const MULTIPLEXER_MIN: u8 = 0_u8; + pub const MULTIPLEXER_MAX: u8 = 0_u8; + + /// Construct new CANMultiplexed from values + pub fn new(multiplexer: u8) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_multiplexer(multiplexer)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Get raw value of Multiplexer + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexer_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexer(&mut self) -> Result { + match self.multiplexer_raw() { + 0 => Ok(CanMultiplexedMultiplexerIndex::M0(CanMultiplexedMultiplexerM0{ raw: self.raw })), + 1 => Ok(CanMultiplexedMultiplexerIndex::M1(CanMultiplexedMultiplexerM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: CanMultiplexed::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexer + #[inline(always)] + fn set_multiplexer(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanMultiplexed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanMultiplexed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexer + #[inline(always)] + pub fn set_m0(&mut self, value: CanMultiplexedMultiplexerM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexer(0)?; + Ok(()) + } + + /// Set value of Multiplexer + #[inline(always)] + pub fn set_m1(&mut self, value: CanMultiplexedMultiplexerM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexer(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CanMultiplexed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CanMultiplexed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Value1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum CanMultiplexedValue1 { + Three, + Two, + One, + Zero, + _Other(u8), +} + +impl From for u8 { + fn from(val: CanMultiplexedValue1) -> u8 { + match val { + CanMultiplexedValue1::Three => 3, + CanMultiplexedValue1::Two => 2, + CanMultiplexedValue1::One => 1, + CanMultiplexedValue1::Zero => 0, + CanMultiplexedValue1::_Other(x) => x, + } + } +} + +/// Defined values for Value0 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum CanMultiplexedValue0 { + Value2, + Value1, + Value0, + _Other(u8), +} + +impl From for u8 { + fn from(val: CanMultiplexedValue0) -> u8 { + match val { + CanMultiplexedValue0::Value2 => 2, + CanMultiplexedValue0::Value1 => 1, + CanMultiplexedValue0::Value0 => 0, + CanMultiplexedValue0::_Other(x) => x, + } + } +} + +/// Defined values for multiplexed signal CANMultiplexed +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum CanMultiplexedMultiplexerIndex { + M0(CanMultiplexedMultiplexerM0), + M1(CanMultiplexedMultiplexerM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct CanMultiplexedMultiplexerM0 { raw: [u8; 2] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CanMultiplexedMultiplexerM0 { +pub fn new() -> Self { Self { raw: [0u8; 2] } } +/// Value0 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Node0 +#[inline(always)] +pub fn value0(&self) -> CanMultiplexedValue0 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 2 => CanMultiplexedValue0::Value2, + 1 => CanMultiplexedValue0::Value1, + 0 => CanMultiplexedValue0::Value0, + _ => CanMultiplexedValue0::_Other(self.value0_raw()), + } +} + +/// Get raw value of Value0 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn value0_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Value0 +#[inline(always)] +pub fn set_value0(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanMultiplexed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanMultiplexed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct CanMultiplexedMultiplexerM1 { raw: [u8; 2] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CanMultiplexedMultiplexerM1 { +pub fn new() -> Self { Self { raw: [0u8; 2] } } +/// Value1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Node1 +#[inline(always)] +pub fn value1(&self) -> CanMultiplexedValue1 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 3 => CanMultiplexedValue1::Three, + 2 => CanMultiplexedValue1::Two, + 1 => CanMultiplexedValue1::One, + 0 => CanMultiplexedValue1::Zero, + _ => CanMultiplexedValue1::_Other(self.value1_raw()), + } +} + +/// Get raw value of Value1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn value1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Value1 +#[inline(always)] +pub fn set_value1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanMultiplexed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanMultiplexed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + +/// CANMessage +/// +/// - Standard ID: 1234 (0x4d2) +/// - Size: 8 bytes +/// - Transmitter: Node0 +#[derive(Clone, Copy)] +pub struct CanMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CanMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4d2)}); + + pub const SIGNAL1_MIN: u64 = 0_u64; + pub const SIGNAL1_MAX: u64 = 100_u64; + pub const SIGNAL0_MIN: i32 = 0_i32; + pub const SIGNAL0_MAX: i32 = 0_i32; + + /// Construct new CANMessage from values + pub fn new(signal1: u64, signal0: i32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal1(signal1)?; + res.set_signal0(signal0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "%" + /// - Receivers: Node1, Node2 + #[inline(always)] + pub fn signal1(&self) -> u64 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 100 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal1_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 100; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 100_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanMessage::MESSAGE_ID }); + } + let factor = 100; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanMessage::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Signal0 + /// + /// First signal in this message + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Node1, Node2 + #[inline(always)] + pub fn signal0(&self) -> i32 { + self.signal0_raw() + } + + /// Get raw value of Signal0 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal0_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal0 + #[inline(always)] + pub fn set_signal0(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanMessage::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CanMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CanMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/!error___bad_message_length.snap b/tests-snapshots/dbc-cantools/!error___bad_message_length.snap new file mode 100644 index 0000000..b35ad7f --- /dev/null +++ b/tests-snapshots/dbc-cantools/!error___bad_message_length.snap @@ -0,0 +1,4 @@ +--- +source: tests/snapshots.rs +--- +"could not generate Rust code" diff --git a/tests-snapshots/dbc-cantools/BU_BO_REL_.snap b/tests-snapshots/dbc-cantools/BU_BO_REL_.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/BU_BO_REL_.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/BU_BO_REL_.snap.rs b/tests-snapshots/dbc-cantools/BU_BO_REL_.snap.rs new file mode 100644 index 0000000..6206dc3 --- /dev/null +++ b/tests-snapshots/dbc-cantools/BU_BO_REL_.snap.rs @@ -0,0 +1,241 @@ +// Generated code! +// +// Message definitions from file `BU_BO_REL_` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// CONTROL + Control(Control), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Control::MESSAGE_ID => Messages::Control(Control::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// CONTROL +/// +/// - Standard ID: 1 (0x1) +/// - Size: 7 bytes +/// - Transmitter: COM +#[derive(Clone, Copy)] +pub struct Control { + raw: [u8; 7], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Control { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const STATE_MIN: u8 = 0_u8; + pub const STATE_MAX: u8 = 100_u8; + + /// Construct new CONTROL from values + pub fn new(state: u8) -> Result { + let mut res = Self { raw: [0u8; 7] }; + res.set_state(state)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 7] { + &self.raw + } + + /// state + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "%" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn state(&self) -> ControlState { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 255 => ControlState::Invalid, + _ => ControlState::_Other(self.state_raw()), + } + } + + /// Get raw value of state + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn state_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of state + #[inline(always)] + pub fn set_state(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 100_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Control::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Control::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Control { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 7 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 7]; + raw.copy_from_slice(&payload[..7]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Control { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for state +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ControlState { + Invalid, + _Other(u8), +} + +impl From for u8 { + fn from(val: ControlState) -> u8 { + match val { + ControlState::Invalid => 255, + ControlState::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/BU_BO_REL_Message.snap b/tests-snapshots/dbc-cantools/BU_BO_REL_Message.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/BU_BO_REL_Message.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/BU_BO_REL_Message.snap.rs b/tests-snapshots/dbc-cantools/BU_BO_REL_Message.snap.rs new file mode 100644 index 0000000..2eec524 --- /dev/null +++ b/tests-snapshots/dbc-cantools/BU_BO_REL_Message.snap.rs @@ -0,0 +1,241 @@ +// Generated code! +// +// Message definitions from file `BU_BO_REL_Message` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// message_1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// message_1 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 7 bytes +/// - Transmitter: ECU1 +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 7], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const SIGNAL_1_MIN: u8 = 0_u8; + pub const SIGNAL_1_MAX: u8 = 100_u8; + + /// Construct new message_1 from values + pub fn new(signal_1: u8) -> Result { + let mut res = Self { raw: [0u8; 7] }; + res.set_signal_1(signal_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 7] { + &self.raw + } + + /// signal_1 + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "" + /// - Receivers: ECU2 + #[inline(always)] + pub fn signal_1(&self) -> Message1Signal1 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 255 => Message1Signal1::Invalid, + _ => Message1Signal1::_Other(self.signal_1_raw()), + } + } + + /// Get raw value of signal_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal_1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of signal_1 + #[inline(always)] + pub fn set_signal_1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 100_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 7 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 7]; + raw.copy_from_slice(&payload[..7]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for signal_1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message1Signal1 { + Invalid, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message1Signal1) -> u8 { + match val { + Message1Signal1::Invalid => 255, + Message1Signal1::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/CamelCaseEmpty.snap b/tests-snapshots/dbc-cantools/CamelCaseEmpty.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/CamelCaseEmpty.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/CamelCaseEmpty.snap.rs b/tests-snapshots/dbc-cantools/CamelCaseEmpty.snap.rs new file mode 100644 index 0000000..4ddaa5e --- /dev/null +++ b/tests-snapshots/dbc-cantools/CamelCaseEmpty.snap.rs @@ -0,0 +1,166 @@ +// Generated code! +// +// Message definitions from file `CamelCaseEmpty` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Standard ID: 1024 (0x400) +/// - Size: 5 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x400)}); + + + /// Construct new Message1 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 5] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/abs.snap b/tests-snapshots/dbc-cantools/abs.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/abs.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/abs.snap.rs b/tests-snapshots/dbc-cantools/abs.snap.rs new file mode 100644 index 0000000..c99d08b --- /dev/null +++ b/tests-snapshots/dbc-cantools/abs.snap.rs @@ -0,0 +1,6122 @@ +// Generated code! +// +// Message definitions from file `abs` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// BREMSE_33 + Bremse33(Bremse33), + /// BREMSE_10 + Bremse10(Bremse10), + /// BREMSE_11 + Bremse11(Bremse11), + /// BREMSE_12 + Bremse12(Bremse12), + /// BREMSE_13 + Bremse13(Bremse13), + /// DRS_RX_ID0 + DrsRxId0(DrsRxId0), + /// MM5_10_TX1 + Mm510Tx1(Mm510Tx1), + /// MM5_10_TX2 + Mm510Tx2(Mm510Tx2), + /// MM5_10_TX3 + Mm510Tx3(Mm510Tx3), + /// BREMSE_2 + Bremse2(Bremse2), + /// ABS_Switch + AbsSwitch(AbsSwitch), + /// BREMSE_30 + Bremse30(Bremse30), + /// BREMSE_31 + Bremse31(Bremse31), + /// BREMSE_32 + Bremse32(Bremse32), + /// BREMSE_51 + Bremse51(Bremse51), + /// BREMSE_52 + Bremse52(Bremse52), + /// BREMSE_50 + Bremse50(Bremse50), + /// BREMSE_53 + Bremse53(Bremse53), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Bremse33::MESSAGE_ID => Messages::Bremse33(Bremse33::try_from(payload)?), + Bremse10::MESSAGE_ID => Messages::Bremse10(Bremse10::try_from(payload)?), + Bremse11::MESSAGE_ID => Messages::Bremse11(Bremse11::try_from(payload)?), + Bremse12::MESSAGE_ID => Messages::Bremse12(Bremse12::try_from(payload)?), + Bremse13::MESSAGE_ID => Messages::Bremse13(Bremse13::try_from(payload)?), + DrsRxId0::MESSAGE_ID => Messages::DrsRxId0(DrsRxId0::try_from(payload)?), + Mm510Tx1::MESSAGE_ID => Messages::Mm510Tx1(Mm510Tx1::try_from(payload)?), + Mm510Tx2::MESSAGE_ID => Messages::Mm510Tx2(Mm510Tx2::try_from(payload)?), + Mm510Tx3::MESSAGE_ID => Messages::Mm510Tx3(Mm510Tx3::try_from(payload)?), + Bremse2::MESSAGE_ID => Messages::Bremse2(Bremse2::try_from(payload)?), + AbsSwitch::MESSAGE_ID => Messages::AbsSwitch(AbsSwitch::try_from(payload)?), + Bremse30::MESSAGE_ID => Messages::Bremse30(Bremse30::try_from(payload)?), + Bremse31::MESSAGE_ID => Messages::Bremse31(Bremse31::try_from(payload)?), + Bremse32::MESSAGE_ID => Messages::Bremse32(Bremse32::try_from(payload)?), + Bremse51::MESSAGE_ID => Messages::Bremse51(Bremse51::try_from(payload)?), + Bremse52::MESSAGE_ID => Messages::Bremse52(Bremse52::try_from(payload)?), + Bremse50::MESSAGE_ID => Messages::Bremse50(Bremse50::try_from(payload)?), + Bremse53::MESSAGE_ID => Messages::Bremse53(Bremse53::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// BREMSE_33 +/// +/// - Standard ID: 835 (0x343) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse33 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse33 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x343)}); + + pub const WHLSPEED_FL_MIN: f32 = 0_f32; + pub const WHLSPEED_FL_MAX: f32 = 100_f32; + pub const WHLSPEED_FR_MIN: f32 = 0_f32; + pub const WHLSPEED_FR_MAX: f32 = 100_f32; + pub const WHLSPEED_RL_MIN: f32 = 0_f32; + pub const WHLSPEED_RL_MAX: f32 = 100_f32; + pub const WHLSPEED_RR_MIN: f32 = 0_f32; + pub const WHLSPEED_RR_MAX: f32 = 100_f32; + + /// Construct new BREMSE_33 from values + pub fn new(whlspeed_fl: f32, whlspeed_fr: f32, whlspeed_rl: f32, whlspeed_rr: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_whlspeed_fl(whlspeed_fl)?; + res.set_whlspeed_fr(whlspeed_fr)?; + res.set_whlspeed_rl(whlspeed_rl)?; + res.set_whlspeed_rr(whlspeed_rr)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// whlspeed_FL + /// + /// Radgeschwindigkeit / wheel speed absCtrl FL + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_fl(&self) -> f32 { + self.whlspeed_fl_raw() + } + + /// Get raw value of whlspeed_FL + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_fl_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_FL + #[inline(always)] + pub fn set_whlspeed_fl(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse33::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + + /// whlspeed_FR + /// + /// Radgeschwindigkeit / wheel speed absCtrl FR + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_fr(&self) -> f32 { + self.whlspeed_fr_raw() + } + + /// Get raw value of whlspeed_FR + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_fr_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_FR + #[inline(always)] + pub fn set_whlspeed_fr(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse33::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// whlspeed_RL + /// + /// Radgeschwindigkeit / wheel speed absCtrl RL + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_rl(&self) -> f32 { + self.whlspeed_rl_raw() + } + + /// Get raw value of whlspeed_RL + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_rl_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_RL + #[inline(always)] + pub fn set_whlspeed_rl(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse33::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// whlspeed_RR + /// + /// Radgeschwindigkeit / wheel speed absCtrl RR + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_rr(&self) -> f32 { + self.whlspeed_rr_raw() + } + + /// Get raw value of whlspeed_RR + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_rr_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_RR + #[inline(always)] + pub fn set_whlspeed_rr(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse33::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse33 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse33 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_10 +/// +/// - Standard ID: 320 (0x140) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse10 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse10 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x140)}); + + + /// Construct new BREMSE_10 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse10 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse10 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_11 +/// +/// - Standard ID: 321 (0x141) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse11 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse11 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x141)}); + + + /// Construct new BREMSE_11 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse11 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse11 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_12 +/// +/// - Standard ID: 322 (0x142) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse12 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse12 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x142)}); + + + /// Construct new BREMSE_12 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse12 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse12 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_13 +/// +/// - Standard ID: 323 (0x143) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse13 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse13 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x143)}); + + + /// Construct new BREMSE_13 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse13 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse13 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// DRS_RX_ID0 +/// +/// - Standard ID: 117 (0x75) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct DrsRxId0 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DrsRxId0 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x75)}); + + + /// Construct new DRS_RX_ID0 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for DrsRxId0 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DrsRxId0 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MM5_10_TX1 +/// +/// - Standard ID: 112 (0x70) +/// - Size: 8 bytes +/// - Transmitter: DRS_MM5_10 +#[derive(Clone, Copy)] +pub struct Mm510Tx1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Mm510Tx1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x70)}); + + pub const YAW_RATE_MIN: f32 = -163.84_f32; + pub const YAW_RATE_MAX: f32 = 163.83_f32; + pub const AY1_MIN: f32 = -4.1768_f32; + pub const AY1_MAX: f32 = 4.1765_f32; + + /// Construct new MM5_10_TX1 from values + pub fn new(yaw_rate: f32, ay1: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_yaw_rate(yaw_rate)?; + res.set_ay1(ay1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Yaw_Rate + /// + /// Measured yaw rate around the Z axle. + /// + /// - Min: -163.84 + /// - Max: 163.83 + /// - Unit: "°/s" + /// - Receivers: ABS + #[inline(always)] + pub fn yaw_rate(&self) -> f32 { + self.yaw_rate_raw() + } + + /// Get raw value of Yaw_Rate + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.005 + /// - Offset: -163.84 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn yaw_rate_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.005_f32; + let offset = -163.84_f32; + (signal as f32) * factor + offset + } + + /// Set value of Yaw_Rate + #[inline(always)] + pub fn set_yaw_rate(&mut self, value: f32) -> Result<(), CanError> { + if value < -163.84_f32 || 163.83_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm510Tx1::MESSAGE_ID }); + } + let factor = 0.005_f32; + let offset = -163.84_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + + /// AY1 + /// + /// Measured lateral acceleration. + /// + /// - Min: -4.1768 + /// - Max: 4.1765 + /// - Unit: "g" + /// - Receivers: ABS + #[inline(always)] + pub fn ay1(&self) -> f32 { + self.ay1_raw() + } + + /// Get raw value of AY1 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.000127465 + /// - Offset: -4.1768 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ay1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.000127465_f32; + let offset = -4.1768_f32; + (signal as f32) * factor + offset + } + + /// Set value of AY1 + #[inline(always)] + pub fn set_ay1(&mut self, value: f32) -> Result<(), CanError> { + if value < -4.1768_f32 || 4.1765_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm510Tx1::MESSAGE_ID }); + } + let factor = 0.000127465_f32; + let offset = -4.1768_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Mm510Tx1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Mm510Tx1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MM5_10_TX2 +/// +/// - Standard ID: 128 (0x80) +/// - Size: 8 bytes +/// - Transmitter: DRS_MM5_10 +#[derive(Clone, Copy)] +pub struct Mm510Tx2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Mm510Tx2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x80)}); + + pub const ROLL_RATE_MIN: f32 = -163.84_f32; + pub const ROLL_RATE_MAX: f32 = 163.835_f32; + pub const AX1_MIN: f32 = -4.1768_f32; + pub const AX1_MAX: f32 = 4.1765_f32; + + /// Construct new MM5_10_TX2 from values + pub fn new(roll_rate: f32, ax1: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_roll_rate(roll_rate)?; + res.set_ax1(ax1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Roll_Rate + /// + /// Measured roll rate around the X axle. + /// + /// - Min: -163.84 + /// - Max: 163.835 + /// - Unit: "°/s" + /// - Receivers: ABS + #[inline(always)] + pub fn roll_rate(&self) -> f32 { + self.roll_rate_raw() + } + + /// Get raw value of Roll_Rate + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.005 + /// - Offset: -163.84 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn roll_rate_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.005_f32; + let offset = -163.84_f32; + (signal as f32) * factor + offset + } + + /// Set value of Roll_Rate + #[inline(always)] + pub fn set_roll_rate(&mut self, value: f32) -> Result<(), CanError> { + if value < -163.84_f32 || 163.835_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm510Tx2::MESSAGE_ID }); + } + let factor = 0.005_f32; + let offset = -163.84_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + + /// AX1 + /// + /// Measured longitudional acceleration. + /// + /// - Min: -4.1768 + /// - Max: 4.1765 + /// - Unit: "g" + /// - Receivers: ABS + #[inline(always)] + pub fn ax1(&self) -> f32 { + self.ax1_raw() + } + + /// Get raw value of AX1 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.000127465 + /// - Offset: -4.1768 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ax1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.000127465_f32; + let offset = -4.1768_f32; + (signal as f32) * factor + offset + } + + /// Set value of AX1 + #[inline(always)] + pub fn set_ax1(&mut self, value: f32) -> Result<(), CanError> { + if value < -4.1768_f32 || 4.1765_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm510Tx2::MESSAGE_ID }); + } + let factor = 0.000127465_f32; + let offset = -4.1768_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Mm510Tx2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Mm510Tx2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MM5_10_TX3 +/// +/// - Standard ID: 1398 (0x576) +/// - Size: 8 bytes +/// - Transmitter: DRS_MM5_10 +#[derive(Clone, Copy)] +pub struct Mm510Tx3 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Mm510Tx3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x576)}); + + pub const AZ_MIN: f32 = -4.1768_f32; + pub const AZ_MAX: f32 = 4.1765_f32; + + /// Construct new MM5_10_TX3 from values + pub fn new(az: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_az(az)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// AZ + /// + /// Measured vertical acceleration. + /// + /// - Min: -4.1768 + /// - Max: 4.1765 + /// - Unit: "g" + /// - Receivers: ABS + #[inline(always)] + pub fn az(&self) -> f32 { + self.az_raw() + } + + /// Get raw value of AZ + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.000127465 + /// - Offset: -4.1768 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn az_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.000127465_f32; + let offset = -4.1768_f32; + (signal as f32) * factor + offset + } + + /// Set value of AZ + #[inline(always)] + pub fn set_az(&mut self, value: f32) -> Result<(), CanError> { + if value < -4.1768_f32 || 4.1765_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm510Tx3::MESSAGE_ID }); + } + let factor = 0.000127465_f32; + let offset = -4.1768_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Mm510Tx3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Mm510Tx3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_2 +/// +/// - Standard ID: 586 (0x24a) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x24a)}); + + pub const WHLSPEED_FL_BREMSE2_MIN: f32 = 0_f32; + pub const WHLSPEED_FL_BREMSE2_MAX: f32 = 100_f32; + pub const WHLSPEED_FR_BREMSE2_MIN: f32 = 0_f32; + pub const WHLSPEED_FR_BREMSE2_MAX: f32 = 100_f32; + pub const WHLSPEED_RL_BREMSE2_MIN: f32 = 0_f32; + pub const WHLSPEED_RL_BREMSE2_MAX: f32 = 100_f32; + pub const WHLSPEED_RR_BREMSE2_MIN: f32 = 0_f32; + pub const WHLSPEED_RR_BREMSE2_MAX: f32 = 100_f32; + + /// Construct new BREMSE_2 from values + pub fn new(whlspeed_fl_bremse2: f32, whlspeed_fr_bremse2: f32, whlspeed_rl_bremse2: f32, whlspeed_rr_bremse2: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_whlspeed_fl_bremse2(whlspeed_fl_bremse2)?; + res.set_whlspeed_fr_bremse2(whlspeed_fr_bremse2)?; + res.set_whlspeed_rl_bremse2(whlspeed_rl_bremse2)?; + res.set_whlspeed_rr_bremse2(whlspeed_rr_bremse2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// whlspeed_FL_Bremse2 + /// + /// Radgeschwindigkeit / wheel speed direct FL + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_fl_bremse2(&self) -> f32 { + self.whlspeed_fl_bremse2_raw() + } + + /// Get raw value of whlspeed_FL_Bremse2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_fl_bremse2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_FL_Bremse2 + #[inline(always)] + pub fn set_whlspeed_fl_bremse2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse2::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + + /// whlspeed_FR_Bremse2 + /// + /// Radgeschwindigkeit / wheel speed direct FR + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_fr_bremse2(&self) -> f32 { + self.whlspeed_fr_bremse2_raw() + } + + /// Get raw value of whlspeed_FR_Bremse2 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_fr_bremse2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_FR_Bremse2 + #[inline(always)] + pub fn set_whlspeed_fr_bremse2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse2::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// whlspeed_RL_Bremse2 + /// + /// Radgeschwindigkeit / wheel speed direct RL + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_rl_bremse2(&self) -> f32 { + self.whlspeed_rl_bremse2_raw() + } + + /// Get raw value of whlspeed_RL_Bremse2 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_rl_bremse2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_RL_Bremse2 + #[inline(always)] + pub fn set_whlspeed_rl_bremse2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse2::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// whlspeed_RR_Bremse2 + /// + /// Radgeschwindigkeit / wheel speed direct RR + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn whlspeed_rr_bremse2(&self) -> f32 { + self.whlspeed_rr_bremse2_raw() + } + + /// Get raw value of whlspeed_RR_Bremse2 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn whlspeed_rr_bremse2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of whlspeed_RR_Bremse2 + #[inline(always)] + pub fn set_whlspeed_rr_bremse2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse2::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// ABS_Switch +/// +/// - Standard ID: 588 (0x24c) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct AbsSwitch { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl AbsSwitch { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x24c)}); + + pub const ABS_SWITCHPOSITION_MIN: u8 = 0_u8; + pub const ABS_SWITCHPOSITION_MAX: u8 = 11_u8; + + /// Construct new ABS_Switch from values + pub fn new(abs_switchposition: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_abs_switchposition(abs_switchposition)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// ABS_Switchposition + /// + /// Channel to send the swich position via CAN to the ABS. + /// + /// - Min: 0 + /// - Max: 11 + /// - Unit: "" + /// - Receivers: ABS + #[inline(always)] + pub fn abs_switchposition(&self) -> u8 { + self.abs_switchposition_raw() + } + + /// Get raw value of ABS_Switchposition + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn abs_switchposition_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ABS_Switchposition + #[inline(always)] + pub fn set_abs_switchposition(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 11_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: AbsSwitch::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: AbsSwitch::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for AbsSwitch { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for AbsSwitch { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_30 +/// +/// - Standard ID: 832 (0x340) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse30 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse30 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x340)}); + + + /// Construct new BREMSE_30 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse30 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse30 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_31 +/// +/// - Standard ID: 833 (0x341) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse31 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse31 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x341)}); + + pub const IDLE_TIME_MIN: u16 = 0_u16; + pub const IDLE_TIME_MAX: u16 = 0_u16; + + /// Construct new BREMSE_31 from values + pub fn new(idle_time: u16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_idle_time(idle_time)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Idle_Time + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "-" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn idle_time(&self) -> u16 { + self.idle_time_raw() + } + + /// Get raw value of Idle_Time + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn idle_time_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Idle_Time + #[inline(always)] + pub fn set_idle_time(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse31::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse31::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse31 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse31 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_32 +/// +/// - Standard ID: 834 (0x342) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse32 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse32 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x342)}); + + pub const ACC_FA_MIN: f32 = 0_f32; + pub const ACC_FA_MAX: f32 = 10_f32; + pub const ACC_RA_MIN: f32 = 0_f32; + pub const ACC_RA_MAX: f32 = 10_f32; + pub const WHEEL_QUALITY_FL_MIN: u8 = 0_u8; + pub const WHEEL_QUALITY_FL_MAX: u8 = 32_u8; + pub const WHEEL_QUALITY_FR_MIN: u8 = 0_u8; + pub const WHEEL_QUALITY_FR_MAX: u8 = 32_u8; + pub const WHEEL_QUALITY_RL_MIN: u8 = 0_u8; + pub const WHEEL_QUALITY_RL_MAX: u8 = 32_u8; + pub const WHEEL_QUALITY_RR_MIN: u8 = 0_u8; + pub const WHEEL_QUALITY_RR_MAX: u8 = 32_u8; + + /// Construct new BREMSE_32 from values + pub fn new(acc_fa: f32, acc_ra: f32, wheel_quality_fl: u8, wheel_quality_fr: u8, wheel_quality_rl: u8, wheel_quality_rr: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_acc_fa(acc_fa)?; + res.set_acc_ra(acc_ra)?; + res.set_wheel_quality_fl(wheel_quality_fl)?; + res.set_wheel_quality_fr(wheel_quality_fr)?; + res.set_wheel_quality_rl(wheel_quality_rl)?; + res.set_wheel_quality_rr(wheel_quality_rr)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// acc_FA + /// + /// Fill level of the fluid reservoir of the front axle. + /// + /// - Min: 0 + /// - Max: 10 + /// - Unit: "cm3" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn acc_fa(&self) -> f32 { + self.acc_fa_raw() + } + + /// Get raw value of acc_FA + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 0.05 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn acc_fa_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 0.05_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of acc_FA + #[inline(always)] + pub fn set_acc_fa(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 10_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID }); + } + let factor = 0.05_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// acc_RA + /// + /// Fill level of the fluid reservoir of the rear axle. + /// + /// - Min: 0 + /// - Max: 10 + /// - Unit: "cm3" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn acc_ra(&self) -> f32 { + self.acc_ra_raw() + } + + /// Get raw value of acc_RA + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 0.05 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn acc_ra_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 0.05_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of acc_RA + #[inline(always)] + pub fn set_acc_ra(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 10_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID }); + } + let factor = 0.05_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// WheelQuality_FL + /// + /// Bit matrix + /// Bit0 ( 1) Signal Reduced Monitored + /// Bit1 ( 2) Reduced Accuracy + /// Bit2 ( 4) Interfered + /// Bit3 ( 8) Suspicious Plausibility + /// Bit4 (16) Suspicious Lost + /// Bit5 (32) Not Initialized + /// Bit6 (64) Invalid Generic + /// Bit7 (128) Invalid Individual + /// + /// - Min: 0 + /// - Max: 32 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn wheel_quality_fl(&self) -> u8 { + self.wheel_quality_fl_raw() + } + + /// Get raw value of WheelQuality_FL + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_quality_fl_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of WheelQuality_FL + #[inline(always)] + pub fn set_wheel_quality_fl(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 32_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// WheelQuality_FR + /// + /// Bit matrix + /// Bit0 ( 1) Signal Reduced Monitored + /// Bit1 ( 2) Reduced Accuracy + /// Bit2 ( 4) Interfered + /// Bit3 ( 8) Suspicious Plausibility + /// Bit4 (16) Suspicious Lost + /// Bit5 (32) Not Initialized + /// Bit6 (64) Invalid Generic + /// Bit7 (128) Invalid Individual + /// + /// - Min: 0 + /// - Max: 32 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn wheel_quality_fr(&self) -> u8 { + self.wheel_quality_fr_raw() + } + + /// Get raw value of WheelQuality_FR + /// + /// - Start bit: 40 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_quality_fr_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of WheelQuality_FR + #[inline(always)] + pub fn set_wheel_quality_fr(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 32_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) + } + + /// WheelQuality_RL + /// + /// Bit matrix + /// Bit0 ( 1) Signal Reduced Monitored + /// Bit1 ( 2) Reduced Accuracy + /// Bit2 ( 4) Interfered + /// Bit3 ( 8) Suspicious Plausibility + /// Bit4 (16) Suspicious Lost + /// Bit5 (32) Not Initialized + /// Bit6 (64) Invalid Generic + /// Bit7 (128) Invalid Individual + /// + /// - Min: 0 + /// - Max: 32 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn wheel_quality_rl(&self) -> u8 { + self.wheel_quality_rl_raw() + } + + /// Get raw value of WheelQuality_RL + /// + /// - Start bit: 48 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_quality_rl_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of WheelQuality_RL + #[inline(always)] + pub fn set_wheel_quality_rl(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 32_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) + } + + /// WheelQuality_RR + /// + /// Bit matrix + /// Bit0 ( 1) Signal Reduced Monitored + /// Bit1 ( 2) Reduced Accuracy + /// Bit2 ( 4) Interfered + /// Bit3 ( 8) Suspicious Plausibility + /// Bit4 (16) Suspicious Lost + /// Bit5 (32) Not Initialized + /// Bit6 (64) Invalid Generic + /// Bit7 (128) Invalid Individual + /// + /// - Min: 0 + /// - Max: 32 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn wheel_quality_rr(&self) -> u8 { + self.wheel_quality_rr_raw() + } + + /// Get raw value of WheelQuality_RR + /// + /// - Start bit: 56 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_quality_rr_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of WheelQuality_RR + #[inline(always)] + pub fn set_wheel_quality_rr(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 32_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse32::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse32 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse32 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_51 +/// +/// - Standard ID: 1345 (0x541) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse51 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse51 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x541)}); + + pub const AX1_ABS_INT_MIN: f32 = -4.1768_f32; + pub const AX1_ABS_INT_MAX: f32 = 4.1736697_f32; + pub const AY1_ABS_INT_MIN: f32 = -4.1768_f32; + pub const AY1_ABS_INT_MAX: f32 = 4.1765_f32; + pub const IF_VARIANT_MIN: u8 = 0_u8; + pub const IF_VARIANT_MAX: u8 = 63_u8; + pub const IF_REVISION_MIN: u8 = 0_u8; + pub const IF_REVISION_MAX: u8 = 63_u8; + pub const IF_CHKSUM_MIN: u8 = 0_u8; + pub const IF_CHKSUM_MAX: u8 = 15_u8; + + /// Construct new BREMSE_51 from values + pub fn new(ax1_abs_int: f32, ay1_abs_int: f32, if_variant: u8, if_revision: u8, if_chksum: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ax1_abs_int(ax1_abs_int)?; + res.set_ay1_abs_int(ay1_abs_int)?; + res.set_if_variant(if_variant)?; + res.set_if_revision(if_revision)?; + res.set_if_chksum(if_chksum)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// AX1_ABS_int + /// + /// Used longitudional acceleration value in the ABS. + /// + /// - Min: -4.1768 + /// - Max: 4.1736697 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ax1_abs_int(&self) -> f32 { + self.ax1_abs_int_raw() + } + + /// Get raw value of AX1_ABS_int + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.00012742 + /// - Offset: -4.1768 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ax1_abs_int_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.00012742_f32; + let offset = -4.1768_f32; + (signal as f32) * factor + offset + } + + /// Set value of AX1_ABS_int + #[inline(always)] + pub fn set_ax1_abs_int(&mut self, value: f32) -> Result<(), CanError> { + if value < -4.1768_f32 || 4.1736697_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID }); + } + let factor = 0.00012742_f32; + let offset = -4.1768_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + + /// AY1_ABS_int + /// + /// Used lateral acceleration value in the ABS. + /// + /// - Min: -4.1768 + /// - Max: 4.1765 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ay1_abs_int(&self) -> f32 { + self.ay1_abs_int_raw() + } + + /// Get raw value of AY1_ABS_int + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.00012742 + /// - Offset: -4.1768 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ay1_abs_int_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.00012742_f32; + let offset = -4.1768_f32; + (signal as f32) * factor + offset + } + + /// Set value of AY1_ABS_int + #[inline(always)] + pub fn set_ay1_abs_int(&mut self, value: f32) -> Result<(), CanError> { + if value < -4.1768_f32 || 4.1765_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID }); + } + let factor = 0.00012742_f32; + let offset = -4.1768_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IF_variant + /// + /// external info to e.g. MS6 which dbc has to be used. This index increments on changes that make the MS6 interface incompatible to the predecessor CAN interface implementation + /// + /// - Min: 0 + /// - Max: 63 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn if_variant(&self) -> u8 { + self.if_variant_raw() + } + + /// Get raw value of IF_variant + /// + /// - Start bit: 48 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn if_variant_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..54].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IF_variant + #[inline(always)] + pub fn set_if_variant(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 63_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..54].store_le(value); + Ok(()) + } + + /// IF_revision + /// + /// external info to e.g. MS6 which dbc has to be used. This index increments with added features (rest of MS6 interface stays intact.) + /// + /// - Min: 0 + /// - Max: 63 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn if_revision(&self) -> u8 { + self.if_revision_raw() + } + + /// Get raw value of IF_revision + /// + /// - Start bit: 54 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn if_revision_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[54..60].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IF_revision + #[inline(always)] + pub fn set_if_revision(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 63_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[54..60].store_le(value); + Ok(()) + } + + /// IF_chksum + /// + /// external info to e.g. MS6 which dbc has to be used. Checksum + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn if_chksum(&self) -> u8 { + self.if_chksum_raw() + } + + /// Get raw value of IF_chksum + /// + /// - Start bit: 60 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn if_chksum_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[60..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IF_chksum + #[inline(always)] + pub fn set_if_chksum(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse51::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[60..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse51 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse51 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_52 +/// +/// - Standard ID: 1346 (0x542) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse52 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x542)}); + + pub const MPLX_SW_INFO_MIN: u8 = 0_u8; + pub const MPLX_SW_INFO_MAX: u8 = 255_u8; + pub const SW_VERSION_HIGH_UPPER_MIN: u8 = 0_u8; + pub const SW_VERSION_HIGH_UPPER_MAX: u8 = 255_u8; + pub const SW_VERSION_HIGH_LOWER_MIN: u8 = 0_u8; + pub const SW_VERSION_HIGH_LOWER_MAX: u8 = 255_u8; + pub const SW_VERSION_MID_UPPER_MIN: u8 = 0_u8; + pub const SW_VERSION_MID_UPPER_MAX: u8 = 255_u8; + pub const SW_VERSION_MID_LOWER_MIN: u8 = 0_u8; + pub const SW_VERSION_MID_LOWER_MAX: u8 = 255_u8; + pub const SW_VERSION_LOW_UPPER_MIN: u8 = 0_u8; + pub const SW_VERSION_LOW_UPPER_MAX: u8 = 255_u8; + pub const SW_VERSION_LOW_LOWER_MIN: u8 = 0_u8; + pub const SW_VERSION_LOW_LOWER_MAX: u8 = 255_u8; + pub const BB_DIG1_MIN: u8 = 0_u8; + pub const BB_DIG1_MAX: u8 = 255_u8; + pub const BB_DIG2_MIN: u8 = 0_u8; + pub const BB_DIG2_MAX: u8 = 255_u8; + pub const BB_DIG3_MIN: u8 = 0_u8; + pub const BB_DIG3_MAX: u8 = 255_u8; + pub const BB_DIG4_MIN: u8 = 0_u8; + pub const BB_DIG4_MAX: u8 = 255_u8; + pub const BB_DIG5_MIN: u8 = 0_u8; + pub const BB_DIG5_MAX: u8 = 255_u8; + pub const BB_DIG6_MIN: u8 = 0_u8; + pub const BB_DIG6_MAX: u8 = 255_u8; + pub const BB_DIG7_MIN: u8 = 0_u8; + pub const BB_DIG7_MAX: u8 = 255_u8; + pub const APPL_ID_01_MIN: u8 = 0_u8; + pub const APPL_ID_01_MAX: u8 = 255_u8; + pub const APPL_ID_02_MIN: u8 = 0_u8; + pub const APPL_ID_02_MAX: u8 = 255_u8; + pub const APPL_ID_03_MIN: u8 = 0_u8; + pub const APPL_ID_03_MAX: u8 = 255_u8; + pub const APPL_ID_04_MIN: u8 = 0_u8; + pub const APPL_ID_04_MAX: u8 = 255_u8; + pub const APPL_ID_05_MIN: u8 = 0_u8; + pub const APPL_ID_05_MAX: u8 = 255_u8; + pub const APPL_ID_06_MIN: u8 = 0_u8; + pub const APPL_ID_06_MAX: u8 = 255_u8; + pub const APPL_ID_07_MIN: u8 = 0_u8; + pub const APPL_ID_07_MAX: u8 = 255_u8; + pub const APPL_ID_08_MIN: u8 = 0_u8; + pub const APPL_ID_08_MAX: u8 = 255_u8; + pub const APPL_ID_09_MIN: u8 = 0_u8; + pub const APPL_ID_09_MAX: u8 = 255_u8; + pub const APPL_ID_10_MIN: u8 = 0_u8; + pub const APPL_ID_10_MAX: u8 = 255_u8; + pub const APPL_ID_11_MIN: u8 = 0_u8; + pub const APPL_ID_11_MAX: u8 = 255_u8; + pub const APPL_ID_12_MIN: u8 = 0_u8; + pub const APPL_ID_12_MAX: u8 = 255_u8; + pub const APPL_ID_13_MIN: u8 = 0_u8; + pub const APPL_ID_13_MAX: u8 = 255_u8; + pub const APPL_ID_14_MIN: u8 = 0_u8; + pub const APPL_ID_14_MAX: u8 = 255_u8; + pub const APPL_DATE_01_MIN: u8 = 0_u8; + pub const APPL_DATE_01_MAX: u8 = 99_u8; + pub const APPL_DATE_02_MIN: u8 = 1_u8; + pub const APPL_DATE_02_MAX: u8 = 12_u8; + pub const APPL_DATE_03_MIN: u8 = 1_u8; + pub const APPL_DATE_03_MAX: u8 = 31_u8; + pub const APPL_DATE_04_MIN: u8 = 0_u8; + pub const APPL_DATE_04_MAX: u8 = 24_u8; + pub const APPL_DATE_05_MIN: u8 = 0_u8; + pub const APPL_DATE_05_MAX: u8 = 59_u8; + pub const APPL_DATE_06_MIN: u8 = 0_u8; + pub const APPL_DATE_06_MAX: u8 = 59_u8; + pub const SW_CAN_IDENT_MIN: u8 = 0_u8; + pub const SW_CAN_IDENT_MAX: u8 = 255_u8; + pub const HU_DATE_YEAR_MIN: u8 = 0_u8; + pub const HU_DATE_YEAR_MAX: u8 = 99_u8; + pub const HU_DATE_MONTH_MIN: u8 = 1_u8; + pub const HU_DATE_MONTH_MAX: u8 = 12_u8; + pub const HU_DATE_DAY_MIN: u8 = 1_u8; + pub const HU_DATE_DAY_MAX: u8 = 31_u8; + pub const ECU_SERIAL_MIN: u32 = 0_u32; + pub const ECU_SERIAL_MAX: u32 = 99999_u32; + + /// Construct new BREMSE_52 from values + pub fn new(mplx_sw_info: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mplx_sw_info(mplx_sw_info)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Mplx_SW_Info + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn mplx_sw_info_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mplx_sw_info(&mut self) -> Result { + match self.mplx_sw_info_raw() { + 1 => Ok(Bremse52MplxSwInfoIndex::M1(Bremse52MplxSwInfoM1{ raw: self.raw })), + 2 => Ok(Bremse52MplxSwInfoIndex::M2(Bremse52MplxSwInfoM2{ raw: self.raw })), + 3 => Ok(Bremse52MplxSwInfoIndex::M3(Bremse52MplxSwInfoM3{ raw: self.raw })), + 4 => Ok(Bremse52MplxSwInfoIndex::M4(Bremse52MplxSwInfoM4{ raw: self.raw })), + 5 => Ok(Bremse52MplxSwInfoIndex::M5(Bremse52MplxSwInfoM5{ raw: self.raw })), + 6 => Ok(Bremse52MplxSwInfoIndex::M6(Bremse52MplxSwInfoM6{ raw: self.raw })), + 7 => Ok(Bremse52MplxSwInfoIndex::M7(Bremse52MplxSwInfoM7{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Bremse52::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Mplx_SW_Info + #[inline(always)] + fn set_mplx_sw_info(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m1(&mut self, value: Bremse52MplxSwInfoM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(1)?; + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m2(&mut self, value: Bremse52MplxSwInfoM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(2)?; + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m3(&mut self, value: Bremse52MplxSwInfoM3) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(3)?; + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m4(&mut self, value: Bremse52MplxSwInfoM4) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(4)?; + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m5(&mut self, value: Bremse52MplxSwInfoM5) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(5)?; + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m6(&mut self, value: Bremse52MplxSwInfoM6) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(6)?; + Ok(()) + } + + /// Set value of Mplx_SW_Info + #[inline(always)] + pub fn set_m7(&mut self, value: Bremse52MplxSwInfoM7) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mplx_sw_info(7)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse52 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse52 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal BREMSE_52 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Bremse52MplxSwInfoIndex { + M1(Bremse52MplxSwInfoM1), + M2(Bremse52MplxSwInfoM2), + M3(Bremse52MplxSwInfoM3), + M4(Bremse52MplxSwInfoM4), + M5(Bremse52MplxSwInfoM5), + M6(Bremse52MplxSwInfoM6), + M7(Bremse52MplxSwInfoM7), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SW_version_High_upper +/// +/// version 1.0 as 0x01(upper), version 100.20 as 0x64(upper) +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_version_high_upper(&self) -> u8 { + self.sw_version_high_upper_raw() +} + +/// Get raw value of SW_version_High_upper +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_version_high_upper_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_version_High_upper +#[inline(always)] +pub fn set_sw_version_high_upper(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +/// SW_version_High_lower +/// +/// version 1.0 as 0x00(lower), version 100.20 as 0x14(lower) +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_version_high_lower(&self) -> u8 { + self.sw_version_high_lower_raw() +} + +/// Get raw value of SW_version_High_lower +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_version_high_lower_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_version_High_lower +#[inline(always)] +pub fn set_sw_version_high_lower(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +/// SW_version_Mid_upper +/// +/// version 1.0 as 0x01(upper), version 100.20 as 0x64(upper) +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_version_mid_upper(&self) -> u8 { + self.sw_version_mid_upper_raw() +} + +/// Get raw value of SW_version_Mid_upper +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_version_mid_upper_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_version_Mid_upper +#[inline(always)] +pub fn set_sw_version_mid_upper(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// SW_version_Mid_lower +/// +/// version 1.0 as 0x00(lower), version 100.20 as 0x14(lower) +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_version_mid_lower(&self) -> u8 { + self.sw_version_mid_lower_raw() +} + +/// Get raw value of SW_version_Mid_lower +/// +/// - Start bit: 32 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_version_mid_lower_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_version_Mid_lower +#[inline(always)] +pub fn set_sw_version_mid_lower(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) +} + +/// SW_version_Low_upper +/// +/// version 1.0 as 0x01(upper), version 100.20 as 0x64(upper) +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_version_low_upper(&self) -> u8 { + self.sw_version_low_upper_raw() +} + +/// Get raw value of SW_version_Low_upper +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_version_low_upper_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_version_Low_upper +#[inline(always)] +pub fn set_sw_version_low_upper(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// SW_version_Low_lower +/// +/// version 1.0 as 0x00(lower), version 100.20 as 0x14(lower) +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_version_low_lower(&self) -> u8 { + self.sw_version_low_lower_raw() +} + +/// Get raw value of SW_version_Low_lower +/// +/// - Start bit: 48 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_version_low_lower_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_version_Low_lower +#[inline(always)] +pub fn set_sw_version_low_lower(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BB_dig1 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig1(&self) -> u8 { + self.bb_dig1_raw() +} + +/// Get raw value of BB_dig1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig1 +#[inline(always)] +pub fn set_bb_dig1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +/// BB_dig2 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig2(&self) -> u8 { + self.bb_dig2_raw() +} + +/// Get raw value of BB_dig2 +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig2 +#[inline(always)] +pub fn set_bb_dig2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +/// BB_dig3 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig3(&self) -> u8 { + self.bb_dig3_raw() +} + +/// Get raw value of BB_dig3 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig3_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig3 +#[inline(always)] +pub fn set_bb_dig3(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// BB_dig4 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig4(&self) -> u8 { + self.bb_dig4_raw() +} + +/// Get raw value of BB_dig4 +/// +/// - Start bit: 32 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig4_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig4 +#[inline(always)] +pub fn set_bb_dig4(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) +} + +/// BB_dig5 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig5(&self) -> u8 { + self.bb_dig5_raw() +} + +/// Get raw value of BB_dig5 +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig5_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig5 +#[inline(always)] +pub fn set_bb_dig5(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// BB_dig6 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig6(&self) -> u8 { + self.bb_dig6_raw() +} + +/// Get raw value of BB_dig6 +/// +/// - Start bit: 48 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig6_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig6 +#[inline(always)] +pub fn set_bb_dig6(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) +} + +/// BB_dig7 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bb_dig7(&self) -> u8 { + self.bb_dig7_raw() +} + +/// Get raw value of BB_dig7 +/// +/// - Start bit: 56 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bb_dig7_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of BB_dig7 +#[inline(always)] +pub fn set_bb_dig7(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM3 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM3 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// Appl_Id_01 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_01(&self) -> u8 { + self.appl_id_01_raw() +} + +/// Get raw value of Appl_Id_01 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_01_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_01 +#[inline(always)] +pub fn set_appl_id_01(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +/// Appl_Id_02 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_02(&self) -> u8 { + self.appl_id_02_raw() +} + +/// Get raw value of Appl_Id_02 +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_02_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_02 +#[inline(always)] +pub fn set_appl_id_02(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +/// Appl_Id_03 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_03(&self) -> u8 { + self.appl_id_03_raw() +} + +/// Get raw value of Appl_Id_03 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_03_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_03 +#[inline(always)] +pub fn set_appl_id_03(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// Appl_Id_04 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_04(&self) -> u8 { + self.appl_id_04_raw() +} + +/// Get raw value of Appl_Id_04 +/// +/// - Start bit: 32 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_04_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_04 +#[inline(always)] +pub fn set_appl_id_04(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) +} + +/// Appl_Id_05 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_05(&self) -> u8 { + self.appl_id_05_raw() +} + +/// Get raw value of Appl_Id_05 +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_05_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_05 +#[inline(always)] +pub fn set_appl_id_05(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// Appl_Id_06 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_06(&self) -> u8 { + self.appl_id_06_raw() +} + +/// Get raw value of Appl_Id_06 +/// +/// - Start bit: 48 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_06_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_06 +#[inline(always)] +pub fn set_appl_id_06(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) +} + +/// Appl_Id_07 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_07(&self) -> u8 { + self.appl_id_07_raw() +} + +/// Get raw value of Appl_Id_07 +/// +/// - Start bit: 56 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_07_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_07 +#[inline(always)] +pub fn set_appl_id_07(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM4 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM4 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// Appl_Id_08 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_08(&self) -> u8 { + self.appl_id_08_raw() +} + +/// Get raw value of Appl_Id_08 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_08_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_08 +#[inline(always)] +pub fn set_appl_id_08(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +/// Appl_Id_09 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_09(&self) -> u8 { + self.appl_id_09_raw() +} + +/// Get raw value of Appl_Id_09 +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_09_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_09 +#[inline(always)] +pub fn set_appl_id_09(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +/// Appl_Id_10 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_10(&self) -> u8 { + self.appl_id_10_raw() +} + +/// Get raw value of Appl_Id_10 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_10_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_10 +#[inline(always)] +pub fn set_appl_id_10(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// Appl_Id_11 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_11(&self) -> u8 { + self.appl_id_11_raw() +} + +/// Get raw value of Appl_Id_11 +/// +/// - Start bit: 32 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_11_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_11 +#[inline(always)] +pub fn set_appl_id_11(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) +} + +/// Appl_Id_12 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_12(&self) -> u8 { + self.appl_id_12_raw() +} + +/// Get raw value of Appl_Id_12 +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_12_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_12 +#[inline(always)] +pub fn set_appl_id_12(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// Appl_Id_13 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_13(&self) -> u8 { + self.appl_id_13_raw() +} + +/// Get raw value of Appl_Id_13 +/// +/// - Start bit: 48 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_13_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_13 +#[inline(always)] +pub fn set_appl_id_13(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) +} + +/// Appl_Id_14 +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "ASCII" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_id_14(&self) -> u8 { + self.appl_id_14_raw() +} + +/// Get raw value of Appl_Id_14 +/// +/// - Start bit: 56 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_id_14_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_Id_14 +#[inline(always)] +pub fn set_appl_id_14(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM5 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM5 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// Appl_date_01 +/// +/// year +/// +/// - Min: 0 +/// - Max: 99 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_date_01(&self) -> u8 { + self.appl_date_01_raw() +} + +/// Get raw value of Appl_date_01 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_date_01_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_date_01 +#[inline(always)] +pub fn set_appl_date_01(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 99_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +/// Appl_date_02 +/// +/// month +/// +/// - Min: 1 +/// - Max: 12 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_date_02(&self) -> u8 { + self.appl_date_02_raw() +} + +/// Get raw value of Appl_date_02 +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_date_02_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_date_02 +#[inline(always)] +pub fn set_appl_date_02(&mut self, value: u8) -> Result<(), CanError> { + if value < 1_u8 || 12_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +/// Appl_date_03 +/// +/// day +/// +/// - Min: 1 +/// - Max: 31 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_date_03(&self) -> u8 { + self.appl_date_03_raw() +} + +/// Get raw value of Appl_date_03 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_date_03_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_date_03 +#[inline(always)] +pub fn set_appl_date_03(&mut self, value: u8) -> Result<(), CanError> { + if value < 1_u8 || 31_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// Appl_date_04 +/// +/// hour +/// +/// - Min: 0 +/// - Max: 24 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_date_04(&self) -> u8 { + self.appl_date_04_raw() +} + +/// Get raw value of Appl_date_04 +/// +/// - Start bit: 32 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_date_04_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_date_04 +#[inline(always)] +pub fn set_appl_date_04(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 24_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) +} + +/// Appl_date_05 +/// +/// minute +/// +/// - Min: 0 +/// - Max: 59 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_date_05(&self) -> u8 { + self.appl_date_05_raw() +} + +/// Get raw value of Appl_date_05 +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_date_05_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_date_05 +#[inline(always)] +pub fn set_appl_date_05(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 59_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// Appl_date_06 +/// +/// seconds +/// +/// - Min: 0 +/// - Max: 59 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn appl_date_06(&self) -> u8 { + self.appl_date_06_raw() +} + +/// Get raw value of Appl_date_06 +/// +/// - Start bit: 48 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn appl_date_06_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Appl_date_06 +#[inline(always)] +pub fn set_appl_date_06(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 59_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM6 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM6 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SW_CAN_ident +/// +/// - Min: 0 +/// - Max: 255 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sw_can_ident(&self) -> u8 { + self.sw_can_ident_raw() +} + +/// Get raw value of SW_CAN_ident +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sw_can_ident_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of SW_CAN_ident +#[inline(always)] +pub fn set_sw_can_ident(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Bremse52MplxSwInfoM7 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse52MplxSwInfoM7 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// HU_date_year +/// +/// - Min: 0 +/// - Max: 99 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn hu_date_year(&self) -> u8 { + self.hu_date_year_raw() +} + +/// Get raw value of HU_date_year +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn hu_date_year_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of HU_date_year +#[inline(always)] +pub fn set_hu_date_year(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 99_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +/// HU_date_month +/// +/// - Min: 1 +/// - Max: 12 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn hu_date_month(&self) -> u8 { + self.hu_date_month_raw() +} + +/// Get raw value of HU_date_month +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn hu_date_month_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of HU_date_month +#[inline(always)] +pub fn set_hu_date_month(&mut self, value: u8) -> Result<(), CanError> { + if value < 1_u8 || 12_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +/// HU_date_day +/// +/// - Min: 1 +/// - Max: 31 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn hu_date_day(&self) -> u8 { + self.hu_date_day_raw() +} + +/// Get raw value of HU_date_day +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn hu_date_day_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of HU_date_day +#[inline(always)] +pub fn set_hu_date_day(&mut self, value: u8) -> Result<(), CanError> { + if value < 1_u8 || 31_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// Ecu_serial +/// +/// - Min: 0 +/// - Max: 99999 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn ecu_serial(&self) -> u32 { + self.ecu_serial_raw() +} + +/// Get raw value of Ecu_serial +/// +/// - Start bit: 32 +/// - Signal size: 32 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn ecu_serial_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of Ecu_serial +#[inline(always)] +pub fn set_ecu_serial(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 99999_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse52::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) +} + +} + + +/// BREMSE_50 +/// +/// - Standard ID: 1376 (0x560) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse50 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse50 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x560)}); + + pub const BRAKE_BAL_AT50_MIN: f32 = 0_f32; + pub const BRAKE_BAL_AT50_MAX: f32 = 100_f32; + pub const BRAKE_BAL_AT50_ADVICE_MIN: u8 = 0_u8; + pub const BRAKE_BAL_AT50_ADVICE_MAX: u8 = 100_u8; + pub const BRAKE_BAL_PCT_MIN: f32 = 0_f32; + pub const BRAKE_BAL_PCT_MAX: f32 = 100_f32; + pub const BRAKE_BAL_PCT_ADVICE_MIN: u8 = 0_u8; + pub const BRAKE_BAL_PCT_ADVICE_MAX: u8 = 100_u8; + + /// Construct new BREMSE_50 from values + pub fn new(brake_bal_at50: f32, brake_bal_at50_advice: u8, brake_bal_pct: f32, brake_bal_pct_advice: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_brake_bal_at50(brake_bal_at50)?; + res.set_brake_bal_at50_advice(brake_bal_at50_advice)?; + res.set_brake_bal_pct(brake_bal_pct)?; + res.set_brake_bal_pct_advice(brake_bal_pct_advice)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Brake_bal_at50 + /// + /// Calculated rear axle brake pressure if the front pressure is at 50 bar. + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "Bar" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn brake_bal_at50(&self) -> f32 { + self.brake_bal_at50_raw() + } + + /// Get raw value of Brake_bal_at50 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_bal_at50_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Brake_bal_at50 + #[inline(always)] + pub fn set_brake_bal_at50(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse50::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Brake_bal_at50_advice + /// + /// Recommended rear axle brake pressure if the front pressure is at 50 bar. + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "Bar" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn brake_bal_at50_advice(&self) -> u8 { + self.brake_bal_at50_advice_raw() + } + + /// Get raw value of Brake_bal_at50_advice + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_bal_at50_advice_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Brake_bal_at50_advice + #[inline(always)] + pub fn set_brake_bal_at50_advice(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 100_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse50::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse50::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// Brake_bal_pct + /// + /// Percental brake balance on the front axle. + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "%" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn brake_bal_pct(&self) -> f32 { + self.brake_bal_pct_raw() + } + + /// Get raw value of Brake_bal_pct + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_bal_pct_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Brake_bal_pct + #[inline(always)] + pub fn set_brake_bal_pct(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse50::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// Brake_bal_pct_advice + /// + /// Recommended percental brake balance on the front axle. + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "%" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn brake_bal_pct_advice(&self) -> u8 { + self.brake_bal_pct_advice_raw() + } + + /// Get raw value of Brake_bal_pct_advice + /// + /// - Start bit: 56 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_bal_pct_advice_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Brake_bal_pct_advice + #[inline(always)] + pub fn set_brake_bal_pct_advice(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 100_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse50::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse50::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse50 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse50 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BREMSE_53 +/// +/// - Standard ID: 1472 (0x5c0) +/// - Size: 8 bytes +/// - Transmitter: ABS +#[derive(Clone, Copy)] +pub struct Bremse53 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bremse53 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x5c0)}); + + pub const SWITCH_POSITION_MIN: u8 = 1_u8; + pub const SWITCH_POSITION_MAX: u8 = 12_u8; + pub const P_FA_MIN: f32 = -42.5_f32; + pub const P_FA_MAX: f32 = 425_f32; + pub const BREMSE_53_CNT_MIN: u8 = 0_u8; + pub const BREMSE_53_CNT_MAX: u8 = 3_u8; + pub const DIAG_FL_MIN: u8 = 0_u8; + pub const DIAG_FL_MAX: u8 = 3_u8; + pub const DIAG_FR_MIN: u8 = 0_u8; + pub const DIAG_FR_MAX: u8 = 3_u8; + pub const DIAG_RL_MIN: u8 = 0_u8; + pub const DIAG_RL_MAX: u8 = 3_u8; + pub const DIAG_RR_MIN: u8 = 0_u8; + pub const DIAG_RR_MAX: u8 = 3_u8; + pub const ABS_FAULT_INFO_MIN: u8 = 0_u8; + pub const ABS_FAULT_INFO_MAX: u8 = 3_u8; + pub const P_RA_MIN: f32 = -42.5_f32; + pub const P_RA_MAX: f32 = 425_f32; + + /// Construct new BREMSE_53 from values + pub fn new(switch_position: u8, p_fa: f32, bls: bool, bremse_53_cnt: u8, abs_malfunction: bool, abs_active: bool, ebd_lamp: bool, abs_lamp: bool, diag_fl: u8, diag_fr: u8, diag_rl: u8, diag_rr: u8, diag_abs_unit: bool, diag_fuse_valve: bool, diag_fuse_pump: bool, diag_p_fa: bool, diag_p_ra: bool, diag_yrs: bool, abs_fault_info: u8, p_ra: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_switch_position(switch_position)?; + res.set_p_fa(p_fa)?; + res.set_bls(bls)?; + res.set_bremse_53_cnt(bremse_53_cnt)?; + res.set_abs_malfunction(abs_malfunction)?; + res.set_abs_active(abs_active)?; + res.set_ebd_lamp(ebd_lamp)?; + res.set_abs_lamp(abs_lamp)?; + res.set_diag_fl(diag_fl)?; + res.set_diag_fr(diag_fr)?; + res.set_diag_rl(diag_rl)?; + res.set_diag_rr(diag_rr)?; + res.set_diag_abs_unit(diag_abs_unit)?; + res.set_diag_fuse_valve(diag_fuse_valve)?; + res.set_diag_fuse_pump(diag_fuse_pump)?; + res.set_diag_p_fa(diag_p_fa)?; + res.set_diag_p_ra(diag_p_ra)?; + res.set_diag_yrs(diag_yrs)?; + res.set_abs_fault_info(abs_fault_info)?; + res.set_p_ra(p_ra)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SwitchPosition + /// + /// Used switch position of the ABS. + /// + /// - Min: 1 + /// - Max: 12 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn switch_position(&self) -> u8 { + self.switch_position_raw() + } + + /// Get raw value of SwitchPosition + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn switch_position_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SwitchPosition + #[inline(always)] + pub fn set_switch_position(&mut self, value: u8) -> Result<(), CanError> { + if value < 1_u8 || 12_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// P_FA + /// + /// Brake pressure on the front axle. + /// + /// - Min: -42.5 + /// - Max: 425 + /// - Unit: "bar" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn p_fa(&self) -> f32 { + self.p_fa_raw() + } + + /// Get raw value of P_FA + /// + /// - Start bit: 8 + /// - Signal size: 16 bits + /// - Factor: 0.01526 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn p_fa_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..24].load_le::(); + + let factor = 0.01526_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of P_FA + #[inline(always)] + pub fn set_p_fa(&mut self, value: f32) -> Result<(), CanError> { + if value < -42.5_f32 || 425_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 0.01526_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..24].store_le(value); + Ok(()) + } + + /// BLS + /// + /// Bit for the brake light switch. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn bls(&self) -> bool { + self.bls_raw() + } + + /// Get raw value of BLS + /// + /// - Start bit: 24 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn bls_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 + } + + /// Set value of BLS + #[inline(always)] + pub fn set_bls(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) + } + + /// Bremse_53_cnt + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn bremse_53_cnt(&self) -> u8 { + self.bremse_53_cnt_raw() + } + + /// Get raw value of Bremse_53_cnt + /// + /// - Start bit: 26 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn bremse_53_cnt_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[26..28].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Bremse_53_cnt + #[inline(always)] + pub fn set_bremse_53_cnt(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[26..28].store_le(value); + Ok(()) + } + + /// ABS_Malfunction + /// + /// Bit will jump to 1, if the ABS control is deactivated by a fault. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn abs_malfunction(&self) -> bool { + self.abs_malfunction_raw() + } + + /// Get raw value of ABS_Malfunction + /// + /// - Start bit: 28 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn abs_malfunction_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 + } + + /// Set value of ABS_Malfunction + #[inline(always)] + pub fn set_abs_malfunction(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) + } + + /// ABS_Active + /// + /// Bit will jump to 1, when the ABS control is active. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn abs_active(&self) -> bool { + self.abs_active_raw() + } + + /// Get raw value of ABS_Active + /// + /// - Start bit: 29 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn abs_active_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 + } + + /// Set value of ABS_Active + #[inline(always)] + pub fn set_abs_active(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) + } + + /// EBD_Lamp + /// + /// Bit will jump to 1, when the EBD is deactivated due to a fault. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ebd_lamp(&self) -> bool { + self.ebd_lamp_raw() + } + + /// Get raw value of EBD_Lamp + /// + /// - Start bit: 30 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ebd_lamp_raw(&self) -> bool { + let signal = self.raw.view_bits::()[30..31].load_le::(); + + signal == 1 + } + + /// Set value of EBD_Lamp + #[inline(always)] + pub fn set_ebd_lamp(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[30..31].store_le(value); + Ok(()) + } + + /// ABS_Lamp + /// + /// Bit will jump to 1, when the ABS control is deactivated due to a fault, switch to the off position or while working with RaceABS. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn abs_lamp(&self) -> bool { + self.abs_lamp_raw() + } + + /// Get raw value of ABS_Lamp + /// + /// - Start bit: 31 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn abs_lamp_raw(&self) -> bool { + let signal = self.raw.view_bits::()[31..32].load_le::(); + + signal == 1 + } + + /// Set value of ABS_Lamp + #[inline(always)] + pub fn set_abs_lamp(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[31..32].store_le(value); + Ok(()) + } + + /// Diag_FL + /// + /// Value to show faults related to the wheel speed sensor. + /// 0 - Signal ok, 1 - Wiring related fault, 2 - Signal related fault + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_fl(&self) -> Bremse53DiagFl { + let signal = self.raw.view_bits::()[32..34].load_le::(); + + match signal { + 2 => Bremse53DiagFl::SignalError, + 1 => Bremse53DiagFl::LineError, + 0 => Bremse53DiagFl::SignalOk, + _ => Bremse53DiagFl::_Other(self.diag_fl_raw()), + } + } + + /// Get raw value of Diag_FL + /// + /// - Start bit: 32 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_fl_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..34].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Diag_FL + #[inline(always)] + pub fn set_diag_fl(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..34].store_le(value); + Ok(()) + } + + /// Diag_FR + /// + /// Value to show faults related to the wheel speed sensor. + /// 0 - Signal ok, 1 - Wiring related fault, 2 - Signal related fault + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_fr(&self) -> Bremse53DiagFr { + let signal = self.raw.view_bits::()[34..36].load_le::(); + + match signal { + 2 => Bremse53DiagFr::SignalError, + 1 => Bremse53DiagFr::LineError, + 0 => Bremse53DiagFr::SignalOk, + _ => Bremse53DiagFr::_Other(self.diag_fr_raw()), + } + } + + /// Get raw value of Diag_FR + /// + /// - Start bit: 34 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_fr_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[34..36].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Diag_FR + #[inline(always)] + pub fn set_diag_fr(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[34..36].store_le(value); + Ok(()) + } + + /// Diag_RL + /// + /// Value to show faults related to the wheel speed sensor. + /// 0 - Signal ok, 1 - Wiring related fault, 2 - Signal related fault + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_rl(&self) -> Bremse53DiagRl { + let signal = self.raw.view_bits::()[36..38].load_le::(); + + match signal { + 2 => Bremse53DiagRl::SignalError, + 1 => Bremse53DiagRl::LineError, + 0 => Bremse53DiagRl::SignalOk, + _ => Bremse53DiagRl::_Other(self.diag_rl_raw()), + } + } + + /// Get raw value of Diag_RL + /// + /// - Start bit: 36 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_rl_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[36..38].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Diag_RL + #[inline(always)] + pub fn set_diag_rl(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[36..38].store_le(value); + Ok(()) + } + + /// Diag_RR + /// + /// Value to show faults related to the wheel speed sensor. + /// 0 - Signal ok, 1 - Wiring related fault, 2 - Signal related fault + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_rr(&self) -> Bremse53DiagRr { + let signal = self.raw.view_bits::()[38..40].load_le::(); + + match signal { + 2 => Bremse53DiagRr::SignalError, + 1 => Bremse53DiagRr::LineError, + 0 => Bremse53DiagRr::SignalOk, + _ => Bremse53DiagRr::_Other(self.diag_rr_raw()), + } + } + + /// Get raw value of Diag_RR + /// + /// - Start bit: 38 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_rr_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[38..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Diag_RR + #[inline(always)] + pub fn set_diag_rr(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[38..40].store_le(value); + Ok(()) + } + + /// Diag_ABSUnit + /// + /// Bit to show, if a ABS error related to the hydraulic unit is present + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_abs_unit(&self) -> bool { + self.diag_abs_unit_raw() + } + + /// Get raw value of Diag_ABSUnit + /// + /// - Start bit: 40 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_abs_unit_raw(&self) -> bool { + let signal = self.raw.view_bits::()[40..41].load_le::(); + + signal == 1 + } + + /// Set value of Diag_ABSUnit + #[inline(always)] + pub fn set_diag_abs_unit(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[40..41].store_le(value); + Ok(()) + } + + /// Diag_FuseValve + /// + /// Bit to show, if a ABS error related to the fuse or power supply of the ABS valves is present. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_fuse_valve(&self) -> bool { + self.diag_fuse_valve_raw() + } + + /// Get raw value of Diag_FuseValve + /// + /// - Start bit: 41 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_fuse_valve_raw(&self) -> bool { + let signal = self.raw.view_bits::()[41..42].load_le::(); + + signal == 1 + } + + /// Set value of Diag_FuseValve + #[inline(always)] + pub fn set_diag_fuse_valve(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[41..42].store_le(value); + Ok(()) + } + + /// Diag_FusePump + /// + /// Bit to show, if a ABS error related to the fuse or power supply of the ABS pump is present. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_fuse_pump(&self) -> bool { + self.diag_fuse_pump_raw() + } + + /// Get raw value of Diag_FusePump + /// + /// - Start bit: 42 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_fuse_pump_raw(&self) -> bool { + let signal = self.raw.view_bits::()[42..43].load_le::(); + + signal == 1 + } + + /// Set value of Diag_FusePump + #[inline(always)] + pub fn set_diag_fuse_pump(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[42..43].store_le(value); + Ok(()) + } + + /// Diag_P_FA + /// + /// Bit to show, if the pressure sensor FA is working properly. An error is pressent, if the bit is 1. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_p_fa(&self) -> bool { + self.diag_p_fa_raw() + } + + /// Get raw value of Diag_P_FA + /// + /// - Start bit: 43 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_p_fa_raw(&self) -> bool { + let signal = self.raw.view_bits::()[43..44].load_le::(); + + signal == 1 + } + + /// Set value of Diag_P_FA + #[inline(always)] + pub fn set_diag_p_fa(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[43..44].store_le(value); + Ok(()) + } + + /// Diag_P_RA + /// + /// Bit to show, if the pressure sensor RA is working properly. An error is pressent, if the bit is 1. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_p_ra(&self) -> bool { + self.diag_p_ra_raw() + } + + /// Get raw value of Diag_P_RA + /// + /// - Start bit: 44 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_p_ra_raw(&self) -> bool { + let signal = self.raw.view_bits::()[44..45].load_le::(); + + signal == 1 + } + + /// Set value of Diag_P_RA + #[inline(always)] + pub fn set_diag_p_ra(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[44..45].store_le(value); + Ok(()) + } + + /// Diag_YRS + /// + /// Bit to show, if the yaw rate sensor is working properly. An error is pressent, if the bit is 1. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn diag_yrs(&self) -> bool { + self.diag_yrs_raw() + } + + /// Get raw value of Diag_YRS + /// + /// - Start bit: 45 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn diag_yrs_raw(&self) -> bool { + let signal = self.raw.view_bits::()[45..46].load_le::(); + + signal == 1 + } + + /// Set value of Diag_YRS + #[inline(always)] + pub fn set_diag_yrs(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[45..46].store_le(value); + Ok(()) + } + + /// ABS_fault_info + /// + /// Bit matrix to show if a fault or a active fault is stored in the ABS. Bit will also show minor errors which do not shut down the ABS controller. + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn abs_fault_info(&self) -> Bremse53AbsFaultInfo { + let signal = self.raw.view_bits::()[46..48].load_le::(); + + match signal { + 2 => Bremse53AbsFaultInfo::ActiveFaultsStored, + 1 => Bremse53AbsFaultInfo::InactiveFaultsStored, + 0 => Bremse53AbsFaultInfo::NoFaultsStored, + _ => Bremse53AbsFaultInfo::_Other(self.abs_fault_info_raw()), + } + } + + /// Get raw value of ABS_fault_info + /// + /// - Start bit: 46 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn abs_fault_info_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[46..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ABS_fault_info + #[inline(always)] + pub fn set_abs_fault_info(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[46..48].store_le(value); + Ok(()) + } + + /// P_RA + /// + /// Brake pressure on the rear axle. + /// + /// - Min: -42.5 + /// - Max: 425 + /// - Unit: "bar" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn p_ra(&self) -> f32 { + self.p_ra_raw() + } + + /// Get raw value of P_RA + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01526 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn p_ra_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01526_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of P_RA + #[inline(always)] + pub fn set_p_ra(&mut self, value: f32) -> Result<(), CanError> { + if value < -42.5_f32 || 425_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bremse53::MESSAGE_ID }); + } + let factor = 0.01526_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bremse53 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bremse53 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Diag_FL +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Bremse53DiagFl { + SignalError, + LineError, + SignalOk, + _Other(u8), +} + +impl From for u8 { + fn from(val: Bremse53DiagFl) -> u8 { + match val { + Bremse53DiagFl::SignalError => 2, + Bremse53DiagFl::LineError => 1, + Bremse53DiagFl::SignalOk => 0, + Bremse53DiagFl::_Other(x) => x, + } + } +} + +/// Defined values for Diag_FR +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Bremse53DiagFr { + SignalError, + LineError, + SignalOk, + _Other(u8), +} + +impl From for u8 { + fn from(val: Bremse53DiagFr) -> u8 { + match val { + Bremse53DiagFr::SignalError => 2, + Bremse53DiagFr::LineError => 1, + Bremse53DiagFr::SignalOk => 0, + Bremse53DiagFr::_Other(x) => x, + } + } +} + +/// Defined values for Diag_RL +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Bremse53DiagRl { + SignalError, + LineError, + SignalOk, + _Other(u8), +} + +impl From for u8 { + fn from(val: Bremse53DiagRl) -> u8 { + match val { + Bremse53DiagRl::SignalError => 2, + Bremse53DiagRl::LineError => 1, + Bremse53DiagRl::SignalOk => 0, + Bremse53DiagRl::_Other(x) => x, + } + } +} + +/// Defined values for Diag_RR +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Bremse53DiagRr { + SignalError, + LineError, + SignalOk, + _Other(u8), +} + +impl From for u8 { + fn from(val: Bremse53DiagRr) -> u8 { + match val { + Bremse53DiagRr::SignalError => 2, + Bremse53DiagRr::LineError => 1, + Bremse53DiagRr::SignalOk => 0, + Bremse53DiagRr::_Other(x) => x, + } + } +} + +/// Defined values for ABS_fault_info +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Bremse53AbsFaultInfo { + ActiveFaultsStored, + InactiveFaultsStored, + NoFaultsStored, + _Other(u8), +} + +impl From for u8 { + fn from(val: Bremse53AbsFaultInfo) -> u8 { + match val { + Bremse53AbsFaultInfo::ActiveFaultsStored => 2, + Bremse53AbsFaultInfo::InactiveFaultsStored => 1, + Bremse53AbsFaultInfo::NoFaultsStored => 0, + Bremse53AbsFaultInfo::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/add_two_dbc_files_1.snap b/tests-snapshots/dbc-cantools/add_two_dbc_files_1.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/add_two_dbc_files_1.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/add_two_dbc_files_1.snap.rs b/tests-snapshots/dbc-cantools/add_two_dbc_files_1.snap.rs new file mode 100644 index 0000000..ed1a12b --- /dev/null +++ b/tests-snapshots/dbc-cantools/add_two_dbc_files_1.snap.rs @@ -0,0 +1,254 @@ +// Generated code! +// +// Message definitions from file `add_two_dbc_files_1` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// M1 + M1(M1), + /// M2 + M2(M2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + M1::MESSAGE_ID => Messages::M1(M1::try_from(payload)?), + M2::MESSAGE_ID => Messages::M2(M2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// M1 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct M1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl M1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + + /// Construct new M1 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for M1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for M1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// M2 +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct M2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl M2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + + /// Construct new M2 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for M2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for M2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/add_two_dbc_files_2.snap b/tests-snapshots/dbc-cantools/add_two_dbc_files_2.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/add_two_dbc_files_2.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/add_two_dbc_files_2.snap.rs b/tests-snapshots/dbc-cantools/add_two_dbc_files_2.snap.rs new file mode 100644 index 0000000..96e9f2c --- /dev/null +++ b/tests-snapshots/dbc-cantools/add_two_dbc_files_2.snap.rs @@ -0,0 +1,166 @@ +// Generated code! +// +// Message definitions from file `add_two_dbc_files_2` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// M1 + M1(M1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + M1::MESSAGE_ID => Messages::M1(M1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// M1 +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct M1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl M1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + + /// Construct new M1 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for M1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for M1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/attribute_Event.snap b/tests-snapshots/dbc-cantools/attribute_Event.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/attribute_Event.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/attribute_Event.snap.rs b/tests-snapshots/dbc-cantools/attribute_Event.snap.rs new file mode 100644 index 0000000..f854a6a --- /dev/null +++ b/tests-snapshots/dbc-cantools/attribute_Event.snap.rs @@ -0,0 +1,213 @@ +// Generated code! +// +// Message definitions from file `attribute_Event` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// INV2EventMsg1 + Inv2EventMsg1(Inv2EventMsg1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Inv2EventMsg1::MESSAGE_ID => Messages::Inv2EventMsg1(Inv2EventMsg1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// INV2EventMsg1 +/// +/// - Standard ID: 1234 (0x4d2) +/// - Size: 8 bytes +/// - Transmitter: Inv2 +#[derive(Clone, Copy)] +pub struct Inv2EventMsg1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Inv2EventMsg1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4d2)}); + + pub const THE_SIGNAL_MIN: i8 = 0_i8; + pub const THE_SIGNAL_MAX: i8 = 0_i8; + + /// Construct new INV2EventMsg1 from values + pub fn new(the_signal: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_the_signal(the_signal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TheSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn the_signal(&self) -> i8 { + self.the_signal_raw() + } + + /// Get raw value of TheSignal + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn the_signal_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TheSignal + #[inline(always)] + pub fn set_the_signal(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Inv2EventMsg1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Inv2EventMsg1::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Inv2EventMsg1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Inv2EventMsg1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/attributes.snap b/tests-snapshots/dbc-cantools/attributes.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/attributes.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/attributes.snap.rs b/tests-snapshots/dbc-cantools/attributes.snap.rs new file mode 100644 index 0000000..4d1877f --- /dev/null +++ b/tests-snapshots/dbc-cantools/attributes.snap.rs @@ -0,0 +1,346 @@ +// Generated code! +// +// Message definitions from file `attributes` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// TheMessage + TheMessage(TheMessage), + /// TheOtherMessage + TheOtherMessage(TheOtherMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + TheMessage::MESSAGE_ID => Messages::TheMessage(TheMessage::try_from(payload)?), + TheOtherMessage::MESSAGE_ID => Messages::TheOtherMessage(TheOtherMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// TheMessage +/// +/// - Extended ID: 57 (0x39) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TheMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TheMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x39)}); + + pub const THE_SIGNAL_MIN: i8 = 0_i8; + pub const THE_SIGNAL_MAX: i8 = 0_i8; + + /// Construct new TheMessage from values + pub fn new(the_signal: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_the_signal(the_signal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TheSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn the_signal(&self) -> i8 { + self.the_signal_raw() + } + + /// Get raw value of TheSignal + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn the_signal_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TheSignal + #[inline(always)] + pub fn set_the_signal(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TheMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TheMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TheMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TheMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TheOtherMessage +/// +/// - Standard ID: 42 (0x2a) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TheOtherMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TheOtherMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2a)}); + + pub const THE_SIGNAL_MIN: i8 = 0_i8; + pub const THE_SIGNAL_MAX: i8 = 0_i8; + + /// Construct new TheOtherMessage from values + pub fn new(the_signal: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_the_signal(the_signal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TheSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn the_signal(&self) -> i8 { + self.the_signal_raw() + } + + /// Get raw value of TheSignal + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn the_signal_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TheSignal + #[inline(always)] + pub fn set_the_signal(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TheOtherMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TheOtherMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TheOtherMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TheOtherMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/attributes_relation.snap b/tests-snapshots/dbc-cantools/attributes_relation.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/attributes_relation.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/attributes_relation.snap.rs b/tests-snapshots/dbc-cantools/attributes_relation.snap.rs new file mode 100644 index 0000000..c9b538c --- /dev/null +++ b/tests-snapshots/dbc-cantools/attributes_relation.snap.rs @@ -0,0 +1,348 @@ +// Generated code! +// +// Message definitions from file `attributes_relation` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message_2 + Message2(Message2), + /// Message_1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message_2 +/// +/// - Standard ID: 83 (0x53) +/// - Size: 8 bytes +/// - Transmitter: ECU2 +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x53)}); + + pub const SIGNAL_2_MIN: i8 = 0_i8; + pub const SIGNAL_2_MAX: i8 = 0_i8; + + /// Construct new Message_2 from values + pub fn new(signal_2: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal_2(signal_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// signal_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: ECU1 + #[inline(always)] + pub fn signal_2(&self) -> i8 { + self.signal_2_raw() + } + + /// Get raw value of signal_2 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of signal_2 + #[inline(always)] + pub fn set_signal_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message_1 +/// +/// - Standard ID: 82 (0x52) +/// - Size: 8 bytes +/// - Transmitter: ECU1 +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x52)}); + + pub const SIGNAL_1_MIN: i8 = 0_i8; + pub const SIGNAL_1_MAX: i8 = 0_i8; + + /// Construct new Message_1 from values + pub fn new(signal_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal_1(signal_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// signal_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: ECU2 + #[inline(always)] + pub fn signal_1(&self) -> i8 { + self.signal_1_raw() + } + + /// Get raw value of signal_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of signal_1 + #[inline(always)] + pub fn set_signal_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/big_numbers.snap b/tests-snapshots/dbc-cantools/big_numbers.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/big_numbers.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/big_numbers.snap.rs b/tests-snapshots/dbc-cantools/big_numbers.snap.rs new file mode 100644 index 0000000..51f2e17 --- /dev/null +++ b/tests-snapshots/dbc-cantools/big_numbers.snap.rs @@ -0,0 +1,346 @@ +// Generated code! +// +// Message definitions from file `big_numbers` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// TheMessage + TheMessage(TheMessage), + /// TheOtherMessage + TheOtherMessage(TheOtherMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + TheMessage::MESSAGE_ID => Messages::TheMessage(TheMessage::try_from(payload)?), + TheOtherMessage::MESSAGE_ID => Messages::TheOtherMessage(TheOtherMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// TheMessage +/// +/// - Extended ID: 57 (0x39) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TheMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TheMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x39)}); + + pub const THE_SIGNAL_MIN: i8 = 0_i8; + pub const THE_SIGNAL_MAX: i8 = 0_i8; + + /// Construct new TheMessage from values + pub fn new(the_signal: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_the_signal(the_signal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TheSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn the_signal(&self) -> i8 { + self.the_signal_raw() + } + + /// Get raw value of TheSignal + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn the_signal_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TheSignal + #[inline(always)] + pub fn set_the_signal(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TheMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TheMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TheMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TheMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TheOtherMessage +/// +/// - Standard ID: 42 (0x2a) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TheOtherMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TheOtherMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2a)}); + + pub const THE_SIGNAL_MIN: i8 = 0_i8; + pub const THE_SIGNAL_MAX: i8 = 0_i8; + + /// Construct new TheOtherMessage from values + pub fn new(the_signal: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_the_signal(the_signal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TheSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn the_signal(&self) -> i8 { + self.the_signal_raw() + } + + /// Get raw value of TheSignal + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn the_signal_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TheSignal + #[inline(always)] + pub fn set_the_signal(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TheOtherMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TheOtherMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TheOtherMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TheOtherMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/bus_comment.snap b/tests-snapshots/dbc-cantools/bus_comment.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/bus_comment.snap.rs b/tests-snapshots/dbc-cantools/bus_comment.snap.rs new file mode 100644 index 0000000..2325e3f --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment.snap.rs @@ -0,0 +1,665 @@ +// Generated code! +// +// Message definitions from file `bus_comment` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Extended ID: 1193046 (0x123456) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123456)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message1 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message1MultiplexorIndex::M8(Message1MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message1MultiplexorIndex::M24(Message1MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message1::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message1MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message1MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Message1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message1MultiplexorIndex { + M8(Message1MultiplexorM8), + M24(Message1MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/bus_comment_bare.snap b/tests-snapshots/dbc-cantools/bus_comment_bare.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment_bare.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/bus_comment_bare.snap.rs b/tests-snapshots/dbc-cantools/bus_comment_bare.snap.rs new file mode 100644 index 0000000..fcc0fe7 --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment_bare.snap.rs @@ -0,0 +1,78 @@ +// Generated code! +// +// Message definitions from file `bus_comment_bare` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/bus_comment_bare.snap.stderr b/tests-snapshots/dbc-cantools/bus_comment_bare.snap.stderr new file mode 100644 index 0000000..d4dbe8d --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment_bare.snap.stderr @@ -0,0 +1,13 @@ +error: unreachable expression + --> tests-snapshots/dbc-cantools/bus_comment_bare.snap.rs:44:9 + | +41 | let res = match id { + | ___________________- +42 | | id => return Err(CanError::UnknownMessageId(id)), +43 | | }; + | |_________- any code following this `match` expression is unreachable, as all arms diverge +44 | Ok(res) + | ^^^^^^^ unreachable expression + | + = note: `-D unreachable-code` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_code)]` diff --git a/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap b/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.rs b/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.rs new file mode 100644 index 0000000..da96041 --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.rs @@ -0,0 +1,78 @@ +// Generated code! +// +// Message definitions from file `bus_comment_bare_out` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.stderr b/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.stderr new file mode 100644 index 0000000..9b283ee --- /dev/null +++ b/tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.stderr @@ -0,0 +1,13 @@ +error: unreachable expression + --> tests-snapshots/dbc-cantools/bus_comment_bare_out.snap.rs:44:9 + | +41 | let res = match id { + | ___________________- +42 | | id => return Err(CanError::UnknownMessageId(id)), +43 | | }; + | |_________- any code following this `match` expression is unreachable, as all arms diverge +44 | Ok(res) + | ^^^^^^^ unreachable expression + | + = note: `-D unreachable-code` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_code)]` diff --git a/tests-snapshots/dbc-cantools/choices.snap b/tests-snapshots/dbc-cantools/choices.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/choices.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/choices.snap.rs b/tests-snapshots/dbc-cantools/choices.snap.rs new file mode 100644 index 0000000..7e79c83 --- /dev/null +++ b/tests-snapshots/dbc-cantools/choices.snap.rs @@ -0,0 +1,263 @@ +// Generated code! +// +// Message definitions from file `choices` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Foo + Foo(Foo), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Foo::MESSAGE_ID => Messages::Foo(Foo::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Foo +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Foo { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foo { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const FOO_MIN: i8 = -128_i8; + pub const FOO_MAX: i8 = 127_i8; + + /// Construct new Foo from values + pub fn new(foo: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_foo(foo)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Foo + /// + /// - Min: -128 + /// - Max: 127 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn foo(&self) -> FooFoo { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 6 => FooFoo::Reserved, + 5 => FooFoo::Reserved, + 4 => FooFoo::Unused2, + 3 => FooFoo::Unused, + 2 => FooFoo::Unused, + 1 => FooFoo::XÄ, + 0 => FooFoo::WithSpace, + -5 => FooFoo::ANegativeValue, + _ => FooFoo::_Other(self.foo_raw()), + } + } + + /// Get raw value of Foo + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn foo_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Foo + #[inline(always)] + pub fn set_foo(&mut self, value: i8) -> Result<(), CanError> { + if value < -128_i8 || 127_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foo { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foo { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Foo +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum FooFoo { + Reserved, + Reserved, + Unused2, + Unused, + Unused, + XÄ, + WithSpace, + ANegativeValue, + _Other(i8), +} + +impl From for i8 { + fn from(val: FooFoo) -> i8 { + match val { + FooFoo::Reserved => 6, + FooFoo::Reserved => 5, + FooFoo::Unused2 => 4, + FooFoo::Unused => 3, + FooFoo::Unused => 2, + FooFoo::XÄ => 1, + FooFoo::WithSpace => 0, + FooFoo::ANegativeValue => -5, + FooFoo::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/choices.snap.stderr b/tests-snapshots/dbc-cantools/choices.snap.stderr new file mode 100644 index 0000000..ab0c84c --- /dev/null +++ b/tests-snapshots/dbc-cantools/choices.snap.stderr @@ -0,0 +1,79 @@ +error[E0428]: the name `Reserved` is defined multiple times + --> tests-snapshots/dbc-cantools/choices.snap.rs:206:5 + | +205 | Reserved, + | -------- previous definition of the type `Reserved` here +206 | Reserved, + | ^^^^^^^^ `Reserved` redefined here + | + = note: `Reserved` must be defined only once in the type namespace of this enum + +error[E0428]: the name `Unused` is defined multiple times + --> tests-snapshots/dbc-cantools/choices.snap.rs:209:5 + | +208 | Unused, + | ------ previous definition of the type `Unused` here +209 | Unused, + | ^^^^^^ `Unused` redefined here + | + = note: `Unused` must be defined only once in the type namespace of this enum + +error[E0277]: the trait bound `u8: Neg` is not satisfied + --> tests-snapshots/dbc-cantools/choices.snap.rs:105:13 + | +105 | -5 => FooFoo::ANegativeValue, + | ^^ the trait `Neg` is not implemented for `u8` + | + = help: the following other types implement trait `Neg`: + &f128 + &f16 + &f32 + &f64 + &i128 + &i16 + &i32 + &i64 + and $N others + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/choices.snap.rs:220:13 + | +219 | FooFoo::Reserved => 6, + | ---------------- matches all the relevant values +220 | FooFoo::Reserved => 5, + | ^^^^^^^^^^^^^^^^ no value can reach this + | + = note: `-D unreachable-patterns` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_patterns)]` + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/choices.snap.rs:223:13 + | +222 | FooFoo::Unused => 3, + | -------------- matches all the relevant values +223 | FooFoo::Unused => 2, + | ^^^^^^^^^^^^^^ no value can reach this + +error[E0004]: non-exhaustive patterns: `FooFoo::Reserved` and `FooFoo::Unused` not covered + --> tests-snapshots/dbc-cantools/choices.snap.rs:218:15 + | +218 | match val { + | ^^^ patterns `FooFoo::Reserved` and `FooFoo::Unused` not covered + | +note: `FooFoo` defined here + --> tests-snapshots/dbc-cantools/choices.snap.rs:204:10 + | +204 | pub enum FooFoo { + | ^^^^^^ +205 | Reserved, +206 | Reserved, + | -------- not covered +... +209 | Unused, + | ------ not covered + = note: the matched value is of type `FooFoo` +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms + | +227 ~ FooFoo::_Other(x) => x, +228 ~ FooFoo::Reserved | FooFoo::Unused => todo!(), + | diff --git a/tests-snapshots/dbc-cantools/choices_issue_with_name.snap b/tests-snapshots/dbc-cantools/choices_issue_with_name.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/choices_issue_with_name.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/choices_issue_with_name.snap.rs b/tests-snapshots/dbc-cantools/choices_issue_with_name.snap.rs new file mode 100644 index 0000000..5d9b312 --- /dev/null +++ b/tests-snapshots/dbc-cantools/choices_issue_with_name.snap.rs @@ -0,0 +1,233 @@ +// Generated code! +// +// Message definitions from file `choices_issue_with_name` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// TestMessage + TestMessage(TestMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + TestMessage::MESSAGE_ID => Messages::TestMessage(TestMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// TestMessage +/// +/// - Extended ID: 589824 (0x90000) +/// - Size: 1 bytes +#[derive(Clone, Copy)] +pub struct TestMessage { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x90000)}); + + + /// Construct new TestMessage from values + pub fn new(signal_with_choices: bool) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_signal_with_choices(signal_with_choices)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// SignalWithChoices + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal_with_choices(&self) -> TestMessageSignalWithChoices { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + match signal { + 1 => TestMessageSignalWithChoices::SignalWithChoicesCmdRespOk, + 0 => TestMessageSignalWithChoices::SignalWithChoicesCmdRespErr, + _ => TestMessageSignalWithChoices::_Other(self.signal_with_choices_raw()), + } + } + + /// Get raw value of SignalWithChoices + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal_with_choices_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of SignalWithChoices + #[inline(always)] + pub fn set_signal_with_choices(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for SignalWithChoices +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum TestMessageSignalWithChoices { + SignalWithChoicesCmdRespOk, + SignalWithChoicesCmdRespErr, + _Other(bool), +} + +impl From for bool { + fn from(val: TestMessageSignalWithChoices) -> bool { + match val { + TestMessageSignalWithChoices::SignalWithChoicesCmdRespOk => true, + TestMessageSignalWithChoices::SignalWithChoicesCmdRespErr => false, + TestMessageSignalWithChoices::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/comments_hex_and_motorola_converted_from_sym.snap b/tests-snapshots/dbc-cantools/comments_hex_and_motorola_converted_from_sym.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/comments_hex_and_motorola_converted_from_sym.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/comments_hex_and_motorola_converted_from_sym.snap.rs b/tests-snapshots/dbc-cantools/comments_hex_and_motorola_converted_from_sym.snap.rs new file mode 100644 index 0000000..dd2ed83 --- /dev/null +++ b/tests-snapshots/dbc-cantools/comments_hex_and_motorola_converted_from_sym.snap.rs @@ -0,0 +1,873 @@ +// Generated code! +// +// Message definitions from file `comments_hex_and_motorola_converted_from_sym` +// Version: 6.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Msg1 + Msg1(Msg1), + /// Msg2 + Msg2(Msg2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Msg1::MESSAGE_ID => Messages::Msg1(Msg1::try_from(payload)?), + Msg2::MESSAGE_ID => Messages::Msg2(Msg2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Msg1 +/// +/// - Standard ID: 1568 (0x620) +/// - Size: 2 bytes +/// - Transmitter: Peripherals +#[derive(Clone, Copy)] +pub struct Msg1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x620)}); + + pub const SIG22_MIN: u8 = 0_u8; + pub const SIG22_MAX: u8 = 1_u8; + pub const SIG12_MIN: u8 = 0_u8; + pub const SIG12_MAX: u8 = 1_u8; + pub const SIG1_MIN: u8 = 0_u8; + pub const SIG1_MAX: u8 = 0_u8; + + /// Construct new Msg1 from values + pub fn new(sig1: u8) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_sig1(sig1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Get raw value of sig1 + /// + /// - Start bit: 7 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sig1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn sig1(&mut self) -> Result { + match self.sig1_raw() { + 1 => Ok(Msg1Sig1Index::M1(Msg1Sig1M1{ raw: self.raw })), + 2 => Ok(Msg1Sig1Index::M2(Msg1Sig1M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Msg1::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of sig1 + #[inline(always)] + fn set_sig1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_be(value); + Ok(()) + } + + /// Set value of sig1 + #[inline(always)] + pub fn set_m1(&mut self, value: Msg1Sig1M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sig1(1)?; + Ok(()) + } + + /// Set value of sig1 + #[inline(always)] + pub fn set_m2(&mut self, value: Msg1Sig1M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sig1(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Msg1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Msg1Sig1Index { + M1(Msg1Sig1M1), + M2(Msg1Sig1M2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Msg1Sig1M1 { raw: [u8; 2] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg1Sig1M1 { +pub fn new() -> Self { Self { raw: [0u8; 2] } } +/// sig12 +/// +/// another comment for sig1=1 +/// +/// - Min: 0 +/// - Max: 1 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sig12(&self) -> u8 { + self.sig12_raw() +} + +/// Get raw value of sig12 +/// +/// - Start bit: 15 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: BigEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sig12_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of sig12 +#[inline(always)] +pub fn set_sig12(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 1_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Msg1Sig1M2 { raw: [u8; 2] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg1Sig1M2 { +pub fn new() -> Self { Self { raw: [0u8; 2] } } +/// sig22 +/// +/// another comment for sig1=2 +/// +/// - Min: 0 +/// - Max: 1 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn sig22(&self) -> u8 { + self.sig22_raw() +} + +/// Get raw value of sig22 +/// +/// - Start bit: 15 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: BigEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sig22_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of sig22 +#[inline(always)] +pub fn set_sig22(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 1_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) +} + +} + + +/// Msg2 +/// +/// - Standard ID: 1365 (0x555) +/// - Size: 8 bytes +/// - Transmitter: ECU +/// +/// test +#[derive(Clone, Copy)] +pub struct Msg2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x555)}); + + pub const TEST7_MIN: u8 = 0_u8; + pub const TEST7_MAX: u8 = 0_u8; + pub const TEST6_MIN: u8 = 0_u8; + pub const TEST6_MAX: u8 = 0_u8; + pub const TEST5_MIN: u8 = 0_u8; + pub const TEST5_MAX: u8 = 0_u8; + pub const TEST4_MIN: u8 = 0_u8; + pub const TEST4_MAX: u8 = 0_u8; + pub const TEST3_MIN: u8 = 0_u8; + pub const TEST3_MAX: u8 = 0_u8; + pub const TEST2_MIN: u8 = 0_u8; + pub const TEST2_MAX: u8 = 0_u8; + pub const TEST1_MIN: u8 = 0_u8; + pub const TEST1_MAX: u8 = 0_u8; + pub const TEST0_MIN: u8 = 0_u8; + pub const TEST0_MAX: u8 = 0_u8; + + /// Construct new Msg2 from values + pub fn new(test7: u8, test6: u8, test5: u8, test4: u8, test3: u8, test2: u8, test1: u8, test0: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test7(test7)?; + res.set_test6(test6)?; + res.set_test5(test5)?; + res.set_test4(test4)?; + res.set_test3(test3)?; + res.set_test2(test2)?; + res.set_test1(test1)?; + res.set_test0(test0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Test7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test7(&self) -> Msg2Test7 { + let signal = self.raw.view_bits::()[56..64].load_be::(); + + match signal { + 1 => Msg2Test7::A, + 2 => Msg2Test7::B, + 3 => Msg2Test7::C, + 4 => Msg2Test7::D, + _ => Msg2Test7::_Other(self.test7_raw()), + } + } + + /// Get raw value of Test7 + /// + /// - Start bit: 63 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test7_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test7 + #[inline(always)] + pub fn set_test7(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_be(value); + Ok(()) + } + + /// Test6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test6(&self) -> u8 { + self.test6_raw() + } + + /// Get raw value of Test6 + /// + /// - Start bit: 55 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test6_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test6 + #[inline(always)] + pub fn set_test6(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_be(value); + Ok(()) + } + + /// Test5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test5(&self) -> u8 { + self.test5_raw() + } + + /// Get raw value of Test5 + /// + /// - Start bit: 47 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test5_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test5 + #[inline(always)] + pub fn set_test5(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_be(value); + Ok(()) + } + + /// Test4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test4(&self) -> u8 { + self.test4_raw() + } + + /// Get raw value of Test4 + /// + /// - Start bit: 39 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test4_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test4 + #[inline(always)] + pub fn set_test4(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_be(value); + Ok(()) + } + + /// Test3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test3(&self) -> u8 { + self.test3_raw() + } + + /// Get raw value of Test3 + /// + /// - Start bit: 31 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test3_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test3 + #[inline(always)] + pub fn set_test3(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_be(value); + Ok(()) + } + + /// Test2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test2(&self) -> u8 { + self.test2_raw() + } + + /// Get raw value of Test2 + /// + /// - Start bit: 23 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test2 + #[inline(always)] + pub fn set_test2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_be(value); + Ok(()) + } + + /// Test1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test1(&self) -> u8 { + self.test1_raw() + } + + /// Get raw value of Test1 + /// + /// - Start bit: 15 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test1 + #[inline(always)] + pub fn set_test1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) + } + + /// Test0 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test0(&self) -> u8 { + self.test0_raw() + } + + /// Get raw value of Test0 + /// + /// - Start bit: 7 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn test0_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Test0 + #[inline(always)] + pub fn set_test0(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Test7 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Msg2Test7 { + A, + B, + C, + D, + _Other(u8), +} + +impl From for u8 { + fn from(val: Msg2Test7) -> u8 { + match val { + Msg2Test7::A => 1, + Msg2Test7::B => 2, + Msg2Test7::C => 3, + Msg2Test7::D => 4, + Msg2Test7::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/cp1252.snap b/tests-snapshots/dbc-cantools/cp1252.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/cp1252.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/cp1252.snap.rs b/tests-snapshots/dbc-cantools/cp1252.snap.rs new file mode 100644 index 0000000..4ca731d --- /dev/null +++ b/tests-snapshots/dbc-cantools/cp1252.snap.rs @@ -0,0 +1,78 @@ +// Generated code! +// +// Message definitions from file `cp1252` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/cp1252.snap.stderr b/tests-snapshots/dbc-cantools/cp1252.snap.stderr new file mode 100644 index 0000000..325894a --- /dev/null +++ b/tests-snapshots/dbc-cantools/cp1252.snap.stderr @@ -0,0 +1,13 @@ +error: unreachable expression + --> tests-snapshots/dbc-cantools/cp1252.snap.rs:44:9 + | +41 | let res = match id { + | ___________________- +42 | | id => return Err(CanError::UnknownMessageId(id)), +43 | | }; + | |_________- any code following this `match` expression is unreachable, as all arms diverge +44 | Ok(res) + | ^^^^^^^ unreachable expression + | + = note: `-D unreachable-code` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_code)]` diff --git a/tests-snapshots/dbc-cantools/dump_signal_choices.snap b/tests-snapshots/dbc-cantools/dump_signal_choices.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/dump_signal_choices.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/dump_signal_choices.snap.rs b/tests-snapshots/dbc-cantools/dump_signal_choices.snap.rs new file mode 100644 index 0000000..b501709 --- /dev/null +++ b/tests-snapshots/dbc-cantools/dump_signal_choices.snap.rs @@ -0,0 +1,346 @@ +// Generated code! +// +// Message definitions from file `dump_signal_choices` +// Version: HIPBNYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY/4/%%%/4/'%**4YYY/// + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message0 + Message0(Message0), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message0::MESSAGE_ID => Messages::Message0(Message0::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message0 +/// +/// - Standard ID: 1024 (0x400) +/// - Size: 8 bytes +/// - Transmitter: Node0 +#[derive(Clone, Copy)] +pub struct Message0 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message0 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x400)}); + + pub const FOO_SIGNAL_MIN: u8 = 0_u8; + pub const FOO_SIGNAL_MAX: u8 = 0_u8; + pub const BAR_SIGNAL_MIN: u8 = 0_u8; + pub const BAR_SIGNAL_MAX: u8 = 0_u8; + + /// Construct new Message0 from values + pub fn new(foo_signal: u8, bar_signal: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_foo_signal(foo_signal)?; + res.set_bar_signal(bar_signal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// FooSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn foo_signal(&self) -> Message0FooSignal { + let signal = self.raw.view_bits::()[0..2].load_le::(); + + match signal { + 0 => Message0FooSignal::FooA, + 1 => Message0FooSignal::FooB, + 2 => Message0FooSignal::FooC, + 3 => Message0FooSignal::FooD, + _ => Message0FooSignal::_Other(self.foo_signal_raw()), + } + } + + /// Get raw value of FooSignal + /// + /// - Start bit: 0 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn foo_signal_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..2].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of FooSignal + #[inline(always)] + pub fn set_foo_signal(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message0::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message0::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..2].store_le(value); + Ok(()) + } + + /// BarSignal + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn bar_signal(&self) -> Message0BarSignal { + let signal = self.raw.view_bits::()[2..5].load_le::(); + + match signal { + 0 => Message0BarSignal::BarA, + 1 => Message0BarSignal::BarB, + 2 => Message0BarSignal::BarC, + 3 => Message0BarSignal::BarD, + 4 => Message0BarSignal::BarE, + 5 => Message0BarSignal::BarF, + 6 => Message0BarSignal::BarG, + 7 => Message0BarSignal::BarH, + _ => Message0BarSignal::_Other(self.bar_signal_raw()), + } + } + + /// Get raw value of BarSignal + /// + /// - Start bit: 2 + /// - Signal size: 3 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn bar_signal_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..5].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of BarSignal + #[inline(always)] + pub fn set_bar_signal(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message0::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message0::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..5].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message0 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message0 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for FooSignal +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message0FooSignal { + FooA, + FooB, + FooC, + FooD, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message0FooSignal) -> u8 { + match val { + Message0FooSignal::FooA => 0, + Message0FooSignal::FooB => 1, + Message0FooSignal::FooC => 2, + Message0FooSignal::FooD => 3, + Message0FooSignal::_Other(x) => x, + } + } +} + +/// Defined values for BarSignal +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message0BarSignal { + BarA, + BarB, + BarC, + BarD, + BarE, + BarF, + BarG, + BarH, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message0BarSignal) -> u8 { + match val { + Message0BarSignal::BarA => 0, + Message0BarSignal::BarB => 1, + Message0BarSignal::BarC => 2, + Message0BarSignal::BarD => 3, + Message0BarSignal::BarE => 4, + Message0BarSignal::BarF => 5, + Message0BarSignal::BarG => 6, + Message0BarSignal::BarH => 7, + Message0BarSignal::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/emc32.snap b/tests-snapshots/dbc-cantools/emc32.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/emc32.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/emc32.snap.rs b/tests-snapshots/dbc-cantools/emc32.snap.rs new file mode 100644 index 0000000..a46163f --- /dev/null +++ b/tests-snapshots/dbc-cantools/emc32.snap.rs @@ -0,0 +1,341 @@ +// Generated code! +// +// Message definitions from file `emc32` +// Version: HINBNYYYYYYYYYYYYYYYYYYYYYYYYYYYNNNNNNNNNN/4/%%%/4/'%**4NNN/// + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// EMV_Stati + EmvStati(EmvStati), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + EmvStati::MESSAGE_ID => Messages::EmvStati(EmvStati::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// EMV_Stati +/// +/// - Standard ID: 546 (0x222) +/// - Size: 8 bytes +/// - Transmitter: EMV_Statusmeldungen +#[derive(Clone, Copy)] +pub struct EmvStati { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl EmvStati { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x222)}); + + + /// Construct new EMV_Stati from values + pub fn new(emv_aktion_status_5: bool, emv_aktion_status_4: bool, emv_aktion_status_3: bool, emv_aktion_status_2: bool, emv_aktion_status_1: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_emv_aktion_status_5(emv_aktion_status_5)?; + res.set_emv_aktion_status_4(emv_aktion_status_4)?; + res.set_emv_aktion_status_3(emv_aktion_status_3)?; + res.set_emv_aktion_status_2(emv_aktion_status_2)?; + res.set_emv_aktion_status_1(emv_aktion_status_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// EMV_Aktion_Status_5 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn emv_aktion_status_5(&self) -> bool { + self.emv_aktion_status_5_raw() + } + + /// Get raw value of EMV_Aktion_Status_5 + /// + /// - Start bit: 4 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn emv_aktion_status_5_raw(&self) -> bool { + let signal = self.raw.view_bits::()[4..5].load_le::(); + + signal == 1 + } + + /// Set value of EMV_Aktion_Status_5 + #[inline(always)] + pub fn set_emv_aktion_status_5(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[4..5].store_le(value); + Ok(()) + } + + /// EMV_Aktion_Status_4 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn emv_aktion_status_4(&self) -> bool { + self.emv_aktion_status_4_raw() + } + + /// Get raw value of EMV_Aktion_Status_4 + /// + /// - Start bit: 3 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn emv_aktion_status_4_raw(&self) -> bool { + let signal = self.raw.view_bits::()[3..4].load_le::(); + + signal == 1 + } + + /// Set value of EMV_Aktion_Status_4 + #[inline(always)] + pub fn set_emv_aktion_status_4(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[3..4].store_le(value); + Ok(()) + } + + /// EMV_Aktion_Status_3 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: EMV_Statusmeldungen + #[inline(always)] + pub fn emv_aktion_status_3(&self) -> bool { + self.emv_aktion_status_3_raw() + } + + /// Get raw value of EMV_Aktion_Status_3 + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn emv_aktion_status_3_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of EMV_Aktion_Status_3 + #[inline(always)] + pub fn set_emv_aktion_status_3(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// EMV_Aktion_Status_2 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn emv_aktion_status_2(&self) -> bool { + self.emv_aktion_status_2_raw() + } + + /// Get raw value of EMV_Aktion_Status_2 + /// + /// - Start bit: 6 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn emv_aktion_status_2_raw(&self) -> bool { + let signal = self.raw.view_bits::()[6..7].load_le::(); + + signal == 1 + } + + /// Set value of EMV_Aktion_Status_2 + #[inline(always)] + pub fn set_emv_aktion_status_2(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[6..7].store_le(value); + Ok(()) + } + + /// EMV_Aktion_Status_1 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn emv_aktion_status_1(&self) -> bool { + self.emv_aktion_status_1_raw() + } + + /// Get raw value of EMV_Aktion_Status_1 + /// + /// - Start bit: 5 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn emv_aktion_status_1_raw(&self) -> bool { + let signal = self.raw.view_bits::()[5..6].load_le::(); + + signal == 1 + } + + /// Set value of EMV_Aktion_Status_1 + #[inline(always)] + pub fn set_emv_aktion_status_1(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[5..6].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for EmvStati { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for EmvStati { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/empty_choice.snap b/tests-snapshots/dbc-cantools/empty_choice.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/empty_choice.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/empty_choice.snap.rs b/tests-snapshots/dbc-cantools/empty_choice.snap.rs new file mode 100644 index 0000000..54342b4 --- /dev/null +++ b/tests-snapshots/dbc-cantools/empty_choice.snap.rs @@ -0,0 +1,367 @@ +// Generated code! +// +// Message definitions from file `empty_choice` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// example_message + ExampleMessage(ExampleMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExampleMessage::MESSAGE_ID => Messages::ExampleMessage(ExampleMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// example_message +/// +/// - Standard ID: 10 (0xa) +/// - Size: 3 bytes +/// - Transmitter: tx_node +#[derive(Clone, Copy)] +pub struct ExampleMessage { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExampleMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xa)}); + + pub const NO_CHOICE_MIN: i8 = 0_i8; + pub const NO_CHOICE_MAX: i8 = 0_i8; + pub const EMPTY_CHOICE_MIN: i8 = 0_i8; + pub const EMPTY_CHOICE_MAX: i8 = 0_i8; + pub const NON_EMPTY_CHOICE_MIN: i8 = 0_i8; + pub const NON_EMPTY_CHOICE_MAX: i8 = 0_i8; + + /// Construct new example_message from values + pub fn new(no_choice: i8, empty_choice: i8, non_empty_choice: i8) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_no_choice(no_choice)?; + res.set_empty_choice(empty_choice)?; + res.set_non_empty_choice(non_empty_choice)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// no_choice + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn no_choice(&self) -> i8 { + self.no_choice_raw() + } + + /// Get raw value of no_choice + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn no_choice_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of no_choice + #[inline(always)] + pub fn set_no_choice(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// empty_choice + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn empty_choice(&self) -> ExampleMessageEmptyChoice { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + _ => ExampleMessageEmptyChoice::_Other(self.empty_choice_raw()), + } + } + + /// Get raw value of empty_choice + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn empty_choice_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of empty_choice + #[inline(always)] + pub fn set_empty_choice(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// non_empty_choice + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn non_empty_choice(&self) -> ExampleMessageNonEmptyChoice { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 255 => ExampleMessageNonEmptyChoice::NotAvailable, + 254 => ExampleMessageNonEmptyChoice::Error, + _ => ExampleMessageNonEmptyChoice::_Other(self.non_empty_choice_raw()), + } + } + + /// Get raw value of non_empty_choice + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn non_empty_choice_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of non_empty_choice + #[inline(always)] + pub fn set_non_empty_choice(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExampleMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExampleMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for empty_choice +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageEmptyChoice { + _Other(i8), +} + +impl From for i8 { + fn from(val: ExampleMessageEmptyChoice) -> i8 { + match val { + ExampleMessageEmptyChoice::_Other(x) => x, + } + } +} + +/// Defined values for non_empty_choice +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageNonEmptyChoice { + NotAvailable, + Error, + _Other(i8), +} + +impl From for i8 { + fn from(val: ExampleMessageNonEmptyChoice) -> i8 { + match val { + ExampleMessageNonEmptyChoice::NotAvailable => 255, + ExampleMessageNonEmptyChoice::Error => 254, + ExampleMessageNonEmptyChoice::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/empty_choice.snap.stderr b/tests-snapshots/dbc-cantools/empty_choice.snap.stderr new file mode 100644 index 0000000..a1c2534 --- /dev/null +++ b/tests-snapshots/dbc-cantools/empty_choice.snap.stderr @@ -0,0 +1,18 @@ +error: literal out of range for `i8` + --> tests-snapshots/dbc-cantools/empty_choice.snap.rs:329:59 + | +329 | ExampleMessageNonEmptyChoice::NotAvailable => 255, + | ^^^ + | + = note: the literal `255` does not fit into the type `i8` whose range is `-128..=127` + = help: consider using the type `u8` instead + = note: `#[deny(overflowing_literals)]` on by default + +error: literal out of range for `i8` + --> tests-snapshots/dbc-cantools/empty_choice.snap.rs:330:52 + | +330 | ExampleMessageNonEmptyChoice::Error => 254, + | ^^^ + | + = note: the literal `254` does not fit into the type `i8` whose range is `-128..=127` + = help: consider using the type `u8` instead diff --git a/tests-snapshots/dbc-cantools/empty_ns.snap b/tests-snapshots/dbc-cantools/empty_ns.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/empty_ns.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/empty_ns.snap.rs b/tests-snapshots/dbc-cantools/empty_ns.snap.rs new file mode 100644 index 0000000..65e2a1f --- /dev/null +++ b/tests-snapshots/dbc-cantools/empty_ns.snap.rs @@ -0,0 +1,78 @@ +// Generated code! +// +// Message definitions from file `empty_ns` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/empty_ns.snap.stderr b/tests-snapshots/dbc-cantools/empty_ns.snap.stderr new file mode 100644 index 0000000..adbca62 --- /dev/null +++ b/tests-snapshots/dbc-cantools/empty_ns.snap.stderr @@ -0,0 +1,13 @@ +error: unreachable expression + --> tests-snapshots/dbc-cantools/empty_ns.snap.rs:44:9 + | +41 | let res = match id { + | ___________________- +42 | | id => return Err(CanError::UnknownMessageId(id)), +43 | | }; + | |_________- any code following this `match` expression is unreachable, as all arms diverge +44 | Ok(res) + | ^^^^^^^ unreachable expression + | + = note: `-D unreachable-code` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_code)]` diff --git a/tests-snapshots/dbc-cantools/fd_test.snap b/tests-snapshots/dbc-cantools/fd_test.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/fd_test.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/fd_test.snap.rs b/tests-snapshots/dbc-cantools/fd_test.snap.rs new file mode 100644 index 0000000..87b4fa2 --- /dev/null +++ b/tests-snapshots/dbc-cantools/fd_test.snap.rs @@ -0,0 +1,614 @@ +// Generated code! +// +// Message definitions from file `fd_test` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// TestMsg_Ex + TestMsgEx(TestMsgEx), + /// TestMsg_Std + TestMsgStd(TestMsgStd), + /// TestMsg_FDStd + TestMsgFdStd(TestMsgFdStd), + /// TestMsg_FDEx + TestMsgFdEx(TestMsgFdEx), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + TestMsgEx::MESSAGE_ID => Messages::TestMsgEx(TestMsgEx::try_from(payload)?), + TestMsgStd::MESSAGE_ID => Messages::TestMsgStd(TestMsgStd::try_from(payload)?), + TestMsgFdStd::MESSAGE_ID => Messages::TestMsgFdStd(TestMsgFdStd::try_from(payload)?), + TestMsgFdEx::MESSAGE_ID => Messages::TestMsgFdEx(TestMsgFdEx::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// TestMsg_Ex +/// +/// - Extended ID: 3 (0x3) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TestMsgEx { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMsgEx { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x3)}); + + pub const TEST_SIG_COPY_1_MIN: i8 = 0_i8; + pub const TEST_SIG_COPY_1_MAX: i8 = 0_i8; + + /// Construct new TestMsg_Ex from values + pub fn new(test_sig_copy_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig_copy_1(test_sig_copy_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig_Copy_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test_sig_copy_1(&self) -> i8 { + self.test_sig_copy_1_raw() + } + + /// Get raw value of TestSig_Copy_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_copy_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig_Copy_1 + #[inline(always)] + pub fn set_test_sig_copy_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMsgEx::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMsgEx::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMsgEx { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMsgEx { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TestMsg_Std +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TestMsgStd { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMsgStd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const TEST_SIG_COPY_3_MIN: i8 = 0_i8; + pub const TEST_SIG_COPY_3_MAX: i8 = 0_i8; + + /// Construct new TestMsg_Std from values + pub fn new(test_sig_copy_3: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig_copy_3(test_sig_copy_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig_Copy_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test_sig_copy_3(&self) -> i8 { + self.test_sig_copy_3_raw() + } + + /// Get raw value of TestSig_Copy_3 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_copy_3_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig_Copy_3 + #[inline(always)] + pub fn set_test_sig_copy_3(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMsgStd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMsgStd::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMsgStd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMsgStd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TestMsg_FDStd +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TestMsgFdStd { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMsgFdStd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const TEST_SIG_COPY_2_MIN: i8 = 0_i8; + pub const TEST_SIG_COPY_2_MAX: i8 = 0_i8; + + /// Construct new TestMsg_FDStd from values + pub fn new(test_sig_copy_2: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig_copy_2(test_sig_copy_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig_Copy_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test_sig_copy_2(&self) -> i8 { + self.test_sig_copy_2_raw() + } + + /// Get raw value of TestSig_Copy_2 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_copy_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig_Copy_2 + #[inline(always)] + pub fn set_test_sig_copy_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMsgFdStd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMsgFdStd::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMsgFdStd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMsgFdStd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TestMsg_FDEx +/// +/// - Extended ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct TestMsgFdEx { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMsgFdEx { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x0)}); + + pub const TEST_SIG_MIN: i8 = 0_i8; + pub const TEST_SIG_MAX: i8 = 0_i8; + + /// Construct new TestMsg_FDEx from values + pub fn new(test_sig: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig(test_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn test_sig(&self) -> i8 { + self.test_sig_raw() + } + + /// Get raw value of TestSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig + #[inline(always)] + pub fn set_test_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMsgFdEx::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMsgFdEx::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMsgFdEx { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMsgFdEx { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/floating_point.snap b/tests-snapshots/dbc-cantools/floating_point.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/floating_point.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/floating_point.snap.rs b/tests-snapshots/dbc-cantools/floating_point.snap.rs new file mode 100644 index 0000000..e82a901 --- /dev/null +++ b/tests-snapshots/dbc-cantools/floating_point.snap.rs @@ -0,0 +1,395 @@ +// Generated code! +// +// Message definitions from file `floating_point` +// Version: HIPBNYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY/4/%%%/4/'%**4YYY/// + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), + /// Message2 + Message2(Message2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Standard ID: 1024 (0x400) +/// - Size: 8 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x400)}); + + pub const SIGNAL1_MIN: i64 = 0_i64; + pub const SIGNAL1_MAX: i64 = 0_i64; + + /// Construct new Message1 from values + pub fn new(signal1: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal1(&self) -> i64 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal1_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..64].load_le::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message2 +/// +/// - Standard ID: 1025 (0x401) +/// - Size: 8 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x401)}); + + pub const SIGNAL2_MIN: i32 = 0_i32; + pub const SIGNAL2_MAX: i32 = 0_i32; + pub const SIGNAL1_MIN: i32 = 0_i32; + pub const SIGNAL1_MAX: i32 = 0_i32; + + /// Construct new Message2 from values + pub fn new(signal2: i32, signal1: i32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal2(signal2)?; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal2(&self) -> i32 { + self.signal2_raw() + } + + /// Get raw value of Signal2 + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal2_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal2 + #[inline(always)] + pub fn set_signal2(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal1(&self) -> i32 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal1_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/floating_point_use_float.snap b/tests-snapshots/dbc-cantools/floating_point_use_float.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/floating_point_use_float.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/floating_point_use_float.snap.rs b/tests-snapshots/dbc-cantools/floating_point_use_float.snap.rs new file mode 100644 index 0000000..cde0444 --- /dev/null +++ b/tests-snapshots/dbc-cantools/floating_point_use_float.snap.rs @@ -0,0 +1,527 @@ +// Generated code! +// +// Message definitions from file `floating_point_use_float` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), + /// Message2 + Message2(Message2), + /// Message3 + Message3(Message3), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + Message3::MESSAGE_ID => Messages::Message3(Message3::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Standard ID: 1024 (0x400) +/// - Size: 8 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x400)}); + + pub const SIGNAL1_MIN: i64 = 0_i64; + pub const SIGNAL1_MAX: i64 = 0_i64; + + /// Construct new Message1 from values + pub fn new(signal1: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal1(&self) -> i64 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal1_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..64].load_le::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message2 +/// +/// - Standard ID: 1025 (0x401) +/// - Size: 8 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x401)}); + + pub const SIGNAL2_MIN: i32 = 0_i32; + pub const SIGNAL2_MAX: i32 = 0_i32; + pub const SIGNAL1_MIN: i32 = 0_i32; + pub const SIGNAL1_MAX: i32 = 0_i32; + + /// Construct new Message2 from values + pub fn new(signal2: i32, signal1: i32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal2(signal2)?; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal2(&self) -> i32 { + self.signal2_raw() + } + + /// Get raw value of Signal2 + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal2_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal2 + #[inline(always)] + pub fn set_signal2(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal1(&self) -> i32 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal1_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message3 +/// +/// - Standard ID: 1026 (0x402) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message3 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x402)}); + + pub const SIGNAL3_MIN: f32 = 0_f32; + pub const SIGNAL3_MAX: f32 = 0_f32; + + /// Construct new Message3 from values + pub fn new(signal3: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal3(signal3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal3(&self) -> f32 { + self.signal3_raw() + } + + /// Get raw value of Signal3 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 0.001 + /// - Offset: -0.125 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 0.001_f32; + let offset = -0.125_f32; + (signal as f32) * factor + offset + } + + /// Set value of Signal3 + #[inline(always)] + pub fn set_signal3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message3::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = -0.125_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/foobar.snap b/tests-snapshots/dbc-cantools/foobar.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/foobar.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/foobar.snap.rs b/tests-snapshots/dbc-cantools/foobar.snap.rs new file mode 100644 index 0000000..d6dbd73 --- /dev/null +++ b/tests-snapshots/dbc-cantools/foobar.snap.rs @@ -0,0 +1,925 @@ +// Generated code! +// +// Message definitions from file `foobar` +// Version: 2.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Foo + Foo(Foo), + /// Fum + Fum(Fum), + /// Bar + Bar(Bar), + /// CanFd + CanFd(CanFd), + /// FOOBAR + Foobar(Foobar), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Foo::MESSAGE_ID => Messages::Foo(Foo::try_from(payload)?), + Fum::MESSAGE_ID => Messages::Fum(Fum::try_from(payload)?), + Bar::MESSAGE_ID => Messages::Bar(Bar::try_from(payload)?), + CanFd::MESSAGE_ID => Messages::CanFd(CanFd::try_from(payload)?), + Foobar::MESSAGE_ID => Messages::Foobar(Foobar::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Foo +/// +/// - Extended ID: 74544 (0x12330) +/// - Size: 8 bytes +/// - Transmitter: FOO +/// +/// Foo. +#[derive(Clone, Copy)] +pub struct Foo { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foo { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12330)}); + + pub const FOO_MIN: f32 = 229.53_f32; + pub const FOO_MAX: f32 = 270.47_f32; + pub const BAR_MIN: f32 = 0_f32; + pub const BAR_MAX: f32 = 5_f32; + + /// Construct new Foo from values + pub fn new(foo: f32, bar: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_foo(foo)?; + res.set_bar(bar)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Foo + /// + /// - Min: 229.53 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: BAR + #[inline(always)] + pub fn foo(&self) -> f32 { + self.foo_raw() + } + + /// Get raw value of Foo + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn foo_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Foo + #[inline(always)] + pub fn set_foo(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.53_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + + /// Bar + /// + /// Bar. + /// + /// - Min: 0 + /// - Max: 5 + /// - Unit: "m" + /// - Receivers: FOO + #[inline(always)] + pub fn bar(&self) -> f32 { + self.bar_raw() + } + + /// Get raw value of Bar + /// + /// - Start bit: 24 + /// - Signal size: 32 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn bar_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[31..63].load_be::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Bar + #[inline(always)] + pub fn set_bar(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[31..63].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foo { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foo { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Fum +/// +/// - Extended ID: 74545 (0x12331) +/// - Size: 5 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct Fum { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Fum { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12331)}); + + pub const FUM_MIN: i16 = 0_i16; + pub const FUM_MAX: i16 = 10_i16; + pub const FAM_MIN: i16 = 0_i16; + pub const FAM_MAX: i16 = 8_i16; + + /// Construct new Fum from values + pub fn new(fum: i16, fam: i16) -> Result { + let mut res = Self { raw: [0u8; 5] }; + res.set_fum(fum)?; + res.set_fam(fam)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + + /// Fum + /// + /// - Min: 0 + /// - Max: 10 + /// - Unit: "" + /// - Receivers: BAR + #[inline(always)] + pub fn fum(&self) -> i16 { + self.fum_raw() + } + + /// Get raw value of Fum + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn fum_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..12].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fum + #[inline(always)] + pub fn set_fum(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 10_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..12].store_le(value); + Ok(()) + } + + /// Fam + /// + /// - Min: 0 + /// - Max: 8 + /// - Unit: "" + /// - Receivers: BAR + #[inline(always)] + pub fn fam(&self) -> FumFam { + let signal = self.raw.view_bits::()[12..24].load_le::(); + + match signal { + 1 => FumFam::Enabled, + 0 => FumFam::Disabled, + _ => FumFam::_Other(self.fam_raw()), + } + } + + /// Get raw value of Fam + /// + /// - Start bit: 12 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn fam_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[12..24].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fam + #[inline(always)] + pub fn set_fam(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 8_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[12..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Fum { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Fum { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Fam +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum FumFam { + Enabled, + Disabled, + _Other(i16), +} + +impl From for i16 { + fn from(val: FumFam) -> i16 { + match val { + FumFam::Enabled => 1, + FumFam::Disabled => 0, + FumFam::_Other(x) => x, + } + } +} + + +/// Bar +/// +/// - Extended ID: 74546 (0x12332) +/// - Size: 4 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct Bar { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bar { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12332)}); + + pub const BINARY32_MIN: i32 = 0_i32; + pub const BINARY32_MAX: i32 = 0_i32; + + /// Construct new Bar from values + pub fn new(binary32: i32) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_binary32(binary32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// Binary32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: FUM + #[inline(always)] + pub fn binary32(&self) -> i32 { + self.binary32_raw() + } + + /// Get raw value of Binary32 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn binary32_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Binary32 + #[inline(always)] + pub fn set_binary32(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bar { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bar { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// CanFd +/// +/// - Extended ID: 74547 (0x12333) +/// - Size: 64 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct CanFd { + raw: [u8; 64], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CanFd { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12333)}); + + pub const FIE_MIN: u64 = 0_u64; + pub const FIE_MAX: u64 = 0_u64; + pub const FAS_MIN: u64 = 0_u64; + pub const FAS_MAX: u64 = 0_u64; + + /// Construct new CanFd from values + pub fn new(fie: u64, fas: u64) -> Result { + let mut res = Self { raw: [0u8; 64] }; + res.set_fie(fie)?; + res.set_fas(fas)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 64] { + &self.raw + } + + /// Fie + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: FUM + #[inline(always)] + pub fn fie(&self) -> u64 { + self.fie_raw() + } + + /// Get raw value of Fie + /// + /// - Start bit: 0 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn fie_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[0..64].load_le::(); + + let factor = 1; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fie + #[inline(always)] + pub fn set_fie(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 0_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID })?; + let value = (value / factor) as u64; + + self.raw.view_bits_mut::()[0..64].store_le(value); + Ok(()) + } + + /// Fas + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn fas(&self) -> u64 { + self.fas_raw() + } + + /// Get raw value of Fas + /// + /// - Start bit: 64 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn fas_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[64..128].load_le::(); + + let factor = 1; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fas + #[inline(always)] + pub fn set_fas(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 0_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID })?; + let value = (value / factor) as u64; + + self.raw.view_bits_mut::()[64..128].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CanFd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 64 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 64]; + raw.copy_from_slice(&payload[..64]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CanFd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// FOOBAR +/// +/// - Standard ID: 780 (0x30c) +/// - Size: 8 bytes +/// - Transmitter: FIE +#[derive(Clone, Copy)] +pub struct Foobar { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foobar { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x30c)}); + + pub const ACC_02_CRC_MIN: i16 = 0_i16; + pub const ACC_02_CRC_MAX: i16 = 1_i16; + + /// Construct new FOOBAR from values + pub fn new(acc_02_crc: i16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_acc_02_crc(acc_02_crc)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// ACC_02_CRC + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: BAR + #[inline(always)] + pub fn acc_02_crc(&self) -> i16 { + self.acc_02_crc_raw() + } + + /// Get raw value of ACC_02_CRC + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn acc_02_crc_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..12].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ACC_02_CRC + #[inline(always)] + pub fn set_acc_02_crc(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 1_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foobar::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Foobar::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..12].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foobar { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foobar { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_163_newline.snap b/tests-snapshots/dbc-cantools/issue_163_newline.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_163_newline.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_163_newline.snap.rs b/tests-snapshots/dbc-cantools/issue_163_newline.snap.rs new file mode 100644 index 0000000..31af47d --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_163_newline.snap.rs @@ -0,0 +1,166 @@ +// Generated code! +// +// Message definitions from file `issue_163_newline` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// dummy_msg + DummyMsg(DummyMsg), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DummyMsg::MESSAGE_ID => Messages::DummyMsg(DummyMsg::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// dummy_msg +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +/// - Transmitter: dummy_node +#[derive(Clone, Copy)] +pub struct DummyMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DummyMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + + /// Construct new dummy_msg from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for DummyMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DummyMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_168.snap b/tests-snapshots/dbc-cantools/issue_168.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_168.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_168.snap.rs b/tests-snapshots/dbc-cantools/issue_168.snap.rs new file mode 100644 index 0000000..1a6886d --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_168.snap.rs @@ -0,0 +1,925 @@ +// Generated code! +// +// Message definitions from file `issue_168` +// Version: 2.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Foo + Foo(Foo), + /// Fum + Fum(Fum), + /// Bar + Bar(Bar), + /// CanFd + CanFd(CanFd), + /// FOOBAR + Foobar(Foobar), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Foo::MESSAGE_ID => Messages::Foo(Foo::try_from(payload)?), + Fum::MESSAGE_ID => Messages::Fum(Fum::try_from(payload)?), + Bar::MESSAGE_ID => Messages::Bar(Bar::try_from(payload)?), + CanFd::MESSAGE_ID => Messages::CanFd(CanFd::try_from(payload)?), + Foobar::MESSAGE_ID => Messages::Foobar(Foobar::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Foo +/// +/// - Extended ID: 74544 (0x12330) +/// - Size: 8 bytes +/// - Transmitter: FOO +/// +/// Foo. +#[derive(Clone, Copy)] +pub struct Foo { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foo { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12330)}); + + pub const FOO_MIN: f32 = 229.53_f32; + pub const FOO_MAX: f32 = 270.47_f32; + pub const BAR_MIN: f32 = 0_f32; + pub const BAR_MAX: f32 = 5_f32; + + /// Construct new Foo from values + pub fn new(foo: f32, bar: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_foo(foo)?; + res.set_bar(bar)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Foo + /// + /// - Min: 229.53 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: BAR + #[inline(always)] + pub fn foo(&self) -> f32 { + self.foo_raw() + } + + /// Get raw value of Foo + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn foo_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Foo + #[inline(always)] + pub fn set_foo(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.53_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + + /// Bar + /// + /// Bar. + /// + /// - Min: 0 + /// - Max: 5 + /// - Unit: "m" + /// - Receivers: FOO + #[inline(always)] + pub fn bar(&self) -> f32 { + self.bar_raw() + } + + /// Get raw value of Bar + /// + /// - Start bit: 24 + /// - Signal size: 32 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn bar_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[31..63].load_be::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Bar + #[inline(always)] + pub fn set_bar(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[31..63].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foo { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foo { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Fum +/// +/// - Extended ID: 74545 (0x12331) +/// - Size: 5 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct Fum { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Fum { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12331)}); + + pub const FUM_MIN: i16 = 0_i16; + pub const FUM_MAX: i16 = 10_i16; + pub const FAM_MIN: i16 = 0_i16; + pub const FAM_MAX: i16 = 8_i16; + + /// Construct new Fum from values + pub fn new(fum: i16, fam: i16) -> Result { + let mut res = Self { raw: [0u8; 5] }; + res.set_fum(fum)?; + res.set_fam(fam)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + + /// Fum + /// + /// - Min: 0 + /// - Max: 10 + /// - Unit: "" + /// - Receivers: BAR + #[inline(always)] + pub fn fum(&self) -> i16 { + self.fum_raw() + } + + /// Get raw value of Fum + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn fum_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..12].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fum + #[inline(always)] + pub fn set_fum(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 10_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..12].store_le(value); + Ok(()) + } + + /// Fam + /// + /// - Min: 0 + /// - Max: 8 + /// - Unit: "" + /// - Receivers: BAR + #[inline(always)] + pub fn fam(&self) -> FumFam { + let signal = self.raw.view_bits::()[12..24].load_le::(); + + match signal { + 1 => FumFam::Enabled, + 0 => FumFam::Disabled, + _ => FumFam::_Other(self.fam_raw()), + } + } + + /// Get raw value of Fam + /// + /// - Start bit: 12 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn fam_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[12..24].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fam + #[inline(always)] + pub fn set_fam(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 8_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Fum::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[12..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Fum { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Fum { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Fam +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum FumFam { + Enabled, + Disabled, + _Other(i16), +} + +impl From for i16 { + fn from(val: FumFam) -> i16 { + match val { + FumFam::Enabled => 1, + FumFam::Disabled => 0, + FumFam::_Other(x) => x, + } + } +} + + +/// Bar +/// +/// - Extended ID: 74546 (0x12332) +/// - Size: 4 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct Bar { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bar { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12332)}); + + pub const BINARY32_MIN: i32 = 0_i32; + pub const BINARY32_MAX: i32 = 0_i32; + + /// Construct new Bar from values + pub fn new(binary32: i32) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_binary32(binary32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// Binary32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: FUM + #[inline(always)] + pub fn binary32(&self) -> i32 { + self.binary32_raw() + } + + /// Get raw value of Binary32 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn binary32_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Binary32 + #[inline(always)] + pub fn set_binary32(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bar { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bar { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// CanFd +/// +/// - Extended ID: 74547 (0x12333) +/// - Size: 64 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct CanFd { + raw: [u8; 64], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CanFd { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x12333)}); + + pub const FIE_MIN: u64 = 0_u64; + pub const FIE_MAX: u64 = 0_u64; + pub const FAS_MIN: u64 = 0_u64; + pub const FAS_MAX: u64 = 0_u64; + + /// Construct new CanFd from values + pub fn new(fie: u64, fas: u64) -> Result { + let mut res = Self { raw: [0u8; 64] }; + res.set_fie(fie)?; + res.set_fas(fas)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 64] { + &self.raw + } + + /// Fie + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: FUM + #[inline(always)] + pub fn fie(&self) -> u64 { + self.fie_raw() + } + + /// Get raw value of Fie + /// + /// - Start bit: 0 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn fie_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[0..64].load_le::(); + + let factor = 1; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fie + #[inline(always)] + pub fn set_fie(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 0_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID })?; + let value = (value / factor) as u64; + + self.raw.view_bits_mut::()[0..64].store_le(value); + Ok(()) + } + + /// Fas + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn fas(&self) -> u64 { + self.fas_raw() + } + + /// Get raw value of Fas + /// + /// - Start bit: 64 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn fas_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[64..128].load_le::(); + + let factor = 1; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Fas + #[inline(always)] + pub fn set_fas(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 0_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CanFd::MESSAGE_ID })?; + let value = (value / factor) as u64; + + self.raw.view_bits_mut::()[64..128].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CanFd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 64 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 64]; + raw.copy_from_slice(&payload[..64]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CanFd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// FOOBAR +/// +/// - Standard ID: 780 (0x30c) +/// - Size: 8 bytes +/// - Transmitter: FIE +#[derive(Clone, Copy)] +pub struct Foobar { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foobar { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x30c)}); + + pub const ACC_02_CRC_MIN: i16 = 0_i16; + pub const ACC_02_CRC_MAX: i16 = 1_i16; + + /// Construct new FOOBAR from values + pub fn new(acc_02_crc: i16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_acc_02_crc(acc_02_crc)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// ACC_02_CRC + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: BAR + #[inline(always)] + pub fn acc_02_crc(&self) -> i16 { + self.acc_02_crc_raw() + } + + /// Get raw value of ACC_02_CRC + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn acc_02_crc_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..12].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ACC_02_CRC + #[inline(always)] + pub fn set_acc_02_crc(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 1_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foobar::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Foobar::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..12].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foobar { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foobar { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.rs b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.rs new file mode 100644 index 0000000..d875eb6 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.rs @@ -0,0 +1,433 @@ +// Generated code! +// +// Message definitions from file `issue_184_extended_mux_cascaded` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ext_MUX_cascaded + ExtMuxCascaded(ExtMuxCascaded), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExtMuxCascaded::MESSAGE_ID => Messages::ExtMuxCascaded(ExtMuxCascaded::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ext_MUX_cascaded +/// +/// - Extended ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtMuxCascaded { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxCascaded { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1)}); + + pub const MUXED_B_1_MIN: i8 = 0_i8; + pub const MUXED_B_1_MAX: i8 = 0_i8; + pub const MUXED_B_0_MIN: i8 = 0_i8; + pub const MUXED_B_0_MAX: i8 = 0_i8; + pub const MUXED_A_2_MUX_B_MIN: i8 = 0_i8; + pub const MUXED_A_2_MUX_B_MAX: i8 = 0_i8; + pub const MUXED_A_1_MIN: i8 = 0_i8; + pub const MUXED_A_1_MAX: i8 = 0_i8; + pub const MUX_A_MIN: i8 = 0_i8; + pub const MUX_A_MAX: i8 = 0_i8; + + /// Construct new ext_MUX_cascaded from values + pub fn new(mux_a: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mux_a(mux_a)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of MUX_A + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_a_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux_a(&mut self) -> Result { + match self.mux_a_raw() { + 0 => Ok(ExtMuxCascadedMuxAIndex::M0(ExtMuxCascadedMuxAM0{ raw: self.raw })), + 1 => Ok(ExtMuxCascadedMuxAIndex::M1(ExtMuxCascadedMuxAM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxCascaded::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX_A + #[inline(always)] + fn set_mux_a(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxCascadedMuxAM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(0)?; + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxCascadedMuxAM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtMuxCascaded { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtMuxCascaded { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ext_MUX_cascaded +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtMuxCascadedMuxAIndex { + M0(ExtMuxCascadedMuxAM0), + M1(ExtMuxCascadedMuxAM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxCascadedMuxAM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxCascadedMuxAM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_0 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_0(&self) -> i8 { + self.muxed_b_0_raw() +} + +/// Get raw value of muxed_B_0 +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_0 +#[inline(always)] +pub fn set_muxed_b_0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxCascadedMuxAM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxCascadedMuxAM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_1(&self) -> i8 { + self.muxed_b_1_raw() +} + +/// Get raw value of muxed_B_1 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_1 +#[inline(always)] +pub fn set_muxed_b_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// muxed_A_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_a_1(&self) -> i8 { + self.muxed_a_1_raw() +} + +/// Get raw value of muxed_A_1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_a_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_A_1 +#[inline(always)] +pub fn set_muxed_a_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.stderr b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.stderr new file mode 100644 index 0000000..bb0f3c0 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.stderr @@ -0,0 +1,11 @@ +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded.snap.rs:116:128 + | +116 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxCascaded::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs new file mode 100644 index 0000000..706a349 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs @@ -0,0 +1,494 @@ +// Generated code! +// +// Message definitions from file `issue_184_extended_mux_cascaded_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ext_MUX_cascaded + ExtMuxCascaded(ExtMuxCascaded), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExtMuxCascaded::MESSAGE_ID => Messages::ExtMuxCascaded(ExtMuxCascaded::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ext_MUX_cascaded +/// +/// - Extended ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtMuxCascaded { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxCascaded { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1)}); + + pub const MUXED_B_1_MIN: i8 = 0_i8; + pub const MUXED_B_1_MAX: i8 = 0_i8; + pub const MUXED_B_0_MIN: i8 = 0_i8; + pub const MUXED_B_0_MAX: i8 = 0_i8; + pub const MUXED_A_1_MIN: i8 = 0_i8; + pub const MUXED_A_1_MAX: i8 = 0_i8; + pub const MUXED_A_2_MUX_B_MIN: i8 = 0_i8; + pub const MUXED_A_2_MUX_B_MAX: i8 = 0_i8; + pub const MUX_A_MIN: i8 = 0_i8; + pub const MUX_A_MAX: i8 = 0_i8; + + /// Construct new ext_MUX_cascaded from values + pub fn new(muxed_a_2_mux_b: i8, mux_a: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_muxed_a_2_mux_b(muxed_a_2_mux_b)?; + res.set_mux_a(mux_a)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of muxed_A_2_MUX_B + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn muxed_a_2_mux_b_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn muxed_a_2_mux_b(&mut self) -> Result { + match self.muxed_a_2_mux_b_raw() { + 0 => Ok(ExtMuxCascadedMuxedA2MuxBIndex::M0(ExtMuxCascadedMuxedA2MuxBM0{ raw: self.raw })), + 1 => Ok(ExtMuxCascadedMuxedA2MuxBIndex::M1(ExtMuxCascadedMuxedA2MuxBM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxCascaded::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of muxed_A_2_MUX_B + #[inline(always)] + fn set_muxed_a_2_mux_b(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Set value of muxed_A_2_MUX_B + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxCascadedMuxedA2MuxBM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_muxed_a_2_mux_b(0)?; + Ok(()) + } + + /// Set value of muxed_A_2_MUX_B + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxCascadedMuxedA2MuxBM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_muxed_a_2_mux_b(1)?; + Ok(()) + } + + /// Get raw value of MUX_A + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_a_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux_a(&mut self) -> Result { + match self.mux_a_raw() { + 0 => Ok(ExtMuxCascadedMuxAIndex::M0(ExtMuxCascadedMuxAM0{ raw: self.raw })), + 1 => Ok(ExtMuxCascadedMuxAIndex::M1(ExtMuxCascadedMuxAM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxCascaded::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX_A + #[inline(always)] + fn set_mux_a(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxCascadedMuxAM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(0)?; + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxCascadedMuxAM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtMuxCascaded { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtMuxCascaded { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ext_MUX_cascaded +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtMuxCascadedMuxedA2MuxBIndex { + M0(ExtMuxCascadedMuxedA2MuxBM0), + M1(ExtMuxCascadedMuxedA2MuxBM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxCascadedMuxedA2MuxBM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxCascadedMuxedA2MuxBM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_0 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_0(&self) -> i8 { + self.muxed_b_0_raw() +} + +/// Get raw value of muxed_B_0 +/// +/// - Start bit: 16 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_0 +#[inline(always)] +pub fn set_muxed_b_0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxCascadedMuxedA2MuxBM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxCascadedMuxedA2MuxBM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_1(&self) -> i8 { + self.muxed_b_1_raw() +} + +/// Get raw value of muxed_B_1 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_1 +#[inline(always)] +pub fn set_muxed_b_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// muxed_A_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_a_1(&self) -> i8 { + self.muxed_a_1_raw() +} + +/// Get raw value of muxed_A_1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_a_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_A_1 +#[inline(always)] +pub fn set_muxed_a_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxCascaded::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.stderr b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.stderr new file mode 100644 index 0000000..2653c4e --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.stderr @@ -0,0 +1,114 @@ +error[E0412]: cannot find type `ExtMuxCascadedMuxAIndex` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:173:39 + | +173 | pub fn mux_a(&mut self) -> Result { + | ^^^^^^^^^^^^^^^^^^^^^^^ +... +276 | pub enum ExtMuxCascadedMuxedA2MuxBIndex { + | --------------------------------------- similarly named enum `ExtMuxCascadedMuxedA2MuxBIndex` defined here + | +help: an enum with a similar name exists + | +173 - pub fn mux_a(&mut self) -> Result { +173 + pub fn mux_a(&mut self) -> Result { + | +help: you might be missing a type parameter + | + 69 | impl ExtMuxCascaded { + | +++++++++++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtMuxCascadedMuxAM0` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:175:49 + | + 56 | pub struct ExtMuxCascaded { + | ------------------------- similarly named struct `ExtMuxCascaded` defined here +... +175 | 0 => Ok(ExtMuxCascadedMuxAIndex::M0(ExtMuxCascadedMuxAM0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxCascaded` + +error[E0422]: cannot find struct, variant or union type `ExtMuxCascadedMuxAM1` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:176:49 + | + 56 | pub struct ExtMuxCascaded { + | ------------------------- similarly named struct `ExtMuxCascaded` defined here +... +176 | 1 => Ok(ExtMuxCascadedMuxAIndex::M1(ExtMuxCascadedMuxAM1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxCascaded` + +error[E0412]: cannot find type `ExtMuxCascadedMuxAM0` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:198:37 + | + 56 | pub struct ExtMuxCascaded { + | ------------------------- similarly named struct `ExtMuxCascaded` defined here +... +198 | pub fn set_m0(&mut self, value: ExtMuxCascadedMuxAM0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxCascaded` + +error[E0412]: cannot find type `ExtMuxCascadedMuxAM1` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:208:37 + | + 56 | pub struct ExtMuxCascaded { + | ------------------------- similarly named struct `ExtMuxCascaded` defined here +... +208 | pub fn set_m1(&mut self, value: ExtMuxCascadedMuxAM1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxCascaded` + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:198:5 + | +138 | pub fn set_m0(&mut self, value: ExtMuxCascadedMuxedA2MuxBM0) -> Result<(), CanError> { + | ------------------------------------------------------------------------------------ other definition for `set_m0` +... +198 | pub fn set_m0(&mut self, value: ExtMuxCascadedMuxAM0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m1` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:208:5 + | +148 | pub fn set_m1(&mut self, value: ExtMuxCascadedMuxedA2MuxBM1) -> Result<(), CanError> { + | ------------------------------------------------------------------------------------ other definition for `set_m1` +... +208 | pub fn set_m1(&mut self, value: ExtMuxCascadedMuxAM1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m1` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:117:128 + | +117 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxCascaded::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxCascadedMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:175:21 + | +175 | 0 => Ok(ExtMuxCascadedMuxAIndex::M0(ExtMuxCascadedMuxAM0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxCascadedMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxCascadedMuxedA2MuxBIndex` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxCascadedMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:176:21 + | +176 | 1 => Ok(ExtMuxCascadedMuxAIndex::M1(ExtMuxCascadedMuxAM1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxCascadedMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxCascadedMuxedA2MuxBIndex` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_cascaded_dumped.snap.rs:177:128 + | +177 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxCascaded::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs new file mode 100644 index 0000000..9194db0 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs @@ -0,0 +1,588 @@ +// Generated code! +// +// Message definitions from file `issue_184_extended_mux_independent_multiplexors` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ext_MUX_indep_multiplexors + ExtMuxIndepMultiplexors(ExtMuxIndepMultiplexors), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExtMuxIndepMultiplexors::MESSAGE_ID => Messages::ExtMuxIndepMultiplexors(ExtMuxIndepMultiplexors::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ext_MUX_indep_multiplexors +/// +/// - Extended ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtMuxIndepMultiplexors { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexors { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x2)}); + + pub const MUXED_B_2_MIN: i8 = 0_i8; + pub const MUXED_B_2_MAX: i8 = 0_i8; + pub const MUXED_B_1_MIN: i8 = 0_i8; + pub const MUXED_B_1_MAX: i8 = 0_i8; + pub const MUX_B_MIN: i8 = 0_i8; + pub const MUX_B_MAX: i8 = 0_i8; + pub const MUXED_A_1_MIN: i8 = 0_i8; + pub const MUXED_A_1_MAX: i8 = 0_i8; + pub const MUXED_A_0_MIN: i8 = 0_i8; + pub const MUXED_A_0_MAX: i8 = 0_i8; + pub const MUX_A_MIN: i8 = 0_i8; + pub const MUX_A_MAX: i8 = 0_i8; + + /// Construct new ext_MUX_indep_multiplexors from values + pub fn new(mux_b: i8, mux_a: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mux_b(mux_b)?; + res.set_mux_a(mux_a)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of MUX_B + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_b_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux_b(&mut self) -> Result { + match self.mux_b_raw() { + 0 => Ok(ExtMuxIndepMultiplexorsMuxBIndex::M0(ExtMuxIndepMultiplexorsMuxBM0{ raw: self.raw })), + 1 => Ok(ExtMuxIndepMultiplexorsMuxBIndex::M1(ExtMuxIndepMultiplexorsMuxBM1{ raw: self.raw })), + 2 => Ok(ExtMuxIndepMultiplexorsMuxBIndex::M2(ExtMuxIndepMultiplexorsMuxBM2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX_B + #[inline(always)] + fn set_mux_b(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Set value of MUX_B + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxBM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_b(0)?; + Ok(()) + } + + /// Set value of MUX_B + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxBM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_b(1)?; + Ok(()) + } + + /// Set value of MUX_B + #[inline(always)] + pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxBM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_b(2)?; + Ok(()) + } + + /// Get raw value of MUX_A + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_a_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux_a(&mut self) -> Result { + match self.mux_a_raw() { + 0 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M0(ExtMuxIndepMultiplexorsMuxAM0{ raw: self.raw })), + 1 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M1(ExtMuxIndepMultiplexorsMuxAM1{ raw: self.raw })), + 2 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M2(ExtMuxIndepMultiplexorsMuxAM2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX_A + #[inline(always)] + fn set_mux_a(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxAM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(0)?; + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxAM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(1)?; + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxAM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtMuxIndepMultiplexors { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtMuxIndepMultiplexors { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ext_MUX_indep_multiplexors +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtMuxIndepMultiplexorsMuxBIndex { + M0(ExtMuxIndepMultiplexorsMuxBM0), + M1(ExtMuxIndepMultiplexorsMuxBM1), + M2(ExtMuxIndepMultiplexorsMuxBM2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxIndepMultiplexorsMuxBM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexorsMuxBM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_A_0 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_a_0(&self) -> i8 { + self.muxed_a_0_raw() +} + +/// Get raw value of muxed_A_0 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_a_0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_A_0 +#[inline(always)] +pub fn set_muxed_a_0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxIndepMultiplexorsMuxBM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexorsMuxBM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_1(&self) -> i8 { + self.muxed_b_1_raw() +} + +/// Get raw value of muxed_B_1 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_1 +#[inline(always)] +pub fn set_muxed_b_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// muxed_A_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_a_1(&self) -> i8 { + self.muxed_a_1_raw() +} + +/// Get raw value of muxed_A_1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_a_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_A_1 +#[inline(always)] +pub fn set_muxed_a_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxIndepMultiplexorsMuxBM2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexorsMuxBM2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_2(&self) -> i8 { + self.muxed_b_2_raw() +} + +/// Get raw value of muxed_B_2 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_2 +#[inline(always)] +pub fn set_muxed_b_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.stderr b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.stderr new file mode 100644 index 0000000..fe4a6b1 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.stderr @@ -0,0 +1,150 @@ +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAIndex` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:186:39 + | +186 | pub fn mux_a(&mut self) -> Result { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +... +300 | pub enum ExtMuxIndepMultiplexorsMuxBIndex { + | ----------------------------------------- similarly named enum `ExtMuxIndepMultiplexorsMuxBIndex` defined here + | +help: an enum with a similar name exists + | +186 - pub fn mux_a(&mut self) -> Result { +186 + pub fn mux_a(&mut self) -> Result { + | +help: you might be missing a type parameter + | + 69 | impl ExtMuxIndepMultiplexors { + | ++++++++++++++++++++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtMuxIndepMultiplexorsMuxAM0` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:188:58 + | +188 | 0 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M0(ExtMuxIndepMultiplexorsMuxAM0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM0` +... +316 | pub struct ExtMuxIndepMultiplexorsMuxBM0 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM0` defined here + +error[E0422]: cannot find struct, variant or union type `ExtMuxIndepMultiplexorsMuxAM1` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:189:58 + | +189 | 1 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M1(ExtMuxIndepMultiplexorsMuxAM1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM1` +... +385 | pub struct ExtMuxIndepMultiplexorsMuxBM1 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM1` defined here + +error[E0422]: cannot find struct, variant or union type `ExtMuxIndepMultiplexorsMuxAM2` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:190:58 + | +190 | 2 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M2(ExtMuxIndepMultiplexorsMuxAM2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM2` +... +498 | pub struct ExtMuxIndepMultiplexorsMuxBM2 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM2` defined here + +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAM0` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:212:37 + | +212 | pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxAM0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM0` +... +316 | pub struct ExtMuxIndepMultiplexorsMuxBM0 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM0` defined here + +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAM1` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:222:37 + | +222 | pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxAM1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM1` +... +385 | pub struct ExtMuxIndepMultiplexorsMuxBM1 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM1` defined here + +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAM2` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:232:37 + | +232 | pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxAM2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM2` +... +498 | pub struct ExtMuxIndepMultiplexorsMuxBM2 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM2` defined here + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:212:5 + | +141 | pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxBM0) -> Result<(), CanError> { + | -------------------------------------------------------------------------------------- other definition for `set_m0` +... +212 | pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxAM0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m1` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:222:5 + | +151 | pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxBM1) -> Result<(), CanError> { + | -------------------------------------------------------------------------------------- other definition for `set_m1` +... +222 | pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxAM1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m1` + +error[E0592]: duplicate definitions with name `set_m2` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:232:5 + | +161 | pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxBM2) -> Result<(), CanError> { + | -------------------------------------------------------------------------------------- other definition for `set_m2` +... +232 | pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxAM2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m2` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:120:137 + | +120 | ...s::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:188:21 + | +188 | 0 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M0(ExtMuxIndepMultiplexorsMuxAM0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxIndepMultiplexorsMuxBIndex` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:189:21 + | +189 | 1 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M1(ExtMuxIndepMultiplexorsMuxAM1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxIndepMultiplexorsMuxBIndex` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:190:21 + | +190 | 2 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M2(ExtMuxIndepMultiplexorsMuxAM2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxIndepMultiplexorsMuxBIndex` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors.snap.rs:191:137 + | +191 | ...s::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs new file mode 100644 index 0000000..da47387 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs @@ -0,0 +1,588 @@ +// Generated code! +// +// Message definitions from file `issue_184_extended_mux_independent_multiplexors_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ext_MUX_indep_multiplexors + ExtMuxIndepMultiplexors(ExtMuxIndepMultiplexors), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExtMuxIndepMultiplexors::MESSAGE_ID => Messages::ExtMuxIndepMultiplexors(ExtMuxIndepMultiplexors::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ext_MUX_indep_multiplexors +/// +/// - Extended ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtMuxIndepMultiplexors { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexors { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x2)}); + + pub const MUXED_B_1_MIN: i8 = 0_i8; + pub const MUXED_B_1_MAX: i8 = 0_i8; + pub const MUXED_B_2_MIN: i8 = 0_i8; + pub const MUXED_B_2_MAX: i8 = 0_i8; + pub const MUX_B_MIN: i8 = 0_i8; + pub const MUX_B_MAX: i8 = 0_i8; + pub const MUXED_A_0_MIN: i8 = 0_i8; + pub const MUXED_A_0_MAX: i8 = 0_i8; + pub const MUXED_A_1_MIN: i8 = 0_i8; + pub const MUXED_A_1_MAX: i8 = 0_i8; + pub const MUX_A_MIN: i8 = 0_i8; + pub const MUX_A_MAX: i8 = 0_i8; + + /// Construct new ext_MUX_indep_multiplexors from values + pub fn new(mux_b: i8, mux_a: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mux_b(mux_b)?; + res.set_mux_a(mux_a)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of MUX_B + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_b_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux_b(&mut self) -> Result { + match self.mux_b_raw() { + 0 => Ok(ExtMuxIndepMultiplexorsMuxBIndex::M0(ExtMuxIndepMultiplexorsMuxBM0{ raw: self.raw })), + 1 => Ok(ExtMuxIndepMultiplexorsMuxBIndex::M1(ExtMuxIndepMultiplexorsMuxBM1{ raw: self.raw })), + 2 => Ok(ExtMuxIndepMultiplexorsMuxBIndex::M2(ExtMuxIndepMultiplexorsMuxBM2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX_B + #[inline(always)] + fn set_mux_b(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Set value of MUX_B + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxBM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_b(0)?; + Ok(()) + } + + /// Set value of MUX_B + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxBM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_b(1)?; + Ok(()) + } + + /// Set value of MUX_B + #[inline(always)] + pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxBM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_b(2)?; + Ok(()) + } + + /// Get raw value of MUX_A + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_a_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux_a(&mut self) -> Result { + match self.mux_a_raw() { + 0 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M0(ExtMuxIndepMultiplexorsMuxAM0{ raw: self.raw })), + 1 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M1(ExtMuxIndepMultiplexorsMuxAM1{ raw: self.raw })), + 2 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M2(ExtMuxIndepMultiplexorsMuxAM2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX_A + #[inline(always)] + fn set_mux_a(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxAM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(0)?; + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxAM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(1)?; + Ok(()) + } + + /// Set value of MUX_A + #[inline(always)] + pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxAM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux_a(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtMuxIndepMultiplexors { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtMuxIndepMultiplexors { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ext_MUX_indep_multiplexors +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtMuxIndepMultiplexorsMuxBIndex { + M0(ExtMuxIndepMultiplexorsMuxBM0), + M1(ExtMuxIndepMultiplexorsMuxBM1), + M2(ExtMuxIndepMultiplexorsMuxBM2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxIndepMultiplexorsMuxBM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexorsMuxBM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_A_0 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_a_0(&self) -> i8 { + self.muxed_a_0_raw() +} + +/// Get raw value of muxed_A_0 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_a_0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_A_0 +#[inline(always)] +pub fn set_muxed_a_0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxIndepMultiplexorsMuxBM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexorsMuxBM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_1(&self) -> i8 { + self.muxed_b_1_raw() +} + +/// Get raw value of muxed_B_1 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_1 +#[inline(always)] +pub fn set_muxed_b_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +/// muxed_A_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_a_1(&self) -> i8 { + self.muxed_a_1_raw() +} + +/// Get raw value of muxed_A_1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_a_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_A_1 +#[inline(always)] +pub fn set_muxed_a_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxIndepMultiplexorsMuxBM2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxIndepMultiplexorsMuxBM2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_B_2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_b_2(&self) -> i8 { + self.muxed_b_2_raw() +} + +/// Get raw value of muxed_B_2 +/// +/// - Start bit: 24 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_b_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_B_2 +#[inline(always)] +pub fn set_muxed_b_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxIndepMultiplexors::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.stderr b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.stderr new file mode 100644 index 0000000..e13f52a --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.stderr @@ -0,0 +1,150 @@ +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAIndex` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:186:39 + | +186 | pub fn mux_a(&mut self) -> Result { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +... +300 | pub enum ExtMuxIndepMultiplexorsMuxBIndex { + | ----------------------------------------- similarly named enum `ExtMuxIndepMultiplexorsMuxBIndex` defined here + | +help: an enum with a similar name exists + | +186 - pub fn mux_a(&mut self) -> Result { +186 + pub fn mux_a(&mut self) -> Result { + | +help: you might be missing a type parameter + | + 69 | impl ExtMuxIndepMultiplexors { + | ++++++++++++++++++++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtMuxIndepMultiplexorsMuxAM0` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:188:58 + | +188 | 0 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M0(ExtMuxIndepMultiplexorsMuxAM0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM0` +... +316 | pub struct ExtMuxIndepMultiplexorsMuxBM0 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM0` defined here + +error[E0422]: cannot find struct, variant or union type `ExtMuxIndepMultiplexorsMuxAM1` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:189:58 + | +189 | 1 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M1(ExtMuxIndepMultiplexorsMuxAM1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM1` +... +385 | pub struct ExtMuxIndepMultiplexorsMuxBM1 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM1` defined here + +error[E0422]: cannot find struct, variant or union type `ExtMuxIndepMultiplexorsMuxAM2` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:190:58 + | +190 | 2 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M2(ExtMuxIndepMultiplexorsMuxAM2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM2` +... +498 | pub struct ExtMuxIndepMultiplexorsMuxBM2 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM2` defined here + +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAM0` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:212:37 + | +212 | pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxAM0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM0` +... +316 | pub struct ExtMuxIndepMultiplexorsMuxBM0 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM0` defined here + +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAM1` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:222:37 + | +222 | pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxAM1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM1` +... +385 | pub struct ExtMuxIndepMultiplexorsMuxBM1 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM1` defined here + +error[E0412]: cannot find type `ExtMuxIndepMultiplexorsMuxAM2` in this scope + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:232:37 + | +232 | pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxAM2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtMuxIndepMultiplexorsMuxBM2` +... +498 | pub struct ExtMuxIndepMultiplexorsMuxBM2 { raw: [u8; 8] } + | ---------------------------------------- similarly named struct `ExtMuxIndepMultiplexorsMuxBM2` defined here + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:212:5 + | +141 | pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxBM0) -> Result<(), CanError> { + | -------------------------------------------------------------------------------------- other definition for `set_m0` +... +212 | pub fn set_m0(&mut self, value: ExtMuxIndepMultiplexorsMuxAM0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m1` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:222:5 + | +151 | pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxBM1) -> Result<(), CanError> { + | -------------------------------------------------------------------------------------- other definition for `set_m1` +... +222 | pub fn set_m1(&mut self, value: ExtMuxIndepMultiplexorsMuxAM1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m1` + +error[E0592]: duplicate definitions with name `set_m2` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:232:5 + | +161 | pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxBM2) -> Result<(), CanError> { + | -------------------------------------------------------------------------------------- other definition for `set_m2` +... +232 | pub fn set_m2(&mut self, value: ExtMuxIndepMultiplexorsMuxAM2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m2` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:120:137 + | +120 | ...s::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:188:21 + | +188 | 0 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M0(ExtMuxIndepMultiplexorsMuxAM0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxIndepMultiplexorsMuxBIndex` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:189:21 + | +189 | 1 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M1(ExtMuxIndepMultiplexorsMuxAM1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxIndepMultiplexorsMuxBIndex` + +error[E0433]: failed to resolve: use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:190:21 + | +190 | 2 => Ok(ExtMuxIndepMultiplexorsMuxAIndex::M2(ExtMuxIndepMultiplexorsMuxAM2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtMuxIndepMultiplexorsMuxAIndex` + | help: an enum with a similar name exists: `ExtMuxIndepMultiplexorsMuxBIndex` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_independent_multiplexors_dumped.snap.rs:191:137 + | +191 | ...s::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.rs b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.rs new file mode 100644 index 0000000..fde1f46 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.rs @@ -0,0 +1,468 @@ +// Generated code! +// +// Message definitions from file `issue_184_extended_mux_multiple_values` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ext_MUX_multiple_values + ExtMuxMultipleValues(ExtMuxMultipleValues), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExtMuxMultipleValues::MESSAGE_ID => Messages::ExtMuxMultipleValues(ExtMuxMultipleValues::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ext_MUX_multiple_values +/// +/// - Extended ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtMuxMultipleValues { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValues { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1)}); + + pub const MUXED_2_MIN: i8 = 0_i8; + pub const MUXED_2_MAX: i8 = 0_i8; + pub const MUXED_1_MIN: i8 = 0_i8; + pub const MUXED_1_MAX: i8 = 0_i8; + pub const MUXED_0_3_4_5_MIN: i8 = 0_i8; + pub const MUXED_0_3_4_5_MAX: i8 = 0_i8; + pub const MUX_MIN: i8 = 0_i8; + pub const MUX_MAX: i8 = 0_i8; + + /// Construct new ext_MUX_multiple_values from values + pub fn new(mux: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mux(mux)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of MUX + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux(&mut self) -> Result { + match self.mux_raw() { + 0 => Ok(ExtMuxMultipleValuesMuxIndex::M0(ExtMuxMultipleValuesMuxM0{ raw: self.raw })), + 1 => Ok(ExtMuxMultipleValuesMuxIndex::M1(ExtMuxMultipleValuesMuxM1{ raw: self.raw })), + 2 => Ok(ExtMuxMultipleValuesMuxIndex::M2(ExtMuxMultipleValuesMuxM2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxMultipleValues::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX + #[inline(always)] + fn set_mux(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MUX + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxMultipleValuesMuxM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux(0)?; + Ok(()) + } + + /// Set value of MUX + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxMultipleValuesMuxM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux(1)?; + Ok(()) + } + + /// Set value of MUX + #[inline(always)] + pub fn set_m2(&mut self, value: ExtMuxMultipleValuesMuxM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtMuxMultipleValues { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtMuxMultipleValues { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ext_MUX_multiple_values +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtMuxMultipleValuesMuxIndex { + M0(ExtMuxMultipleValuesMuxM0), + M1(ExtMuxMultipleValuesMuxM1), + M2(ExtMuxMultipleValuesMuxM2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxMultipleValuesMuxM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValuesMuxM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_0_3_4_5 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_0_3_4_5(&self) -> i8 { + self.muxed_0_3_4_5_raw() +} + +/// Get raw value of muxed_0_3_4_5 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_0_3_4_5_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_0_3_4_5 +#[inline(always)] +pub fn set_muxed_0_3_4_5(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxMultipleValuesMuxM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValuesMuxM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_1(&self) -> i8 { + self.muxed_1_raw() +} + +/// Get raw value of muxed_1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_1 +#[inline(always)] +pub fn set_muxed_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxMultipleValuesMuxM2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValuesMuxM2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_2(&self) -> i8 { + self.muxed_2_raw() +} + +/// Get raw value of muxed_2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_2 +#[inline(always)] +pub fn set_muxed_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.stderr b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.stderr new file mode 100644 index 0000000..c22a16a --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.stderr @@ -0,0 +1,11 @@ +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values.snap.rs:115:134 + | +115 | ...s::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.rs b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.rs new file mode 100644 index 0000000..d90f1ee --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.rs @@ -0,0 +1,468 @@ +// Generated code! +// +// Message definitions from file `issue_184_extended_mux_multiple_values_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ext_MUX_multiple_values + ExtMuxMultipleValues(ExtMuxMultipleValues), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExtMuxMultipleValues::MESSAGE_ID => Messages::ExtMuxMultipleValues(ExtMuxMultipleValues::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ext_MUX_multiple_values +/// +/// - Extended ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtMuxMultipleValues { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValues { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1)}); + + pub const MUXED_0_3_4_5_MIN: i8 = 0_i8; + pub const MUXED_0_3_4_5_MAX: i8 = 0_i8; + pub const MUXED_1_MIN: i8 = 0_i8; + pub const MUXED_1_MAX: i8 = 0_i8; + pub const MUXED_2_MIN: i8 = 0_i8; + pub const MUXED_2_MAX: i8 = 0_i8; + pub const MUX_MIN: i8 = 0_i8; + pub const MUX_MAX: i8 = 0_i8; + + /// Construct new ext_MUX_multiple_values from values + pub fn new(mux: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mux(mux)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of MUX + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mux_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn mux(&mut self) -> Result { + match self.mux_raw() { + 0 => Ok(ExtMuxMultipleValuesMuxIndex::M0(ExtMuxMultipleValuesMuxM0{ raw: self.raw })), + 1 => Ok(ExtMuxMultipleValuesMuxIndex::M1(ExtMuxMultipleValuesMuxM1{ raw: self.raw })), + 2 => Ok(ExtMuxMultipleValuesMuxIndex::M2(ExtMuxMultipleValuesMuxM2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtMuxMultipleValues::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MUX + #[inline(always)] + fn set_mux(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MUX + #[inline(always)] + pub fn set_m0(&mut self, value: ExtMuxMultipleValuesMuxM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux(0)?; + Ok(()) + } + + /// Set value of MUX + #[inline(always)] + pub fn set_m1(&mut self, value: ExtMuxMultipleValuesMuxM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux(1)?; + Ok(()) + } + + /// Set value of MUX + #[inline(always)] + pub fn set_m2(&mut self, value: ExtMuxMultipleValuesMuxM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_mux(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtMuxMultipleValues { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtMuxMultipleValues { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ext_MUX_multiple_values +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtMuxMultipleValuesMuxIndex { + M0(ExtMuxMultipleValuesMuxM0), + M1(ExtMuxMultipleValuesMuxM1), + M2(ExtMuxMultipleValuesMuxM2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxMultipleValuesMuxM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValuesMuxM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_0_3_4_5 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_0_3_4_5(&self) -> i8 { + self.muxed_0_3_4_5_raw() +} + +/// Get raw value of muxed_0_3_4_5 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_0_3_4_5_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_0_3_4_5 +#[inline(always)] +pub fn set_muxed_0_3_4_5(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxMultipleValuesMuxM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValuesMuxM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_1(&self) -> i8 { + self.muxed_1_raw() +} + +/// Get raw value of muxed_1 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_1 +#[inline(always)] +pub fn set_muxed_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtMuxMultipleValuesMuxM2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtMuxMultipleValuesMuxM2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// muxed_2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn muxed_2(&self) -> i8 { + self.muxed_2_raw() +} + +/// Get raw value of muxed_2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn muxed_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of muxed_2 +#[inline(always)] +pub fn set_muxed_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtMuxMultipleValues::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.stderr b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.stderr new file mode 100644 index 0000000..e608dd4 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.stderr @@ -0,0 +1,11 @@ +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/issue_184_extended_mux_multiple_values_dumped.snap.rs:115:134 + | +115 | ...s::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/issue_199.snap b/tests-snapshots/dbc-cantools/issue_199.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_199.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_199.snap.rs b/tests-snapshots/dbc-cantools/issue_199.snap.rs new file mode 100644 index 0000000..6c3a05a --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_199.snap.rs @@ -0,0 +1,2517 @@ +// Generated code! +// +// Message definitions from file `issue_199` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// DriverDoorStatus + DriverDoorStatus(DriverDoorStatus), + /// Chime + Chime(Chime), + /// BlinkerStatus + BlinkerStatus(BlinkerStatus), + /// SteeringWheelAngle + SteeringWheelAngle(SteeringWheelAngle), + /// GearShifter + GearShifter(GearShifter), + /// GasPedalRegenCruise + GasPedalRegenCruise(GasPedalRegenCruise), + /// BrakePedal + BrakePedal(BrakePedal), + /// WheelSpeed + WheelSpeed(WheelSpeed), + /// VehicleSpeed + VehicleSpeed(VehicleSpeed), + /// CruiseButtons + CruiseButtons(CruiseButtons), + /// CruiseButtons2 + CruiseButtons2(CruiseButtons2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DriverDoorStatus::MESSAGE_ID => Messages::DriverDoorStatus(DriverDoorStatus::try_from(payload)?), + Chime::MESSAGE_ID => Messages::Chime(Chime::try_from(payload)?), + BlinkerStatus::MESSAGE_ID => Messages::BlinkerStatus(BlinkerStatus::try_from(payload)?), + SteeringWheelAngle::MESSAGE_ID => Messages::SteeringWheelAngle(SteeringWheelAngle::try_from(payload)?), + GearShifter::MESSAGE_ID => Messages::GearShifter(GearShifter::try_from(payload)?), + GasPedalRegenCruise::MESSAGE_ID => Messages::GasPedalRegenCruise(GasPedalRegenCruise::try_from(payload)?), + BrakePedal::MESSAGE_ID => Messages::BrakePedal(BrakePedal::try_from(payload)?), + WheelSpeed::MESSAGE_ID => Messages::WheelSpeed(WheelSpeed::try_from(payload)?), + VehicleSpeed::MESSAGE_ID => Messages::VehicleSpeed(VehicleSpeed::try_from(payload)?), + CruiseButtons::MESSAGE_ID => Messages::CruiseButtons(CruiseButtons::try_from(payload)?), + CruiseButtons2::MESSAGE_ID => Messages::CruiseButtons2(CruiseButtons2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// DriverDoorStatus +/// +/// - Standard ID: 0 (0x0) +/// - Size: 1 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct DriverDoorStatus { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DriverDoorStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + + /// Construct new DriverDoorStatus from values + pub fn new(driver_door_opened: bool) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_driver_door_opened(driver_door_opened)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// DriverDoorOpened + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn driver_door_opened(&self) -> DriverDoorStatusDriverDoorOpened { + let signal = self.raw.view_bits::()[7..8].load_be::(); + + match signal { + 1 => DriverDoorStatusDriverDoorOpened::Opened, + 0 => DriverDoorStatusDriverDoorOpened::Closed, + _ => DriverDoorStatusDriverDoorOpened::_Other(self.driver_door_opened_raw()), + } + } + + /// Get raw value of DriverDoorOpened + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn driver_door_opened_raw(&self) -> bool { + let signal = self.raw.view_bits::()[7..8].load_be::(); + + signal == 1 + } + + /// Set value of DriverDoorOpened + #[inline(always)] + pub fn set_driver_door_opened(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[7..8].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for DriverDoorStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DriverDoorStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DriverDoorOpened +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum DriverDoorStatusDriverDoorOpened { + Opened, + Closed, + _Other(bool), +} + +impl From for bool { + fn from(val: DriverDoorStatusDriverDoorOpened) -> bool { + match val { + DriverDoorStatusDriverDoorOpened::Opened => true, + DriverDoorStatusDriverDoorOpened::Closed => false, + DriverDoorStatusDriverDoorOpened::_Other(x) => x, + } + } +} + + +/// Chime +/// +/// - Standard ID: 0 (0x0) +/// - Size: 5 bytes +/// - Transmitter: NEO +#[derive(Clone, Copy)] +pub struct Chime { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Chime { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const CHIME_TYPE_MIN: u8 = 0_u8; + pub const CHIME_TYPE_MAX: u8 = 0_u8; + pub const CHIME_REPEAT_MIN: u8 = 0_u8; + pub const CHIME_REPEAT_MAX: u8 = 0_u8; + pub const CHIME_DURATION_MIN: u8 = 0_u8; + pub const CHIME_DURATION_MAX: u8 = 0_u8; + pub const CHIME_BYTE5_MIN: u8 = 0_u8; + pub const CHIME_BYTE5_MAX: u8 = 0_u8; + pub const CHIME_BYTE4_MIN: u8 = 0_u8; + pub const CHIME_BYTE4_MAX: u8 = 0_u8; + + /// Construct new Chime from values + pub fn new(chime_type: u8, chime_repeat: u8, chime_duration: u8, chime_byte5: u8, chime_byte4: u8) -> Result { + let mut res = Self { raw: [0u8; 5] }; + res.set_chime_type(chime_type)?; + res.set_chime_repeat(chime_repeat)?; + res.set_chime_duration(chime_duration)?; + res.set_chime_byte5(chime_byte5)?; + res.set_chime_byte4(chime_byte4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + + /// ChimeType + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_type(&self) -> u8 { + self.chime_type_raw() + } + + /// Get raw value of ChimeType + /// + /// - Start bit: 7 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_type_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeType + #[inline(always)] + pub fn set_chime_type(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_be(value); + Ok(()) + } + + /// ChimeRepeat + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_repeat(&self) -> u8 { + self.chime_repeat_raw() + } + + /// Get raw value of ChimeRepeat + /// + /// - Start bit: 23 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_repeat_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeRepeat + #[inline(always)] + pub fn set_chime_repeat(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_be(value); + Ok(()) + } + + /// ChimeDuration + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_duration(&self) -> u8 { + self.chime_duration_raw() + } + + /// Get raw value of ChimeDuration + /// + /// - Start bit: 15 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_duration_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeDuration + #[inline(always)] + pub fn set_chime_duration(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) + } + + /// ChimeByte5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_byte5(&self) -> u8 { + self.chime_byte5_raw() + } + + /// Get raw value of ChimeByte5 + /// + /// - Start bit: 39 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_byte5_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeByte5 + #[inline(always)] + pub fn set_chime_byte5(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_be(value); + Ok(()) + } + + /// ChimeByte4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_byte4(&self) -> u8 { + self.chime_byte4_raw() + } + + /// Get raw value of ChimeByte4 + /// + /// - Start bit: 31 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_byte4_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeByte4 + #[inline(always)] + pub fn set_chime_byte4(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Chime { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Chime { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DriverDoorOpened +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ChimeDriverDoorOpened { + Opened, + Closed, + _Other(bool), +} + +impl From for bool { + fn from(val: ChimeDriverDoorOpened) -> bool { + match val { + ChimeDriverDoorOpened::Opened => true, + ChimeDriverDoorOpened::Closed => false, + ChimeDriverDoorOpened::_Other(x) => x, + } + } +} + + +/// BlinkerStatus +/// +/// - Standard ID: 49152 (0xc000) +/// - Size: 5 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct BlinkerStatus { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BlinkerStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc000)}); + + + /// Construct new BlinkerStatus from values + pub fn new(right_blinker: bool, left_blinker: bool, blinker_light: bool) -> Result { + let mut res = Self { raw: [0u8; 5] }; + res.set_right_blinker(right_blinker)?; + res.set_left_blinker(left_blinker)?; + res.set_blinker_light(blinker_light)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + + /// RightBlinker + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn right_blinker(&self) -> BlinkerStatusRightBlinker { + let signal = self.raw.view_bits::()[1..2].load_be::(); + + match signal { + 1 => BlinkerStatusRightBlinker::Active, + 0 => BlinkerStatusRightBlinker::Inactive, + _ => BlinkerStatusRightBlinker::_Other(self.right_blinker_raw()), + } + } + + /// Get raw value of RightBlinker + /// + /// - Start bit: 6 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn right_blinker_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_be::(); + + signal == 1 + } + + /// Set value of RightBlinker + #[inline(always)] + pub fn set_right_blinker(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_be(value); + Ok(()) + } + + /// LeftBlinker + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn left_blinker(&self) -> BlinkerStatusLeftBlinker { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + match signal { + 1 => BlinkerStatusLeftBlinker::Active, + 0 => BlinkerStatusLeftBlinker::Inactive, + _ => BlinkerStatusLeftBlinker::_Other(self.left_blinker_raw()), + } + } + + /// Get raw value of LeftBlinker + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn left_blinker_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of LeftBlinker + #[inline(always)] + pub fn set_left_blinker(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + + /// BlinkerLight + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn blinker_light(&self) -> BlinkerStatusBlinkerLight { + let signal = self.raw.view_bits::()[30..31].load_be::(); + + match signal { + 1 => BlinkerStatusBlinkerLight::Active, + 0 => BlinkerStatusBlinkerLight::Inactive, + _ => BlinkerStatusBlinkerLight::_Other(self.blinker_light_raw()), + } + } + + /// Get raw value of BlinkerLight + /// + /// - Start bit: 25 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn blinker_light_raw(&self) -> bool { + let signal = self.raw.view_bits::()[30..31].load_be::(); + + signal == 1 + } + + /// Set value of BlinkerLight + #[inline(always)] + pub fn set_blinker_light(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[30..31].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for BlinkerStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for BlinkerStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for RightBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BlinkerStatusRightBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: BlinkerStatusRightBlinker) -> bool { + match val { + BlinkerStatusRightBlinker::Active => true, + BlinkerStatusRightBlinker::Inactive => false, + BlinkerStatusRightBlinker::_Other(x) => x, + } + } +} + +/// Defined values for LeftBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BlinkerStatusLeftBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: BlinkerStatusLeftBlinker) -> bool { + match val { + BlinkerStatusLeftBlinker::Active => true, + BlinkerStatusLeftBlinker::Inactive => false, + BlinkerStatusLeftBlinker::_Other(x) => x, + } + } +} + +/// Defined values for BlinkerLight +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BlinkerStatusBlinkerLight { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: BlinkerStatusBlinkerLight) -> bool { + match val { + BlinkerStatusBlinkerLight::Active => true, + BlinkerStatusBlinkerLight::Inactive => false, + BlinkerStatusBlinkerLight::_Other(x) => x, + } + } +} + + +/// SteeringWheelAngle +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct SteeringWheelAngle { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SteeringWheelAngle { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const STEERING_WHEEL_ANGLE_MIN: f32 = -540_f32; + pub const STEERING_WHEEL_ANGLE_MAX: f32 = 540_f32; + + /// Construct new SteeringWheelAngle from values + pub fn new(steering_wheel_angle: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_steering_wheel_angle(steering_wheel_angle)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SteeringWheelAngle + /// + /// - Min: -540 + /// - Max: 540 + /// - Unit: "deg" + /// - Receivers: NEO + #[inline(always)] + pub fn steering_wheel_angle(&self) -> f32 { + self.steering_wheel_angle_raw() + } + + /// Get raw value of SteeringWheelAngle + /// + /// - Start bit: 39 + /// - Signal size: 16 bits + /// - Factor: 0.0625 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn steering_wheel_angle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_be::(); + + let factor = 0.0625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of SteeringWheelAngle + #[inline(always)] + pub fn set_steering_wheel_angle(&mut self, value: f32) -> Result<(), CanError> { + if value < -540_f32 || 540_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SteeringWheelAngle::MESSAGE_ID }); + } + let factor = 0.0625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SteeringWheelAngle { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SteeringWheelAngle { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DriverDoorOpened +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum SteeringWheelAngleDriverDoorOpened { + Opened, + Closed, + _Other(bool), +} + +impl From for bool { + fn from(val: SteeringWheelAngleDriverDoorOpened) -> bool { + match val { + SteeringWheelAngleDriverDoorOpened::Opened => true, + SteeringWheelAngleDriverDoorOpened::Closed => false, + SteeringWheelAngleDriverDoorOpened::_Other(x) => x, + } + } +} + + +/// GearShifter +/// +/// - Standard ID: 49152 (0xc000) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct GearShifter { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl GearShifter { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc000)}); + + pub const GEAR_SHIFTER_MIN: u8 = 0_u8; + pub const GEAR_SHIFTER_MAX: u8 = 3_u8; + + /// Construct new GearShifter from values + pub fn new(gear_shifter: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gear_shifter(gear_shifter)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GearShifter + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn gear_shifter(&self) -> GearShifterGearShifter { + let signal = self.raw.view_bits::()[22..24].load_be::(); + + match signal { + 3 => GearShifterGearShifter::Park, + 0 => GearShifterGearShifter::DriveLow, + _ => GearShifterGearShifter::_Other(self.gear_shifter_raw()), + } + } + + /// Get raw value of GearShifter + /// + /// - Start bit: 17 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gear_shifter_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[22..24].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GearShifter + #[inline(always)] + pub fn set_gear_shifter(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: GearShifter::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: GearShifter::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[22..24].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for GearShifter { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for GearShifter { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for RightBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GearShifterRightBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GearShifterRightBlinker) -> bool { + match val { + GearShifterRightBlinker::Active => true, + GearShifterRightBlinker::Inactive => false, + GearShifterRightBlinker::_Other(x) => x, + } + } +} + +/// Defined values for LeftBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GearShifterLeftBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GearShifterLeftBlinker) -> bool { + match val { + GearShifterLeftBlinker::Active => true, + GearShifterLeftBlinker::Inactive => false, + GearShifterLeftBlinker::_Other(x) => x, + } + } +} + +/// Defined values for BlinkerLight +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GearShifterBlinkerLight { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GearShifterBlinkerLight) -> bool { + match val { + GearShifterBlinkerLight::Active => true, + GearShifterBlinkerLight::Inactive => false, + GearShifterBlinkerLight::_Other(x) => x, + } + } +} + + +/// GasPedalRegenCruise +/// +/// - Standard ID: 40960 (0xa000) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct GasPedalRegenCruise { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl GasPedalRegenCruise { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xa000)}); + + pub const GAS_PEDAL_MIN: u8 = 0_u8; + pub const GAS_PEDAL_MAX: u8 = 254_u8; + pub const GEAR_SHIFTER2_NOT_USED_MIN: u8 = 0_u8; + pub const GEAR_SHIFTER2_NOT_USED_MAX: u8 = 255_u8; + + /// Construct new GasPedalRegenCruise from values + pub fn new(cruise_control_active: bool, max_regen: bool, gas_pedal: u8, gear_shifter2_not_used: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_cruise_control_active(cruise_control_active)?; + res.set_max_regen(max_regen)?; + res.set_gas_pedal(gas_pedal)?; + res.set_gear_shifter2_not_used(gear_shifter2_not_used)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// CruiseControlActive + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn cruise_control_active(&self) -> GasPedalRegenCruiseCruiseControlActive { + let signal = self.raw.view_bits::()[63..64].load_be::(); + + match signal { + 1 => GasPedalRegenCruiseCruiseControlActive::Active, + 0 => GasPedalRegenCruiseCruiseControlActive::Inactive, + _ => GasPedalRegenCruiseCruiseControlActive::_Other(self.cruise_control_active_raw()), + } + } + + /// Get raw value of CruiseControlActive + /// + /// - Start bit: 56 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cruise_control_active_raw(&self) -> bool { + let signal = self.raw.view_bits::()[63..64].load_be::(); + + signal == 1 + } + + /// Set value of CruiseControlActive + #[inline(always)] + pub fn set_cruise_control_active(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[63..64].store_be(value); + Ok(()) + } + + /// MaxRegen + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: GMLAN, NEO + #[inline(always)] + pub fn max_regen(&self) -> bool { + self.max_regen_raw() + } + + /// Get raw value of MaxRegen + /// + /// - Start bit: 12 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn max_regen_raw(&self) -> bool { + let signal = self.raw.view_bits::()[11..12].load_be::(); + + signal == 1 + } + + /// Set value of MaxRegen + #[inline(always)] + pub fn set_max_regen(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[11..12].store_be(value); + Ok(()) + } + + /// GasPedal + /// + /// - Min: 0 + /// - Max: 254 + /// - Unit: "" + /// - Receivers: GMLAN, NEO + #[inline(always)] + pub fn gas_pedal(&self) -> u8 { + self.gas_pedal_raw() + } + + /// Get raw value of GasPedal + /// + /// - Start bit: 47 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gas_pedal_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GasPedal + #[inline(always)] + pub fn set_gas_pedal(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 254_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_be(value); + Ok(()) + } + + /// GearShifter2NotUsed + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: GMLAN, NEO + #[inline(always)] + pub fn gear_shifter2_not_used(&self) -> u8 { + self.gear_shifter2_not_used_raw() + } + + /// Get raw value of GearShifter2NotUsed + /// + /// - Start bit: 55 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gear_shifter2_not_used_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GearShifter2NotUsed + #[inline(always)] + pub fn set_gear_shifter2_not_used(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for GasPedalRegenCruise { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for GasPedalRegenCruise { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for CruiseControlActive +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GasPedalRegenCruiseCruiseControlActive { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GasPedalRegenCruiseCruiseControlActive) -> bool { + match val { + GasPedalRegenCruiseCruiseControlActive::Active => true, + GasPedalRegenCruiseCruiseControlActive::Inactive => false, + GasPedalRegenCruiseCruiseControlActive::_Other(x) => x, + } + } +} + + +/// BrakePedal +/// +/// - Standard ID: 0 (0x0) +/// - Size: 2 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct BrakePedal { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BrakePedal { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const BRAKE_LEVEL_MIN: u8 = 0_u8; + pub const BRAKE_LEVEL_MAX: u8 = 3_u8; + pub const BRAKE_SENSOR_MIN: u8 = 0_u8; + pub const BRAKE_SENSOR_MAX: u8 = 255_u8; + + /// Construct new BrakePedal from values + pub fn new(brake_level: u8, brake_sensor: u8) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_brake_level(brake_level)?; + res.set_brake_sensor(brake_sensor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// BrakeLevel + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn brake_level(&self) -> u8 { + self.brake_level_raw() + } + + /// Get raw value of BrakeLevel + /// + /// - Start bit: 2 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_level_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[5..7].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of BrakeLevel + #[inline(always)] + pub fn set_brake_level(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[5..7].store_be(value); + Ok(()) + } + + /// BrakeSensor + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn brake_sensor(&self) -> u8 { + self.brake_sensor_raw() + } + + /// Get raw value of BrakeSensor + /// + /// - Start bit: 15 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_sensor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of BrakeSensor + #[inline(always)] + pub fn set_brake_sensor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for BrakePedal { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for BrakePedal { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DriverDoorOpened +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BrakePedalDriverDoorOpened { + Opened, + Closed, + _Other(bool), +} + +impl From for bool { + fn from(val: BrakePedalDriverDoorOpened) -> bool { + match val { + BrakePedalDriverDoorOpened::Opened => true, + BrakePedalDriverDoorOpened::Closed => false, + BrakePedalDriverDoorOpened::_Other(x) => x, + } + } +} + + +/// WheelSpeed +/// +/// - Standard ID: 32768 (0x8000) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct WheelSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl WheelSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x8000)}); + + pub const WHEEL_SPEED_FL_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_FL_MAX: f32 = 70_f32; + pub const WHEEL_SPEED_FR_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_FR_MAX: f32 = 70_f32; + pub const WHEEL_SPEED_RL_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_RL_MAX: f32 = 70_f32; + pub const WHEEL_SPEED_RR_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_RR_MAX: f32 = 70_f32; + + /// Construct new WheelSpeed from values + pub fn new(wheel_speed_fl: f32, wheel_speed_fr: f32, wheel_speed_rl: f32, wheel_speed_rr: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_wheel_speed_fl(wheel_speed_fl)?; + res.set_wheel_speed_fr(wheel_speed_fr)?; + res.set_wheel_speed_rl(wheel_speed_rl)?; + res.set_wheel_speed_rr(wheel_speed_rr)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// WheelSpeedFL + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_fl(&self) -> f32 { + self.wheel_speed_fl_raw() + } + + /// Get raw value of WheelSpeedFL + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_fl_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedFL + #[inline(always)] + pub fn set_wheel_speed_fl(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + + /// WheelSpeedFR + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_fr(&self) -> f32 { + self.wheel_speed_fr_raw() + } + + /// Get raw value of WheelSpeedFR + /// + /// - Start bit: 39 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_fr_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedFR + #[inline(always)] + pub fn set_wheel_speed_fr(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_be(value); + Ok(()) + } + + /// WheelSpeedRL + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_rl(&self) -> f32 { + self.wheel_speed_rl_raw() + } + + /// Get raw value of WheelSpeedRL + /// + /// - Start bit: 23 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_rl_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedRL + #[inline(always)] + pub fn set_wheel_speed_rl(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_be(value); + Ok(()) + } + + /// WheelSpeedRR + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_rr(&self) -> f32 { + self.wheel_speed_rr_raw() + } + + /// Get raw value of WheelSpeedRR + /// + /// - Start bit: 55 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_rr_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedRR + #[inline(always)] + pub fn set_wheel_speed_rr(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for WheelSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for WheelSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// VehicleSpeed +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct VehicleSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl VehicleSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const VEHICLE_SPEED1_MIN: f32 = 0_f32; + pub const VEHICLE_SPEED1_MAX: f32 = 100_f32; + pub const VEHICLE_SPEED2_MIN: f32 = 0_f32; + pub const VEHICLE_SPEED2_MAX: f32 = 100_f32; + + /// Construct new VehicleSpeed from values + pub fn new(vehicle_speed1: f32, vehicle_speed2: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_vehicle_speed1(vehicle_speed1)?; + res.set_vehicle_speed2(vehicle_speed2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// VehicleSpeed1 + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "mph" + /// - Receivers: NEO + #[inline(always)] + pub fn vehicle_speed1(&self) -> f32 { + self.vehicle_speed1_raw() + } + + /// Get raw value of VehicleSpeed1 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn vehicle_speed1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of VehicleSpeed1 + #[inline(always)] + pub fn set_vehicle_speed1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: VehicleSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + + /// VehicleSpeed2 + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "mph" + /// - Receivers: NEO + #[inline(always)] + pub fn vehicle_speed2(&self) -> f32 { + self.vehicle_speed2_raw() + } + + /// Get raw value of VehicleSpeed2 + /// + /// - Start bit: 39 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn vehicle_speed2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of VehicleSpeed2 + #[inline(always)] + pub fn set_vehicle_speed2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: VehicleSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for VehicleSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for VehicleSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DriverDoorOpened +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum VehicleSpeedDriverDoorOpened { + Opened, + Closed, + _Other(bool), +} + +impl From for bool { + fn from(val: VehicleSpeedDriverDoorOpened) -> bool { + match val { + VehicleSpeedDriverDoorOpened::Opened => true, + VehicleSpeedDriverDoorOpened::Closed => false, + VehicleSpeedDriverDoorOpened::_Other(x) => x, + } + } +} + + +/// CruiseButtons +/// +/// - Standard ID: 32768 (0x8000) +/// - Size: 3 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct CruiseButtons { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CruiseButtons { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x8000)}); + + pub const CRUISE_BUTTONS_MIN: u8 = 0_u8; + pub const CRUISE_BUTTONS_MAX: u8 = 12_u8; + + /// Construct new CruiseButtons from values + pub fn new(cruise_buttons: u8) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_cruise_buttons(cruise_buttons)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// CruiseButtons + /// + /// - Min: 0 + /// - Max: 12 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn cruise_buttons(&self) -> CruiseButtonsCruiseButtons { + let signal = self.raw.view_bits::()[4..7].load_be::(); + + match signal { + 6 => CruiseButtonsCruiseButtons::Cancel, + 5 => CruiseButtonsCruiseButtons::Main, + 3 => CruiseButtonsCruiseButtons::Set, + 2 => CruiseButtonsCruiseButtons::Resume, + 1 => CruiseButtonsCruiseButtons::None, + _ => CruiseButtonsCruiseButtons::_Other(self.cruise_buttons_raw()), + } + } + + /// Get raw value of CruiseButtons + /// + /// - Start bit: 3 + /// - Signal size: 3 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cruise_buttons_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..7].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CruiseButtons + #[inline(always)] + pub fn set_cruise_buttons(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 12_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CruiseButtons::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CruiseButtons::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..7].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CruiseButtons { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CruiseButtons { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// CruiseButtons2 +/// +/// - Standard ID: 24576 (0x6000) +/// - Size: 1 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct CruiseButtons2 { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CruiseButtons2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x6000)}); + + pub const LKA_GAP_BUTTON_MIN: u8 = 0_u8; + pub const LKA_GAP_BUTTON_MAX: u8 = 2_u8; + + /// Construct new CruiseButtons2 from values + pub fn new(lka_gap_button: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_lka_gap_button(lka_gap_button)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// LKAGapButton + /// + /// - Min: 0 + /// - Max: 2 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn lka_gap_button(&self) -> CruiseButtons2LkaGapButton { + let signal = self.raw.view_bits::()[6..8].load_be::(); + + match signal { + 2 => CruiseButtons2LkaGapButton::X, + 1 => CruiseButtons2LkaGapButton::X, + 0 => CruiseButtons2LkaGapButton::None, + _ => CruiseButtons2LkaGapButton::_Other(self.lka_gap_button_raw()), + } + } + + /// Get raw value of LKAGapButton + /// + /// - Start bit: 1 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn lka_gap_button_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[6..8].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of LKAGapButton + #[inline(always)] + pub fn set_lka_gap_button(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 2_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CruiseButtons2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CruiseButtons2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[6..8].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CruiseButtons2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CruiseButtons2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for LKAGapButton +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum CruiseButtons2LkaGapButton { + X, + X, + None, + _Other(u8), +} + +impl From for u8 { + fn from(val: CruiseButtons2LkaGapButton) -> u8 { + match val { + CruiseButtons2LkaGapButton::X => 2, + CruiseButtons2LkaGapButton::X => 1, + CruiseButtons2LkaGapButton::None => 0, + CruiseButtons2LkaGapButton::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_199.snap.stderr b/tests-snapshots/dbc-cantools/issue_199.snap.stderr new file mode 100644 index 0000000..e4766c7 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_199.snap.stderr @@ -0,0 +1,193 @@ +error[E0428]: the name `X` is defined multiple times + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2470:5 + | +2469 | X, + | - previous definition of the type `X` here +2470 | X, + | ^ `X` redefined here + | + = note: `X` must be defined only once in the type namespace of this enum + +error[E0412]: cannot find type `GearShifterGearShifter` in this scope + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:1062:35 + | +1062 | pub fn gear_shifter(&self) -> GearShifterGearShifter { + | ^^^^^^^^^^^^^^^^^^^^^^ help: an enum with a similar name exists: `GearShifterLeftBlinker` +... +1191 | pub enum GearShifterLeftBlinker { + | ------------------------------- similarly named enum `GearShifterLeftBlinker` defined here + +error[E0412]: cannot find type `CruiseButtonsCruiseButtons` in this scope + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2226:37 + | +2226 | pub fn cruise_buttons(&self) -> CruiseButtonsCruiseButtons { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` +... +2468 | pub enum CruiseButtons2LkaGapButton { + | ----------------------------------- similarly named enum `CruiseButtons2LkaGapButton` defined here + +error[E0433]: failed to resolve: use of undeclared type `GearShifterGearShifter` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:1066:18 + | +1066 | 3 => GearShifterGearShifter::Park, + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `GearShifterGearShifter` + | help: an enum with a similar name exists: `GearShifterLeftBlinker` + +error[E0433]: failed to resolve: use of undeclared type `GearShifterGearShifter` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:1067:18 + | +1067 | 0 => GearShifterGearShifter::DriveLow, + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `GearShifterGearShifter` + | help: an enum with a similar name exists: `GearShifterLeftBlinker` + +error[E0433]: failed to resolve: use of undeclared type `GearShifterGearShifter` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:1068:18 + | +1068 | _ => GearShifterGearShifter::_Other(self.gear_shifter_raw()), + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `GearShifterGearShifter` + | help: an enum with a similar name exists: `GearShifterLeftBlinker` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2230:18 + | +2230 | 6 => CruiseButtonsCruiseButtons::Cancel, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2231:18 + | +2231 | 5 => CruiseButtonsCruiseButtons::Main, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2232:18 + | +2232 | 3 => CruiseButtonsCruiseButtons::Set, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2233:18 + | +2233 | 2 => CruiseButtonsCruiseButtons::Resume, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2234:18 + | +2234 | 1 => CruiseButtonsCruiseButtons::None, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2235:18 + | +2235 | _ => CruiseButtonsCruiseButtons::_Other(self.cruise_buttons_raw()), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:65:13 + | +64 | DriverDoorStatus::MESSAGE_ID => Messages::DriverDoorStatus(DriverDoorStatus::try_from(payload)?), + | ---------------------------- matches all the relevant values +65 | Chime::MESSAGE_ID => Messages::Chime(Chime::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^ no value can reach this + | + = note: `-D unreachable-patterns` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_patterns)]` + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:67:13 + | +64 | DriverDoorStatus::MESSAGE_ID => Messages::DriverDoorStatus(DriverDoorStatus::try_from(payload)?), + | ---------------------------- matches all the relevant values +... +67 | SteeringWheelAngle::MESSAGE_ID => Messages::SteeringWheelAngle(SteeringWheelAngle::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:68:13 + | +66 | BlinkerStatus::MESSAGE_ID => Messages::BlinkerStatus(BlinkerStatus::try_from(payload)?), + | ------------------------- matches all the relevant values +67 | SteeringWheelAngle::MESSAGE_ID => Messages::SteeringWheelAngle(SteeringWheelAngle::try_from(payload)?), +68 | GearShifter::MESSAGE_ID => Messages::GearShifter(GearShifter::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:70:13 + | +64 | DriverDoorStatus::MESSAGE_ID => Messages::DriverDoorStatus(DriverDoorStatus::try_from(payload)?), + | ---------------------------- matches all the relevant values +... +70 | BrakePedal::MESSAGE_ID => Messages::BrakePedal(BrakePedal::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:72:13 + | +64 | DriverDoorStatus::MESSAGE_ID => Messages::DriverDoorStatus(DriverDoorStatus::try_from(payload)?), + | ---------------------------- matches all the relevant values +... +72 | VehicleSpeed::MESSAGE_ID => Messages::VehicleSpeed(VehicleSpeed::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:73:13 + | +71 | WheelSpeed::MESSAGE_ID => Messages::WheelSpeed(WheelSpeed::try_from(payload)?), + | ---------------------- matches all the relevant values +72 | VehicleSpeed::MESSAGE_ID => Messages::VehicleSpeed(VehicleSpeed::try_from(payload)?), +73 | CruiseButtons::MESSAGE_ID => Messages::CruiseButtons(CruiseButtons::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2479:13 + | +2478 | CruiseButtons2LkaGapButton::X => 2, + | ----------------------------- matches all the relevant values +2479 | CruiseButtons2LkaGapButton::X => 1, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error[E0004]: non-exhaustive patterns: `CruiseButtons2LkaGapButton::X` not covered + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2477:15 + | +2477 | match val { + | ^^^ pattern `CruiseButtons2LkaGapButton::X` not covered + | +note: `CruiseButtons2LkaGapButton` defined here + --> tests-snapshots/dbc-cantools/issue_199.snap.rs:2468:10 + | +2468 | pub enum CruiseButtons2LkaGapButton { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ +2469 | X, +2470 | X, + | - not covered + = note: the matched value is of type `CruiseButtons2LkaGapButton` +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown + | +2481 ~ CruiseButtons2LkaGapButton::_Other(x) => x, +2482 ~ CruiseButtons2LkaGapButton::X => todo!(), + | diff --git a/tests-snapshots/dbc-cantools/issue_199_extended.snap b/tests-snapshots/dbc-cantools/issue_199_extended.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_199_extended.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_199_extended.snap.rs b/tests-snapshots/dbc-cantools/issue_199_extended.snap.rs new file mode 100644 index 0000000..7ff1ce3 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_199_extended.snap.rs @@ -0,0 +1,2409 @@ +// Generated code! +// +// Message definitions from file `issue_199_extended` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// DriverDoorStatus + DriverDoorStatus(DriverDoorStatus), + /// Chime + Chime(Chime), + /// BlinkerStatus + BlinkerStatus(BlinkerStatus), + /// SteeringWheelAngle + SteeringWheelAngle(SteeringWheelAngle), + /// GearShifter + GearShifter(GearShifter), + /// GasPedalRegenCruise + GasPedalRegenCruise(GasPedalRegenCruise), + /// BrakePedal + BrakePedal(BrakePedal), + /// WheelSpeed + WheelSpeed(WheelSpeed), + /// VehicleSpeed + VehicleSpeed(VehicleSpeed), + /// CruiseButtons + CruiseButtons(CruiseButtons), + /// CruiseButtons2 + CruiseButtons2(CruiseButtons2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DriverDoorStatus::MESSAGE_ID => Messages::DriverDoorStatus(DriverDoorStatus::try_from(payload)?), + Chime::MESSAGE_ID => Messages::Chime(Chime::try_from(payload)?), + BlinkerStatus::MESSAGE_ID => Messages::BlinkerStatus(BlinkerStatus::try_from(payload)?), + SteeringWheelAngle::MESSAGE_ID => Messages::SteeringWheelAngle(SteeringWheelAngle::try_from(payload)?), + GearShifter::MESSAGE_ID => Messages::GearShifter(GearShifter::try_from(payload)?), + GasPedalRegenCruise::MESSAGE_ID => Messages::GasPedalRegenCruise(GasPedalRegenCruise::try_from(payload)?), + BrakePedal::MESSAGE_ID => Messages::BrakePedal(BrakePedal::try_from(payload)?), + WheelSpeed::MESSAGE_ID => Messages::WheelSpeed(WheelSpeed::try_from(payload)?), + VehicleSpeed::MESSAGE_ID => Messages::VehicleSpeed(VehicleSpeed::try_from(payload)?), + CruiseButtons::MESSAGE_ID => Messages::CruiseButtons(CruiseButtons::try_from(payload)?), + CruiseButtons2::MESSAGE_ID => Messages::CruiseButtons2(CruiseButtons2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// DriverDoorStatus +/// +/// - Extended ID: 536870911 (0x1fffffff) +/// - Size: 1 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct DriverDoorStatus { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DriverDoorStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1fffffff)}); + + + /// Construct new DriverDoorStatus from values + pub fn new(driver_door_opened: bool) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_driver_door_opened(driver_door_opened)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// DriverDoorOpened + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn driver_door_opened(&self) -> DriverDoorStatusDriverDoorOpened { + let signal = self.raw.view_bits::()[7..8].load_be::(); + + match signal { + 1 => DriverDoorStatusDriverDoorOpened::Opened, + 0 => DriverDoorStatusDriverDoorOpened::Closed, + _ => DriverDoorStatusDriverDoorOpened::_Other(self.driver_door_opened_raw()), + } + } + + /// Get raw value of DriverDoorOpened + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn driver_door_opened_raw(&self) -> bool { + let signal = self.raw.view_bits::()[7..8].load_be::(); + + signal == 1 + } + + /// Set value of DriverDoorOpened + #[inline(always)] + pub fn set_driver_door_opened(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[7..8].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for DriverDoorStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DriverDoorStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DriverDoorOpened +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum DriverDoorStatusDriverDoorOpened { + Opened, + Closed, + _Other(bool), +} + +impl From for bool { + fn from(val: DriverDoorStatusDriverDoorOpened) -> bool { + match val { + DriverDoorStatusDriverDoorOpened::Opened => true, + DriverDoorStatusDriverDoorOpened::Closed => false, + DriverDoorStatusDriverDoorOpened::_Other(x) => x, + } + } +} + + +/// Chime +/// +/// - Standard ID: 0 (0x0) +/// - Size: 5 bytes +/// - Transmitter: NEO +#[derive(Clone, Copy)] +pub struct Chime { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Chime { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const CHIME_TYPE_MIN: u8 = 0_u8; + pub const CHIME_TYPE_MAX: u8 = 0_u8; + pub const CHIME_REPEAT_MIN: u8 = 0_u8; + pub const CHIME_REPEAT_MAX: u8 = 0_u8; + pub const CHIME_DURATION_MIN: u8 = 0_u8; + pub const CHIME_DURATION_MAX: u8 = 0_u8; + pub const CHIME_BYTE5_MIN: u8 = 0_u8; + pub const CHIME_BYTE5_MAX: u8 = 0_u8; + pub const CHIME_BYTE4_MIN: u8 = 0_u8; + pub const CHIME_BYTE4_MAX: u8 = 0_u8; + + /// Construct new Chime from values + pub fn new(chime_type: u8, chime_repeat: u8, chime_duration: u8, chime_byte5: u8, chime_byte4: u8) -> Result { + let mut res = Self { raw: [0u8; 5] }; + res.set_chime_type(chime_type)?; + res.set_chime_repeat(chime_repeat)?; + res.set_chime_duration(chime_duration)?; + res.set_chime_byte5(chime_byte5)?; + res.set_chime_byte4(chime_byte4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + + /// ChimeType + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_type(&self) -> u8 { + self.chime_type_raw() + } + + /// Get raw value of ChimeType + /// + /// - Start bit: 7 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_type_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeType + #[inline(always)] + pub fn set_chime_type(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_be(value); + Ok(()) + } + + /// ChimeRepeat + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_repeat(&self) -> u8 { + self.chime_repeat_raw() + } + + /// Get raw value of ChimeRepeat + /// + /// - Start bit: 23 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_repeat_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeRepeat + #[inline(always)] + pub fn set_chime_repeat(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_be(value); + Ok(()) + } + + /// ChimeDuration + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_duration(&self) -> u8 { + self.chime_duration_raw() + } + + /// Get raw value of ChimeDuration + /// + /// - Start bit: 15 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_duration_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeDuration + #[inline(always)] + pub fn set_chime_duration(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) + } + + /// ChimeByte5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_byte5(&self) -> u8 { + self.chime_byte5_raw() + } + + /// Get raw value of ChimeByte5 + /// + /// - Start bit: 39 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_byte5_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeByte5 + #[inline(always)] + pub fn set_chime_byte5(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_be(value); + Ok(()) + } + + /// ChimeByte4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn chime_byte4(&self) -> u8 { + self.chime_byte4_raw() + } + + /// Get raw value of ChimeByte4 + /// + /// - Start bit: 31 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chime_byte4_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of ChimeByte4 + #[inline(always)] + pub fn set_chime_byte4(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Chime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Chime { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Chime { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// BlinkerStatus +/// +/// - Standard ID: 49152 (0xc000) +/// - Size: 5 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct BlinkerStatus { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BlinkerStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc000)}); + + + /// Construct new BlinkerStatus from values + pub fn new(right_blinker: bool, left_blinker: bool, blinker_light: bool) -> Result { + let mut res = Self { raw: [0u8; 5] }; + res.set_right_blinker(right_blinker)?; + res.set_left_blinker(left_blinker)?; + res.set_blinker_light(blinker_light)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + + /// RightBlinker + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn right_blinker(&self) -> BlinkerStatusRightBlinker { + let signal = self.raw.view_bits::()[1..2].load_be::(); + + match signal { + 1 => BlinkerStatusRightBlinker::Active, + 0 => BlinkerStatusRightBlinker::Inactive, + _ => BlinkerStatusRightBlinker::_Other(self.right_blinker_raw()), + } + } + + /// Get raw value of RightBlinker + /// + /// - Start bit: 6 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn right_blinker_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_be::(); + + signal == 1 + } + + /// Set value of RightBlinker + #[inline(always)] + pub fn set_right_blinker(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_be(value); + Ok(()) + } + + /// LeftBlinker + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn left_blinker(&self) -> BlinkerStatusLeftBlinker { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + match signal { + 1 => BlinkerStatusLeftBlinker::Active, + 0 => BlinkerStatusLeftBlinker::Inactive, + _ => BlinkerStatusLeftBlinker::_Other(self.left_blinker_raw()), + } + } + + /// Get raw value of LeftBlinker + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn left_blinker_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of LeftBlinker + #[inline(always)] + pub fn set_left_blinker(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + + /// BlinkerLight + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn blinker_light(&self) -> BlinkerStatusBlinkerLight { + let signal = self.raw.view_bits::()[30..31].load_be::(); + + match signal { + 1 => BlinkerStatusBlinkerLight::Active, + 0 => BlinkerStatusBlinkerLight::Inactive, + _ => BlinkerStatusBlinkerLight::_Other(self.blinker_light_raw()), + } + } + + /// Get raw value of BlinkerLight + /// + /// - Start bit: 25 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn blinker_light_raw(&self) -> bool { + let signal = self.raw.view_bits::()[30..31].load_be::(); + + signal == 1 + } + + /// Set value of BlinkerLight + #[inline(always)] + pub fn set_blinker_light(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[30..31].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for BlinkerStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for BlinkerStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for RightBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BlinkerStatusRightBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: BlinkerStatusRightBlinker) -> bool { + match val { + BlinkerStatusRightBlinker::Active => true, + BlinkerStatusRightBlinker::Inactive => false, + BlinkerStatusRightBlinker::_Other(x) => x, + } + } +} + +/// Defined values for LeftBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BlinkerStatusLeftBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: BlinkerStatusLeftBlinker) -> bool { + match val { + BlinkerStatusLeftBlinker::Active => true, + BlinkerStatusLeftBlinker::Inactive => false, + BlinkerStatusLeftBlinker::_Other(x) => x, + } + } +} + +/// Defined values for BlinkerLight +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum BlinkerStatusBlinkerLight { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: BlinkerStatusBlinkerLight) -> bool { + match val { + BlinkerStatusBlinkerLight::Active => true, + BlinkerStatusBlinkerLight::Inactive => false, + BlinkerStatusBlinkerLight::_Other(x) => x, + } + } +} + + +/// SteeringWheelAngle +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct SteeringWheelAngle { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SteeringWheelAngle { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const STEERING_WHEEL_ANGLE_MIN: f32 = -540_f32; + pub const STEERING_WHEEL_ANGLE_MAX: f32 = 540_f32; + + /// Construct new SteeringWheelAngle from values + pub fn new(steering_wheel_angle: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_steering_wheel_angle(steering_wheel_angle)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SteeringWheelAngle + /// + /// - Min: -540 + /// - Max: 540 + /// - Unit: "deg" + /// - Receivers: NEO + #[inline(always)] + pub fn steering_wheel_angle(&self) -> f32 { + self.steering_wheel_angle_raw() + } + + /// Get raw value of SteeringWheelAngle + /// + /// - Start bit: 39 + /// - Signal size: 16 bits + /// - Factor: 0.0625 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn steering_wheel_angle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_be::(); + + let factor = 0.0625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of SteeringWheelAngle + #[inline(always)] + pub fn set_steering_wheel_angle(&mut self, value: f32) -> Result<(), CanError> { + if value < -540_f32 || 540_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SteeringWheelAngle::MESSAGE_ID }); + } + let factor = 0.0625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SteeringWheelAngle { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SteeringWheelAngle { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// GearShifter +/// +/// - Standard ID: 49152 (0xc000) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct GearShifter { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl GearShifter { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc000)}); + + pub const GEAR_SHIFTER_MIN: u8 = 0_u8; + pub const GEAR_SHIFTER_MAX: u8 = 3_u8; + + /// Construct new GearShifter from values + pub fn new(gear_shifter: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gear_shifter(gear_shifter)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GearShifter + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn gear_shifter(&self) -> GearShifterGearShifter { + let signal = self.raw.view_bits::()[22..24].load_be::(); + + match signal { + 3 => GearShifterGearShifter::Park, + 0 => GearShifterGearShifter::DriveLow, + _ => GearShifterGearShifter::_Other(self.gear_shifter_raw()), + } + } + + /// Get raw value of GearShifter + /// + /// - Start bit: 17 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gear_shifter_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[22..24].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GearShifter + #[inline(always)] + pub fn set_gear_shifter(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: GearShifter::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: GearShifter::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[22..24].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for GearShifter { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for GearShifter { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for RightBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GearShifterRightBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GearShifterRightBlinker) -> bool { + match val { + GearShifterRightBlinker::Active => true, + GearShifterRightBlinker::Inactive => false, + GearShifterRightBlinker::_Other(x) => x, + } + } +} + +/// Defined values for LeftBlinker +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GearShifterLeftBlinker { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GearShifterLeftBlinker) -> bool { + match val { + GearShifterLeftBlinker::Active => true, + GearShifterLeftBlinker::Inactive => false, + GearShifterLeftBlinker::_Other(x) => x, + } + } +} + +/// Defined values for BlinkerLight +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GearShifterBlinkerLight { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GearShifterBlinkerLight) -> bool { + match val { + GearShifterBlinkerLight::Active => true, + GearShifterBlinkerLight::Inactive => false, + GearShifterBlinkerLight::_Other(x) => x, + } + } +} + + +/// GasPedalRegenCruise +/// +/// - Standard ID: 40960 (0xa000) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct GasPedalRegenCruise { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl GasPedalRegenCruise { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xa000)}); + + pub const GAS_PEDAL_MIN: u8 = 0_u8; + pub const GAS_PEDAL_MAX: u8 = 254_u8; + pub const GEAR_SHIFTER2_NOT_USED_MIN: u8 = 0_u8; + pub const GEAR_SHIFTER2_NOT_USED_MAX: u8 = 255_u8; + + /// Construct new GasPedalRegenCruise from values + pub fn new(cruise_control_active: bool, max_regen: bool, gas_pedal: u8, gear_shifter2_not_used: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_cruise_control_active(cruise_control_active)?; + res.set_max_regen(max_regen)?; + res.set_gas_pedal(gas_pedal)?; + res.set_gear_shifter2_not_used(gear_shifter2_not_used)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// CruiseControlActive + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: GMLAN + #[inline(always)] + pub fn cruise_control_active(&self) -> GasPedalRegenCruiseCruiseControlActive { + let signal = self.raw.view_bits::()[63..64].load_be::(); + + match signal { + 1 => GasPedalRegenCruiseCruiseControlActive::Active, + 0 => GasPedalRegenCruiseCruiseControlActive::Inactive, + _ => GasPedalRegenCruiseCruiseControlActive::_Other(self.cruise_control_active_raw()), + } + } + + /// Get raw value of CruiseControlActive + /// + /// - Start bit: 56 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cruise_control_active_raw(&self) -> bool { + let signal = self.raw.view_bits::()[63..64].load_be::(); + + signal == 1 + } + + /// Set value of CruiseControlActive + #[inline(always)] + pub fn set_cruise_control_active(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[63..64].store_be(value); + Ok(()) + } + + /// MaxRegen + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: GMLAN, NEO + #[inline(always)] + pub fn max_regen(&self) -> bool { + self.max_regen_raw() + } + + /// Get raw value of MaxRegen + /// + /// - Start bit: 12 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn max_regen_raw(&self) -> bool { + let signal = self.raw.view_bits::()[11..12].load_be::(); + + signal == 1 + } + + /// Set value of MaxRegen + #[inline(always)] + pub fn set_max_regen(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[11..12].store_be(value); + Ok(()) + } + + /// GasPedal + /// + /// - Min: 0 + /// - Max: 254 + /// - Unit: "" + /// - Receivers: GMLAN, NEO + #[inline(always)] + pub fn gas_pedal(&self) -> u8 { + self.gas_pedal_raw() + } + + /// Get raw value of GasPedal + /// + /// - Start bit: 47 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gas_pedal_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GasPedal + #[inline(always)] + pub fn set_gas_pedal(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 254_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_be(value); + Ok(()) + } + + /// GearShifter2NotUsed + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: GMLAN, NEO + #[inline(always)] + pub fn gear_shifter2_not_used(&self) -> u8 { + self.gear_shifter2_not_used_raw() + } + + /// Get raw value of GearShifter2NotUsed + /// + /// - Start bit: 55 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gear_shifter2_not_used_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GearShifter2NotUsed + #[inline(always)] + pub fn set_gear_shifter2_not_used(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: GasPedalRegenCruise::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for GasPedalRegenCruise { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for GasPedalRegenCruise { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for CruiseControlActive +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum GasPedalRegenCruiseCruiseControlActive { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: GasPedalRegenCruiseCruiseControlActive) -> bool { + match val { + GasPedalRegenCruiseCruiseControlActive::Active => true, + GasPedalRegenCruiseCruiseControlActive::Inactive => false, + GasPedalRegenCruiseCruiseControlActive::_Other(x) => x, + } + } +} + + +/// BrakePedal +/// +/// - Standard ID: 0 (0x0) +/// - Size: 2 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct BrakePedal { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BrakePedal { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const BRAKE_LEVEL_MIN: u8 = 0_u8; + pub const BRAKE_LEVEL_MAX: u8 = 3_u8; + pub const BRAKE_SENSOR_MIN: u8 = 0_u8; + pub const BRAKE_SENSOR_MAX: u8 = 255_u8; + + /// Construct new BrakePedal from values + pub fn new(brake_level: u8, brake_sensor: u8) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_brake_level(brake_level)?; + res.set_brake_sensor(brake_sensor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// BrakeLevel + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn brake_level(&self) -> u8 { + self.brake_level_raw() + } + + /// Get raw value of BrakeLevel + /// + /// - Start bit: 2 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_level_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[5..7].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of BrakeLevel + #[inline(always)] + pub fn set_brake_level(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[5..7].store_be(value); + Ok(()) + } + + /// BrakeSensor + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn brake_sensor(&self) -> u8 { + self.brake_sensor_raw() + } + + /// Get raw value of BrakeSensor + /// + /// - Start bit: 15 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn brake_sensor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of BrakeSensor + #[inline(always)] + pub fn set_brake_sensor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BrakePedal::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for BrakePedal { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for BrakePedal { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// WheelSpeed +/// +/// - Standard ID: 32768 (0x8000) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct WheelSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl WheelSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x8000)}); + + pub const WHEEL_SPEED_FL_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_FL_MAX: f32 = 70_f32; + pub const WHEEL_SPEED_FR_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_FR_MAX: f32 = 70_f32; + pub const WHEEL_SPEED_RL_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_RL_MAX: f32 = 70_f32; + pub const WHEEL_SPEED_RR_MIN: f32 = 0_f32; + pub const WHEEL_SPEED_RR_MAX: f32 = 70_f32; + + /// Construct new WheelSpeed from values + pub fn new(wheel_speed_fl: f32, wheel_speed_fr: f32, wheel_speed_rl: f32, wheel_speed_rr: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_wheel_speed_fl(wheel_speed_fl)?; + res.set_wheel_speed_fr(wheel_speed_fr)?; + res.set_wheel_speed_rl(wheel_speed_rl)?; + res.set_wheel_speed_rr(wheel_speed_rr)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// WheelSpeedFL + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_fl(&self) -> f32 { + self.wheel_speed_fl_raw() + } + + /// Get raw value of WheelSpeedFL + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_fl_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedFL + #[inline(always)] + pub fn set_wheel_speed_fl(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + + /// WheelSpeedFR + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_fr(&self) -> f32 { + self.wheel_speed_fr_raw() + } + + /// Get raw value of WheelSpeedFR + /// + /// - Start bit: 39 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_fr_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedFR + #[inline(always)] + pub fn set_wheel_speed_fr(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_be(value); + Ok(()) + } + + /// WheelSpeedRL + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_rl(&self) -> f32 { + self.wheel_speed_rl_raw() + } + + /// Get raw value of WheelSpeedRL + /// + /// - Start bit: 23 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_rl_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedRL + #[inline(always)] + pub fn set_wheel_speed_rl(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_be(value); + Ok(()) + } + + /// WheelSpeedRR + /// + /// - Min: 0 + /// - Max: 70 + /// - Unit: "yd/s" + /// - Receivers: NEO + #[inline(always)] + pub fn wheel_speed_rr(&self) -> f32 { + self.wheel_speed_rr_raw() + } + + /// Get raw value of WheelSpeedRR + /// + /// - Start bit: 55 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn wheel_speed_rr_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of WheelSpeedRR + #[inline(always)] + pub fn set_wheel_speed_rr(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 70_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: WheelSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for WheelSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for WheelSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// VehicleSpeed +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct VehicleSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl VehicleSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const VEHICLE_SPEED1_MIN: f32 = 0_f32; + pub const VEHICLE_SPEED1_MAX: f32 = 100_f32; + pub const VEHICLE_SPEED2_MIN: f32 = 0_f32; + pub const VEHICLE_SPEED2_MAX: f32 = 100_f32; + + /// Construct new VehicleSpeed from values + pub fn new(vehicle_speed1: f32, vehicle_speed2: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_vehicle_speed1(vehicle_speed1)?; + res.set_vehicle_speed2(vehicle_speed2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// VehicleSpeed1 + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "mph" + /// - Receivers: NEO + #[inline(always)] + pub fn vehicle_speed1(&self) -> f32 { + self.vehicle_speed1_raw() + } + + /// Get raw value of VehicleSpeed1 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn vehicle_speed1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of VehicleSpeed1 + #[inline(always)] + pub fn set_vehicle_speed1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: VehicleSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + + /// VehicleSpeed2 + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "mph" + /// - Receivers: NEO + #[inline(always)] + pub fn vehicle_speed2(&self) -> f32 { + self.vehicle_speed2_raw() + } + + /// Get raw value of VehicleSpeed2 + /// + /// - Start bit: 39 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn vehicle_speed2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_be::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of VehicleSpeed2 + #[inline(always)] + pub fn set_vehicle_speed2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: VehicleSpeed::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for VehicleSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for VehicleSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// CruiseButtons +/// +/// - Standard ID: 32768 (0x8000) +/// - Size: 3 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct CruiseButtons { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CruiseButtons { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x8000)}); + + pub const CRUISE_BUTTONS_MIN: u8 = 0_u8; + pub const CRUISE_BUTTONS_MAX: u8 = 12_u8; + + /// Construct new CruiseButtons from values + pub fn new(cruise_buttons: u8) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_cruise_buttons(cruise_buttons)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// CruiseButtons + /// + /// - Min: 0 + /// - Max: 12 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn cruise_buttons(&self) -> CruiseButtonsCruiseButtons { + let signal = self.raw.view_bits::()[4..7].load_be::(); + + match signal { + 6 => CruiseButtonsCruiseButtons::Cancel, + 5 => CruiseButtonsCruiseButtons::Main, + 3 => CruiseButtonsCruiseButtons::Set, + 2 => CruiseButtonsCruiseButtons::Resume, + 1 => CruiseButtonsCruiseButtons::None, + _ => CruiseButtonsCruiseButtons::_Other(self.cruise_buttons_raw()), + } + } + + /// Get raw value of CruiseButtons + /// + /// - Start bit: 3 + /// - Signal size: 3 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cruise_buttons_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..7].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CruiseButtons + #[inline(always)] + pub fn set_cruise_buttons(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 12_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CruiseButtons::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CruiseButtons::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..7].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CruiseButtons { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CruiseButtons { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// CruiseButtons2 +/// +/// - Standard ID: 24576 (0x6000) +/// - Size: 1 bytes +/// - Transmitter: GMLAN +#[derive(Clone, Copy)] +pub struct CruiseButtons2 { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl CruiseButtons2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x6000)}); + + pub const LKA_GAP_BUTTON_MIN: u8 = 0_u8; + pub const LKA_GAP_BUTTON_MAX: u8 = 2_u8; + + /// Construct new CruiseButtons2 from values + pub fn new(lka_gap_button: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_lka_gap_button(lka_gap_button)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// LKAGapButton + /// + /// - Min: 0 + /// - Max: 2 + /// - Unit: "" + /// - Receivers: NEO + #[inline(always)] + pub fn lka_gap_button(&self) -> CruiseButtons2LkaGapButton { + let signal = self.raw.view_bits::()[6..8].load_be::(); + + match signal { + 2 => CruiseButtons2LkaGapButton::X, + 1 => CruiseButtons2LkaGapButton::X, + 0 => CruiseButtons2LkaGapButton::None, + _ => CruiseButtons2LkaGapButton::_Other(self.lka_gap_button_raw()), + } + } + + /// Get raw value of LKAGapButton + /// + /// - Start bit: 1 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn lka_gap_button_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[6..8].load_be::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of LKAGapButton + #[inline(always)] + pub fn set_lka_gap_button(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 2_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: CruiseButtons2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: CruiseButtons2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[6..8].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for CruiseButtons2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for CruiseButtons2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for LKAGapButton +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum CruiseButtons2LkaGapButton { + X, + X, + None, + _Other(u8), +} + +impl From for u8 { + fn from(val: CruiseButtons2LkaGapButton) -> u8 { + match val { + CruiseButtons2LkaGapButton::X => 2, + CruiseButtons2LkaGapButton::X => 1, + CruiseButtons2LkaGapButton::None => 0, + CruiseButtons2LkaGapButton::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_199_extended.snap.stderr b/tests-snapshots/dbc-cantools/issue_199_extended.snap.stderr new file mode 100644 index 0000000..5ba4a0e --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_199_extended.snap.stderr @@ -0,0 +1,185 @@ +error[E0428]: the name `X` is defined multiple times + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2362:5 + | +2361 | X, + | - previous definition of the type `X` here +2362 | X, + | ^ `X` redefined here + | + = note: `X` must be defined only once in the type namespace of this enum + +error[E0412]: cannot find type `GearShifterGearShifter` in this scope + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:1008:35 + | +1008 | pub fn gear_shifter(&self) -> GearShifterGearShifter { + | ^^^^^^^^^^^^^^^^^^^^^^ help: an enum with a similar name exists: `GearShifterLeftBlinker` +... +1137 | pub enum GearShifterLeftBlinker { + | ------------------------------- similarly named enum `GearShifterLeftBlinker` defined here + +error[E0412]: cannot find type `CruiseButtonsCruiseButtons` in this scope + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2118:37 + | +2118 | pub fn cruise_buttons(&self) -> CruiseButtonsCruiseButtons { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` +... +2360 | pub enum CruiseButtons2LkaGapButton { + | ----------------------------------- similarly named enum `CruiseButtons2LkaGapButton` defined here + +error[E0433]: failed to resolve: use of undeclared type `GearShifterGearShifter` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:1012:18 + | +1012 | 3 => GearShifterGearShifter::Park, + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `GearShifterGearShifter` + | help: an enum with a similar name exists: `GearShifterLeftBlinker` + +error[E0433]: failed to resolve: use of undeclared type `GearShifterGearShifter` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:1013:18 + | +1013 | 0 => GearShifterGearShifter::DriveLow, + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `GearShifterGearShifter` + | help: an enum with a similar name exists: `GearShifterLeftBlinker` + +error[E0433]: failed to resolve: use of undeclared type `GearShifterGearShifter` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:1014:18 + | +1014 | _ => GearShifterGearShifter::_Other(self.gear_shifter_raw()), + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `GearShifterGearShifter` + | help: an enum with a similar name exists: `GearShifterLeftBlinker` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2122:18 + | +2122 | 6 => CruiseButtonsCruiseButtons::Cancel, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2123:18 + | +2123 | 5 => CruiseButtonsCruiseButtons::Main, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2124:18 + | +2124 | 3 => CruiseButtonsCruiseButtons::Set, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2125:18 + | +2125 | 2 => CruiseButtonsCruiseButtons::Resume, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2126:18 + | +2126 | 1 => CruiseButtonsCruiseButtons::None, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error[E0433]: failed to resolve: use of undeclared type `CruiseButtonsCruiseButtons` + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2127:18 + | +2127 | _ => CruiseButtonsCruiseButtons::_Other(self.cruise_buttons_raw()), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `CruiseButtonsCruiseButtons` + | help: an enum with a similar name exists: `CruiseButtons2LkaGapButton` + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:67:13 + | +65 | Chime::MESSAGE_ID => Messages::Chime(Chime::try_from(payload)?), + | ----------------- matches all the relevant values +66 | BlinkerStatus::MESSAGE_ID => Messages::BlinkerStatus(BlinkerStatus::try_from(payload)?), +67 | SteeringWheelAngle::MESSAGE_ID => Messages::SteeringWheelAngle(SteeringWheelAngle::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + | + = note: `-D unreachable-patterns` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_patterns)]` + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:68:13 + | +66 | BlinkerStatus::MESSAGE_ID => Messages::BlinkerStatus(BlinkerStatus::try_from(payload)?), + | ------------------------- matches all the relevant values +67 | SteeringWheelAngle::MESSAGE_ID => Messages::SteeringWheelAngle(SteeringWheelAngle::try_from(payload)?), +68 | GearShifter::MESSAGE_ID => Messages::GearShifter(GearShifter::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:70:13 + | +65 | Chime::MESSAGE_ID => Messages::Chime(Chime::try_from(payload)?), + | ----------------- matches all the relevant values +... +70 | BrakePedal::MESSAGE_ID => Messages::BrakePedal(BrakePedal::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:72:13 + | +65 | Chime::MESSAGE_ID => Messages::Chime(Chime::try_from(payload)?), + | ----------------- matches all the relevant values +... +72 | VehicleSpeed::MESSAGE_ID => Messages::VehicleSpeed(VehicleSpeed::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:73:13 + | +71 | WheelSpeed::MESSAGE_ID => Messages::WheelSpeed(WheelSpeed::try_from(payload)?), + | ---------------------- matches all the relevant values +72 | VehicleSpeed::MESSAGE_ID => Messages::VehicleSpeed(VehicleSpeed::try_from(payload)?), +73 | CruiseButtons::MESSAGE_ID => Messages::CruiseButtons(CruiseButtons::try_from(payload)?), + | ^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2371:13 + | +2370 | CruiseButtons2LkaGapButton::X => 2, + | ----------------------------- matches all the relevant values +2371 | CruiseButtons2LkaGapButton::X => 1, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error[E0004]: non-exhaustive patterns: `CruiseButtons2LkaGapButton::X` not covered + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2369:15 + | +2369 | match val { + | ^^^ pattern `CruiseButtons2LkaGapButton::X` not covered + | +note: `CruiseButtons2LkaGapButton` defined here + --> tests-snapshots/dbc-cantools/issue_199_extended.snap.rs:2360:10 + | +2360 | pub enum CruiseButtons2LkaGapButton { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ +2361 | X, +2362 | X, + | - not covered + = note: the matched value is of type `CruiseButtons2LkaGapButton` +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown + | +2373 ~ CruiseButtons2LkaGapButton::_Other(x) => x, +2374 ~ CruiseButtons2LkaGapButton::X => todo!(), + | diff --git a/tests-snapshots/dbc-cantools/issue_207_sig_plus.snap b/tests-snapshots/dbc-cantools/issue_207_sig_plus.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_207_sig_plus.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_207_sig_plus.snap.rs b/tests-snapshots/dbc-cantools/issue_207_sig_plus.snap.rs new file mode 100644 index 0000000..a55a048 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_207_sig_plus.snap.rs @@ -0,0 +1,257 @@ +// Generated code! +// +// Message definitions from file `issue_207_sig_plus` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// myMsg + MyMsg(MyMsg), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + MyMsg::MESSAGE_ID => Messages::MyMsg(MyMsg::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// myMsg +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MyMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MyMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const MY_EXTRA_SIG_WITH_PLUS_MIN: i16 = -128_i16; + pub const MY_EXTRA_SIG_WITH_PLUS_MAX: i16 = 127_i16; + pub const MY_NORMAL_SIG_MIN: i16 = -128_i16; + pub const MY_NORMAL_SIG_MAX: i16 = 127_i16; + + /// Construct new myMsg from values + pub fn new(my_extra_sig_with_plus: i16, my_normal_sig: i16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_my_extra_sig_with_plus(my_extra_sig_with_plus)?; + res.set_my_normal_sig(my_normal_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// myExtraSigWithPlus + /// + /// - Min: -128 + /// - Max: 127 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn my_extra_sig_with_plus(&self) -> i16 { + self.my_extra_sig_with_plus_raw() + } + + /// Get raw value of myExtraSigWithPlus + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: -128 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn my_extra_sig_with_plus_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + i16::from(signal).saturating_mul(factor).saturating_sub(128) + } + + /// Set value of myExtraSigWithPlus + #[inline(always)] + pub fn set_my_extra_sig_with_plus(&mut self, value: i16) -> Result<(), CanError> { + if value < -128_i16 || 127_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: MyMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(128) + .ok_or(CanError::ParameterOutOfRange { message_id: MyMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// myNormalSig + /// + /// - Min: -128 + /// - Max: 127 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn my_normal_sig(&self) -> i16 { + self.my_normal_sig_raw() + } + + /// Get raw value of myNormalSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: -128 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn my_normal_sig_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + i16::from(signal).saturating_mul(factor).saturating_sub(128) + } + + /// Set value of myNormalSig + #[inline(always)] + pub fn set_my_normal_sig(&mut self, value: i16) -> Result<(), CanError> { + if value < -128_i16 || 127_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: MyMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(128) + .ok_or(CanError::ParameterOutOfRange { message_id: MyMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MyMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MyMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_228.snap b/tests-snapshots/dbc-cantools/issue_228.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_228.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_228.snap.rs b/tests-snapshots/dbc-cantools/issue_228.snap.rs new file mode 100644 index 0000000..7ea8e76 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_228.snap.rs @@ -0,0 +1,487 @@ +// Generated code! +// +// Message definitions from file `issue_228` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// SGMsg + SgMsg(SgMsg), + /// NormalMsg + NormalMsg(NormalMsg), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + SgMsg::MESSAGE_ID => Messages::SgMsg(SgMsg::try_from(payload)?), + NormalMsg::MESSAGE_ID => Messages::NormalMsg(NormalMsg::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// SGMsg +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SG2_MIN: i8 = 0_i8; + pub const SG2_MAX: i8 = 0_i8; + pub const SG1_MIN: i8 = 0_i8; + pub const SG1_MAX: i8 = 0_i8; + + /// Construct new SGMsg from values + pub fn new(dupsig: i8, sg2: i8, sg1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sg2(sg2)?; + res.set_sg1(sg1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// SG2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg2(&self) -> i8 { + self.sg2_raw() + } + + /// Get raw value of SG2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG2 + #[inline(always)] + pub fn set_sg2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// SG1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg1(&self) -> i8 { + self.sg1_raw() + } + + /// Get raw value of SG1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG1 + #[inline(always)] + pub fn set_sg1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// NormalMsg +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct NormalMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const SIG_2_MIN: i8 = 0_i8; + pub const SIG_2_MAX: i8 = 0_i8; + pub const SIG_1_MIN: i8 = 0_i8; + pub const SIG_1_MAX: i8 = 0_i8; + + /// Construct new NormalMsg from values + pub fn new(sig_2: i8, sig_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_2(sig_2)?; + res.set_sig_1(sig_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_2(&self) -> i8 { + self.sig_2_raw() + } + + /// Get raw value of Sig_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_2 + #[inline(always)] + pub fn set_sig_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_1(&self) -> i8 { + self.sig_1_raw() + } + + /// Get raw value of Sig_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_1 + #[inline(always)] + pub fn set_sig_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for NormalMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for NormalMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_62.snap b/tests-snapshots/dbc-cantools/issue_62.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_62.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_62.snap.rs b/tests-snapshots/dbc-cantools/issue_62.snap.rs new file mode 100644 index 0000000..5c51086 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_62.snap.rs @@ -0,0 +1,78 @@ +// Generated code! +// +// Message definitions from file `issue_62` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_62.snap.stderr b/tests-snapshots/dbc-cantools/issue_62.snap.stderr new file mode 100644 index 0000000..a59aadb --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_62.snap.stderr @@ -0,0 +1,13 @@ +error: unreachable expression + --> tests-snapshots/dbc-cantools/issue_62.snap.rs:44:9 + | +41 | let res = match id { + | ___________________- +42 | | id => return Err(CanError::UnknownMessageId(id)), +43 | | }; + | |_________- any code following this `match` expression is unreachable, as all arms diverge +44 | Ok(res) + | ^^^^^^^ unreachable expression + | + = note: `-D unreachable-code` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_code)]` diff --git a/tests-snapshots/dbc-cantools/issue_63.snap b/tests-snapshots/dbc-cantools/issue_63.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_63.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_63.snap.rs b/tests-snapshots/dbc-cantools/issue_63.snap.rs new file mode 100644 index 0000000..06100b1 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_63.snap.rs @@ -0,0 +1,435 @@ +// Generated code! +// +// Message definitions from file `issue_63` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// AFT1PSI2 + Aft1psi2(Aft1psi2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Aft1psi2::MESSAGE_ID => Messages::Aft1psi2(Aft1psi2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// AFT1PSI2 +/// +/// - Extended ID: 419204094 (0x18fc8bfe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Aft1psi2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Aft1psi2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x18fc8bfe)}); + + pub const HTR_RES_MIN: f32 = 0_f32; + pub const HTR_RES_MAX: f32 = 6425.5_f32; + pub const MAX_RES_MIN: u32 = 0_u32; + pub const MAX_RES_MAX: u32 = 62500_u32; + pub const TEMP_MIN: f32 = -273_f32; + pub const TEMP_MAX: f32 = 1734.96875_f32; + pub const REGEN_FAILED_COUNT_MIN: u8 = 0_u8; + pub const REGEN_FAILED_COUNT_MAX: u8 = 250_u8; + pub const PWR_SUPPLY_MIN: u8 = 0_u8; + pub const PWR_SUPPLY_MAX: u8 = 3_u8; + pub const DETECTION_STATUS_MIN: u8 = 0_u8; + pub const DETECTION_STATUS_MAX: u8 = 15_u8; + + /// Construct new AFT1PSI2 from values + pub fn new(htr_res: f32, max_res: u32, temp: f32, regen_failed_count: u8, pwr_supply: u8, detection_status: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_htr_res(htr_res)?; + res.set_max_res(max_res)?; + res.set_temp(temp)?; + res.set_regen_failed_count(regen_failed_count)?; + res.set_pwr_supply(pwr_supply)?; + res.set_detection_status(detection_status)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// HtrRes + /// + /// - Min: 0 + /// - Max: 6425.5 + /// - Unit: "ohm" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn htr_res(&self) -> f32 { + self.htr_res_raw() + } + + /// Get raw value of HtrRes + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn htr_res_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of HtrRes + #[inline(always)] + pub fn set_htr_res(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 6425.5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// MaxRes + /// + /// - Min: 0 + /// - Max: 62500 + /// - Unit: "kohm" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn max_res(&self) -> u32 { + self.max_res_raw() + } + + /// Get raw value of MaxRes + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 250 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn max_res_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 250; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MaxRes + #[inline(always)] + pub fn set_max_res(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 62500_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID }); + } + let factor = 250; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Temp + /// + /// - Min: -273 + /// - Max: 1734.96875 + /// - Unit: "�C" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temp(&self) -> f32 { + self.temp_raw() + } + + /// Get raw value of Temp + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.03125 + /// - Offset: -273 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn temp_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.03125_f32; + let offset = -273_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temp + #[inline(always)] + pub fn set_temp(&mut self, value: f32) -> Result<(), CanError> { + if value < -273_f32 || 1734.96875_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID }); + } + let factor = 0.03125_f32; + let offset = -273_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// RegenFailedCount + /// + /// - Min: 0 + /// - Max: 250 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn regen_failed_count(&self) -> u8 { + self.regen_failed_count_raw() + } + + /// Get raw value of RegenFailedCount + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn regen_failed_count_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of RegenFailedCount + #[inline(always)] + pub fn set_regen_failed_count(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 250_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// PwrSupply + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn pwr_supply(&self) -> u8 { + self.pwr_supply_raw() + } + + /// Get raw value of PwrSupply + /// + /// - Start bit: 4 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn pwr_supply_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..6].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of PwrSupply + #[inline(always)] + pub fn set_pwr_supply(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..6].store_le(value); + Ok(()) + } + + /// DetectionStatus + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn detection_status(&self) -> u8 { + self.detection_status_raw() + } + + /// Get raw value of DetectionStatus + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn detection_status_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of DetectionStatus + #[inline(always)] + pub fn set_detection_status(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Aft1psi2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Aft1psi2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Aft1psi2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_636_negative_scaling.snap b/tests-snapshots/dbc-cantools/issue_636_negative_scaling.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_636_negative_scaling.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_636_negative_scaling.snap.rs b/tests-snapshots/dbc-cantools/issue_636_negative_scaling.snap.rs new file mode 100644 index 0000000..1d27acd --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_636_negative_scaling.snap.rs @@ -0,0 +1,246 @@ +// Generated code! +// +// Message definitions from file `issue_636_negative_scaling` +// Version: 1.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ExampleMessage + ExampleMessage(ExampleMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExampleMessage::MESSAGE_ID => Messages::ExampleMessage(ExampleMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ExampleMessage +/// +/// - Standard ID: 496 (0x1f0) +/// - Size: 2 bytes +/// - Transmitter: PCM1 +/// +/// Example message +#[derive(Clone, Copy)] +pub struct ExampleMessage { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExampleMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f0)}); + + pub const TEMPERATURE_MIN: f32 = 4070_f32; + pub const TEMPERATURE_MAX: f32 = 4100_f32; + + /// Construct new ExampleMessage from values + pub fn new(temperature: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature(temperature)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature + /// + /// - Min: 4070 + /// - Max: 4100 + /// - Unit: "degK" + /// - Receivers: PCM1, FOO + #[inline(always)] + pub fn temperature(&self) -> ExampleMessageTemperature { + let signal = self.raw.view_bits::()[4..16].load_be::(); + + match signal { + 4095 => ExampleMessageTemperature::Error, + 4094 => ExampleMessageTemperature::Init, + _ => ExampleMessageTemperature::_Other(self.temperature_raw()), + } + } + + /// Get raw value of Temperature + /// + /// - Start bit: 3 + /// - Signal size: 12 bits + /// - Factor: -0.01 + /// - Offset: 4100 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn temperature_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[4..16].load_be::(); + + let factor = -0.01_f32; + let offset = 4100_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature + #[inline(always)] + pub fn set_temperature(&mut self, value: f32) -> Result<(), CanError> { + if value < 4070_f32 || 4100_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = -0.01_f32; + let offset = 4100_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[4..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExampleMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExampleMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Temperature +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageTemperature { + Error, + Init, + _Other(f32), +} + +impl From for f32 { + fn from(val: ExampleMessageTemperature) -> f32 { + match val { + ExampleMessageTemperature::Error => 4095_f32, + ExampleMessageTemperature::Init => 4094_f32, + ExampleMessageTemperature::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/issue_725.snap b/tests-snapshots/dbc-cantools/issue_725.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_725.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/issue_725.snap.rs b/tests-snapshots/dbc-cantools/issue_725.snap.rs new file mode 100644 index 0000000..0597d61 --- /dev/null +++ b/tests-snapshots/dbc-cantools/issue_725.snap.rs @@ -0,0 +1,211 @@ +// Generated code! +// +// Message definitions from file `issue_725` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// TestMessage + TestMessage(TestMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + TestMessage::MESSAGE_ID => Messages::TestMessage(TestMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// TestMessage +/// +/// - Standard ID: 1 (0x1) +/// - Size: 1 bytes +/// - Transmitter: Node1 +#[derive(Clone, Copy)] +pub struct TestMessage { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const SIGNAL1_MIN: u8 = 0_u8; + pub const SIGNAL1_MAX: u8 = 250_u8; + + /// Construct new TestMessage from values + pub fn new(signal1: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 250 + /// - Unit: "" + /// - Receivers: Node2 + #[inline(always)] + pub fn signal1(&self) -> u8 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 250_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/j1939.snap b/tests-snapshots/dbc-cantools/j1939.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/j1939.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/j1939.snap.rs b/tests-snapshots/dbc-cantools/j1939.snap.rs new file mode 100644 index 0000000..bbc0152 --- /dev/null +++ b/tests-snapshots/dbc-cantools/j1939.snap.rs @@ -0,0 +1,348 @@ +// Generated code! +// +// Message definitions from file `j1939` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), + /// Message2 + Message2(Message2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Extended ID: 355729921 (0x15340201) +/// - Size: 8 bytes +/// - Transmitter: Node1 +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x15340201)}); + + pub const SIGNAL1_MIN: i8 = 0_i8; + pub const SIGNAL1_MAX: i8 = 0_i8; + + /// Construct new Message1 from values + pub fn new(signal1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Node2 + #[inline(always)] + pub fn signal1(&self) -> i8 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message2 +/// +/// - Extended ID: 368054274 (0x15f01002) +/// - Size: 8 bytes +/// - Transmitter: Node2 +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x15f01002)}); + + pub const SIGNAL2_MIN: i8 = 0_i8; + pub const SIGNAL2_MAX: i8 = 0_i8; + + /// Construct new Message2 from values + pub fn new(signal2: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal2(signal2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Node1 + #[inline(always)] + pub fn signal2(&self) -> i8 { + self.signal2_raw() + } + + /// Get raw value of Signal2 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal2 + #[inline(always)] + pub fn set_signal2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/long_names.snap b/tests-snapshots/dbc-cantools/long_names.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/long_names.snap.rs b/tests-snapshots/dbc-cantools/long_names.snap.rs new file mode 100644 index 0000000..8e7d723 --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names.snap.rs @@ -0,0 +1,1561 @@ +// Generated code! +// +// Message definitions from file `long_names` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// SS123456789012345678901234587890 + Ss123456789012345678901234587890(Ss123456789012345678901234587890), + /// SS1234567890123456789012345_0000 + Ss12345678901234567890123450000(Ss12345678901234567890123450000), + /// SS1234567890123456789012345_0001 + Ss12345678901234567890123450001(Ss12345678901234567890123450001), + /// SS123456789012345678901234577890 + Ss123456789012345678901234577890(Ss123456789012345678901234577890), + /// SS123456789012345678901234567890 + Ss123456789012345678901234567890(Ss123456789012345678901234567890), + /// S1234567890123456789012345678901 + S1234567890123456789012345678901(S1234567890123456789012345678901), + /// M12345678901234567890123456_0000 + M123456789012345678901234560000(M123456789012345678901234560000), + /// M1234567890123456789012345678901 + M1234567890123456789012345678901(M1234567890123456789012345678901), + /// M12345678901234567890123456_0001 + M123456789012345678901234560001(M123456789012345678901234560001), + /// MM123456789012345678901234567890 + Mm123456789012345678901234567890(Mm123456789012345678901234567890), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Ss123456789012345678901234587890::MESSAGE_ID => Messages::Ss123456789012345678901234587890(Ss123456789012345678901234587890::try_from(payload)?), + Ss12345678901234567890123450000::MESSAGE_ID => Messages::Ss12345678901234567890123450000(Ss12345678901234567890123450000::try_from(payload)?), + Ss12345678901234567890123450001::MESSAGE_ID => Messages::Ss12345678901234567890123450001(Ss12345678901234567890123450001::try_from(payload)?), + Ss123456789012345678901234577890::MESSAGE_ID => Messages::Ss123456789012345678901234577890(Ss123456789012345678901234577890::try_from(payload)?), + Ss123456789012345678901234567890::MESSAGE_ID => Messages::Ss123456789012345678901234567890(Ss123456789012345678901234567890::try_from(payload)?), + S1234567890123456789012345678901::MESSAGE_ID => Messages::S1234567890123456789012345678901(S1234567890123456789012345678901::try_from(payload)?), + M123456789012345678901234560000::MESSAGE_ID => Messages::M123456789012345678901234560000(M123456789012345678901234560000::try_from(payload)?), + M1234567890123456789012345678901::MESSAGE_ID => Messages::M1234567890123456789012345678901(M1234567890123456789012345678901::try_from(payload)?), + M123456789012345678901234560001::MESSAGE_ID => Messages::M123456789012345678901234560001(M123456789012345678901234560001::try_from(payload)?), + Mm123456789012345678901234567890::MESSAGE_ID => Messages::Mm123456789012345678901234567890(Mm123456789012345678901234567890::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// SS123456789012345678901234587890 +/// +/// - Standard ID: 9 (0x9) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Ss123456789012345678901234587890 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Ss123456789012345678901234587890 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x9)}); + + + /// Construct new SS123456789012345678901234587890 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Ss123456789012345678901234587890 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Ss123456789012345678901234587890 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SS1234567890123456789012345_0000 +/// +/// - Standard ID: 8 (0x8) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Ss12345678901234567890123450000 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Ss12345678901234567890123450000 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x8)}); + + + /// Construct new SS1234567890123456789012345_0000 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Ss12345678901234567890123450000 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Ss12345678901234567890123450000 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SS1234567890123456789012345_0001 +/// +/// - Standard ID: 7 (0x7) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Ss12345678901234567890123450001 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Ss12345678901234567890123450001 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x7)}); + + + /// Construct new SS1234567890123456789012345_0001 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Ss12345678901234567890123450001 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Ss12345678901234567890123450001 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SS123456789012345678901234577890 +/// +/// - Standard ID: 6 (0x6) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Ss123456789012345678901234577890 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Ss123456789012345678901234577890 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x6)}); + + + /// Construct new SS123456789012345678901234577890 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Ss123456789012345678901234577890 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Ss123456789012345678901234577890 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SS123456789012345678901234567890 +/// +/// - Standard ID: 5 (0x5) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Ss123456789012345678901234567890 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Ss123456789012345678901234567890 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x5)}); + + + /// Construct new SS123456789012345678901234567890 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Ss123456789012345678901234567890 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Ss123456789012345678901234567890 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// S1234567890123456789012345678901 +/// +/// - Standard ID: 4 (0x4) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct S1234567890123456789012345678901 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl S1234567890123456789012345678901 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + + pub const SS123456789012345678901234567890_MIN: i8 = 0_i8; + pub const SS123456789012345678901234567890_MAX: i8 = 0_i8; + + /// Construct new S1234567890123456789012345678901 from values + pub fn new(ss123456789012345678901234567890: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ss123456789012345678901234567890(ss123456789012345678901234567890)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SS123456789012345678901234567890 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ss123456789012345678901234567890(&self) -> i8 { + self.ss123456789012345678901234567890_raw() + } + + /// Get raw value of SS123456789012345678901234567890 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss123456789012345678901234567890_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS123456789012345678901234567890 + #[inline(always)] + pub fn set_ss123456789012345678901234567890(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: S1234567890123456789012345678901::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: S1234567890123456789012345678901::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for S1234567890123456789012345678901 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for S1234567890123456789012345678901 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// M12345678901234567890123456_0000 +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct M123456789012345678901234560000 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl M123456789012345678901234560000 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const SSS12345678901234567890123456789_MIN: i8 = 0_i8; + pub const SSS12345678901234567890123456789_MAX: i8 = 0_i8; + + /// Construct new M12345678901234567890123456_0000 from values + pub fn new(sss12345678901234567890123456789: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sss12345678901234567890123456789(sss12345678901234567890123456789)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SSS12345678901234567890123456789 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sss12345678901234567890123456789(&self) -> i8 { + self.sss12345678901234567890123456789_raw() + } + + /// Get raw value of SSS12345678901234567890123456789 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sss12345678901234567890123456789_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SSS12345678901234567890123456789 + #[inline(always)] + pub fn set_sss12345678901234567890123456789(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560000::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560000::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for M123456789012345678901234560000 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for M123456789012345678901234560000 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// M1234567890123456789012345678901 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +/// - Transmitter: N1234567890123456789012345678901 +#[derive(Clone, Copy)] +pub struct M1234567890123456789012345678901 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl M1234567890123456789012345678901 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const SS1234567890123456789012345_0000_MIN: i8 = 0_i8; + pub const SS1234567890123456789012345_0000_MAX: i8 = 0_i8; + pub const SS1234567890123456789012345_0001_MIN: i8 = 0_i8; + pub const SS1234567890123456789012345_0001_MAX: i8 = 0_i8; + pub const SS1234567890123456789012345_0002_MIN: i8 = 0_i8; + pub const SS1234567890123456789012345_0002_MAX: i8 = 0_i8; + pub const S12345678901234567890123456_0000_MIN: i8 = 0_i8; + pub const S12345678901234567890123456_0000_MAX: i8 = 0_i8; + pub const S1234567890123456789012345678901_MIN: i8 = 0_i8; + pub const S1234567890123456789012345678901_MAX: i8 = 0_i8; + + /// Construct new M1234567890123456789012345678901 from values + pub fn new(ss1234567890123456789012345_0000: i8, ss1234567890123456789012345_0001: i8, ss1234567890123456789012345_0002: i8, s12345678901234567890123456_0000: i8, s1234567890123456789012345678901: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ss1234567890123456789012345_0000(ss1234567890123456789012345_0000)?; + res.set_ss1234567890123456789012345_0001(ss1234567890123456789012345_0001)?; + res.set_ss1234567890123456789012345_0002(ss1234567890123456789012345_0002)?; + res.set_s12345678901234567890123456_0000(s12345678901234567890123456_0000)?; + res.set_s1234567890123456789012345678901(s1234567890123456789012345678901)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SS1234567890123456789012345_0000 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ss1234567890123456789012345_0000(&self) -> i8 { + self.ss1234567890123456789012345_0000_raw() + } + + /// Get raw value of SS1234567890123456789012345_0000 + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss1234567890123456789012345_0000_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS1234567890123456789012345_0000 + #[inline(always)] + pub fn set_ss1234567890123456789012345_0000(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// SS1234567890123456789012345_0001 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ss1234567890123456789012345_0001(&self) -> i8 { + self.ss1234567890123456789012345_0001_raw() + } + + /// Get raw value of SS1234567890123456789012345_0001 + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss1234567890123456789012345_0001_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS1234567890123456789012345_0001 + #[inline(always)] + pub fn set_ss1234567890123456789012345_0001(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// SS1234567890123456789012345_0002 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: N12345678901234567890123456_0000 + #[inline(always)] + pub fn ss1234567890123456789012345_0002(&self) -> i8 { + self.ss1234567890123456789012345_0002_raw() + } + + /// Get raw value of SS1234567890123456789012345_0002 + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss1234567890123456789012345_0002_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS1234567890123456789012345_0002 + #[inline(always)] + pub fn set_ss1234567890123456789012345_0002(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// S12345678901234567890123456_0000 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s12345678901234567890123456_0000(&self) -> i8 { + self.s12345678901234567890123456_0000_raw() + } + + /// Get raw value of S12345678901234567890123456_0000 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s12345678901234567890123456_0000_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of S12345678901234567890123456_0000 + #[inline(always)] + pub fn set_s12345678901234567890123456_0000(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// S1234567890123456789012345678901 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s1234567890123456789012345678901(&self) -> i8 { + self.s1234567890123456789012345678901_raw() + } + + /// Get raw value of S1234567890123456789012345678901 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s1234567890123456789012345678901_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of S1234567890123456789012345678901 + #[inline(always)] + pub fn set_s1234567890123456789012345678901(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M1234567890123456789012345678901::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for M1234567890123456789012345678901 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for M1234567890123456789012345678901 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// M12345678901234567890123456_0001 +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +/// - Transmitter: N12345678901234567890123456_0001 +#[derive(Clone, Copy)] +pub struct M123456789012345678901234560001 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl M123456789012345678901234560001 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const SS1234567890123456789012345_0003_MIN: i8 = 0_i8; + pub const SS1234567890123456789012345_0003_MAX: i8 = 0_i8; + pub const SS1234567890123456789012345_0004_MIN: i8 = 0_i8; + pub const SS1234567890123456789012345_0004_MAX: i8 = 0_i8; + pub const S12345678901234567890123456_0001_MIN: i8 = 0_i8; + pub const S12345678901234567890123456_0001_MAX: i8 = 0_i8; + pub const S12345678901234567890123456_0002_MIN: i8 = 0_i8; + pub const S12345678901234567890123456_0002_MAX: i8 = 0_i8; + + /// Construct new M12345678901234567890123456_0001 from values + pub fn new(ss1234567890123456789012345_0003: i8, ss1234567890123456789012345_0004: i8, s12345678901234567890123456_0001: i8, s12345678901234567890123456_0002: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ss1234567890123456789012345_0003(ss1234567890123456789012345_0003)?; + res.set_ss1234567890123456789012345_0004(ss1234567890123456789012345_0004)?; + res.set_s12345678901234567890123456_0001(s12345678901234567890123456_0001)?; + res.set_s12345678901234567890123456_0002(s12345678901234567890123456_0002)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SS1234567890123456789012345_0003 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ss1234567890123456789012345_0003(&self) -> i8 { + self.ss1234567890123456789012345_0003_raw() + } + + /// Get raw value of SS1234567890123456789012345_0003 + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss1234567890123456789012345_0003_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS1234567890123456789012345_0003 + #[inline(always)] + pub fn set_ss1234567890123456789012345_0003(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// SS1234567890123456789012345_0004 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ss1234567890123456789012345_0004(&self) -> i8 { + self.ss1234567890123456789012345_0004_raw() + } + + /// Get raw value of SS1234567890123456789012345_0004 + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss1234567890123456789012345_0004_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS1234567890123456789012345_0004 + #[inline(always)] + pub fn set_ss1234567890123456789012345_0004(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// S12345678901234567890123456_0001 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s12345678901234567890123456_0001(&self) -> i8 { + self.s12345678901234567890123456_0001_raw() + } + + /// Get raw value of S12345678901234567890123456_0001 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s12345678901234567890123456_0001_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of S12345678901234567890123456_0001 + #[inline(always)] + pub fn set_s12345678901234567890123456_0001(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// S12345678901234567890123456_0002 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s12345678901234567890123456_0002(&self) -> i8 { + self.s12345678901234567890123456_0002_raw() + } + + /// Get raw value of S12345678901234567890123456_0002 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s12345678901234567890123456_0002_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of S12345678901234567890123456_0002 + #[inline(always)] + pub fn set_s12345678901234567890123456_0002(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: M123456789012345678901234560001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for M123456789012345678901234560001 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for M123456789012345678901234560001 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MM123456789012345678901234567890 +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Mm123456789012345678901234567890 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Mm123456789012345678901234567890 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + pub const SSS123456789012345678901234_0000_MIN: i8 = 0_i8; + pub const SSS123456789012345678901234_0000_MAX: i8 = 0_i8; + pub const SS1234567890123456789012345_0005_MIN: i8 = 0_i8; + pub const SS1234567890123456789012345_0005_MAX: i8 = 0_i8; + + /// Construct new MM123456789012345678901234567890 from values + pub fn new(sss123456789012345678901234_0000: i8, ss1234567890123456789012345_0005: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sss123456789012345678901234_0000(sss123456789012345678901234_0000)?; + res.set_ss1234567890123456789012345_0005(ss1234567890123456789012345_0005)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SSS123456789012345678901234_0000 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sss123456789012345678901234_0000(&self) -> i8 { + self.sss123456789012345678901234_0000_raw() + } + + /// Get raw value of SSS123456789012345678901234_0000 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sss123456789012345678901234_0000_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SSS123456789012345678901234_0000 + #[inline(always)] + pub fn set_sss123456789012345678901234_0000(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm123456789012345678901234567890::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Mm123456789012345678901234567890::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// SS1234567890123456789012345_0005 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ss1234567890123456789012345_0005(&self) -> i8 { + self.ss1234567890123456789012345_0005_raw() + } + + /// Get raw value of SS1234567890123456789012345_0005 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ss1234567890123456789012345_0005_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SS1234567890123456789012345_0005 + #[inline(always)] + pub fn set_ss1234567890123456789012345_0005(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Mm123456789012345678901234567890::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Mm123456789012345678901234567890::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Mm123456789012345678901234567890 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Mm123456789012345678901234567890 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap b/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs b/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs new file mode 100644 index 0000000..cb588fa --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs @@ -0,0 +1,1528 @@ +// Generated code! +// +// Message definitions from file `long_names_multiple_relations` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Msg_Long_Name_56789_123456789_12 + MsgLongName5678912345678912(MsgLongName5678912345678912), + /// TX_twice + TxTwice(TxTwice), + /// RX_TX_1 + RxTx1(RxTx1), + /// MSG_CASE_TEST + MsgCaseTest(MsgCaseTest), + /// msg_case_test + MsgCaseTest(MsgCaseTest), + /// Msg_with_value_table_sigs + MsgWithValueTableSigs(MsgWithValueTableSigs), + /// Msg_Long_Name_56789_1234567_0000 + MsgLongName5678912345670000(MsgLongName5678912345670000), + /// Msg_Long_Name_56789_1234567_0001 + MsgLongName5678912345670001(MsgLongName5678912345670001), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + MsgLongName5678912345678912::MESSAGE_ID => Messages::MsgLongName5678912345678912(MsgLongName5678912345678912::try_from(payload)?), + TxTwice::MESSAGE_ID => Messages::TxTwice(TxTwice::try_from(payload)?), + RxTx1::MESSAGE_ID => Messages::RxTx1(RxTx1::try_from(payload)?), + MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + MsgWithValueTableSigs::MESSAGE_ID => Messages::MsgWithValueTableSigs(MsgWithValueTableSigs::try_from(payload)?), + MsgLongName5678912345670000::MESSAGE_ID => Messages::MsgLongName5678912345670000(MsgLongName5678912345670000::try_from(payload)?), + MsgLongName5678912345670001::MESSAGE_ID => Messages::MsgLongName5678912345670001(MsgLongName5678912345670001::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Msg_Long_Name_56789_123456789_12 +/// +/// - Standard ID: 85 (0x55) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgLongName5678912345678912 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgLongName5678912345678912 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x55)}); + + pub const RX_TWICE_11111111111111111111111_MIN: i8 = 0_i8; + pub const RX_TWICE_11111111111111111111111_MAX: i8 = 0_i8; + pub const RX_TWICE_SHORT_MIN: i32 = 0_i32; + pub const RX_TWICE_SHORT_MAX: i32 = 0_i32; + pub const SIG_USED_TWICE_EFGH_ABCDEFGHI_AB_MIN: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFGHI_AB_MAX: i8 = 0_i8; + + /// Construct new Msg_Long_Name_56789_123456789_12 from values + pub fn new(rx_twice_11111111111111111111111: i8, rx_twice_short: i32, sig_used_twice_efgh_abcdefghi_ab: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rx_twice_11111111111111111111111(rx_twice_11111111111111111111111)?; + res.set_rx_twice_short(rx_twice_short)?; + res.set_sig_used_twice_efgh_abcdefghi_ab(sig_used_twice_efgh_abcdefghi_ab)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// rx_twice_11111111111111111111111 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_11111111111111111111111(&self) -> i8 { + self.rx_twice_11111111111111111111111_raw() + } + + /// Get raw value of rx_twice_11111111111111111111111 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_11111111111111111111111_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_11111111111111111111111 + #[inline(always)] + pub fn set_rx_twice_11111111111111111111111(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// rx_twice_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_short(&self) -> i32 { + self.rx_twice_short_raw() + } + + /// Get raw value of rx_twice_short + /// + /// - Start bit: 16 + /// - Signal size: 18 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_short_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[16..34].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_short + #[inline(always)] + pub fn set_rx_twice_short(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..34].store_le(value); + Ok(()) + } + + /// Sig_used_twice_efgh_abcdefghi_ab + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefghi_ab(&self) -> i8 { + self.sig_used_twice_efgh_abcdefghi_ab_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefghi_ab + /// + /// - Start bit: 0 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefghi_ab_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..6].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefghi_ab + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefghi_ab(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..6].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgLongName5678912345678912 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgLongName5678912345678912 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TX_twice +/// +/// - Standard ID: 6 (0x6) +/// - Size: 2 bytes +/// - Transmitter: Node_6789_123456789_123456789_12 +#[derive(Clone, Copy)] +pub struct TxTwice { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TxTwice { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x6)}); + + pub const RX_TWICE_LONG_YYYYYYYYYYYYYYYYYY_MIN: i8 = 0_i8; + pub const RX_TWICE_LONG_YYYYYYYYYYYYYYYYYY_MAX: i8 = 0_i8; + pub const RX_TWICE_SHORT_MIN: i8 = 0_i8; + pub const RX_TWICE_SHORT_MAX: i8 = 0_i8; + + /// Construct new TX_twice from values + pub fn new(rx_twice_long_yyyyyyyyyyyyyyyyyy: i8, rx_twice_short: i8) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_rx_twice_long_yyyyyyyyyyyyyyyyyy(rx_twice_long_yyyyyyyyyyyyyyyyyy)?; + res.set_rx_twice_short(rx_twice_short)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// rx_twice_long_yyyyyyyyyyyyyyyyyy + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Receiver_1, Receiver_2_zzzzzzzzzzzzzzzzzzzzz + #[inline(always)] + pub fn rx_twice_long_yyyyyyyyyyyyyyyyyy(&self) -> i8 { + self.rx_twice_long_yyyyyyyyyyyyyyyyyy_raw() + } + + /// Get raw value of rx_twice_long_yyyyyyyyyyyyyyyyyy + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_long_yyyyyyyyyyyyyyyyyy_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_long_yyyyyyyyyyyyyyyyyy + #[inline(always)] + pub fn set_rx_twice_long_yyyyyyyyyyyyyyyyyy(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// rx_twice_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Receiver_2_zzzzzzzzzzzzzzzzzzzzz, Receiver_1 + #[inline(always)] + pub fn rx_twice_short(&self) -> i8 { + self.rx_twice_short_raw() + } + + /// Get raw value of rx_twice_short + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_short_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_short + #[inline(always)] + pub fn set_rx_twice_short(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TxTwice { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TxTwice { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RX_TX_1 +/// +/// - Standard ID: 5 (0x5) +/// - Size: 8 bytes +/// - Transmitter: Node_6789_123456789_123456789_12 +#[derive(Clone, Copy)] +pub struct RxTx1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RxTx1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x5)}); + + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0000_MIN: i16 = 0_i16; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0000_MAX: i16 = 0_i16; + + /// Construct new RX_TX_1 from values + pub fn new(sig_used_twice_efgh_abcdefg_0000: i16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_used_twice_efgh_abcdefg_0000(sig_used_twice_efgh_abcdefg_0000)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_used_twice_efgh_abcdefg_0000 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0000(&self) -> i16 { + self.sig_used_twice_efgh_abcdefg_0000_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefg_0000 + /// + /// - Start bit: 0 + /// - Signal size: 9 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0000_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..9].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefg_0000 + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefg_0000(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 0_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: RxTx1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RxTx1::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..9].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RxTx1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RxTx1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MSG_CASE_TEST +/// +/// - Standard ID: 4 (0x4) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgCaseTest { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgCaseTest { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + + + /// Construct new MSG_CASE_TEST from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgCaseTest { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// msg_case_test +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgCaseTest { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgCaseTest { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + + /// Construct new msg_case_test from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgCaseTest { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Msg_with_value_table_sigs +/// +/// - Standard ID: 2 (0x2) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct MsgWithValueTableSigs { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgWithValueTableSigs { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const SIG_WITH_SHORT_VAL_TABLE_MIN: i8 = 0_i8; + pub const SIG_WITH_SHORT_VAL_TABLE_MAX: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_2_MIN: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_2_MAX: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_1_MIN: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_1_MAX: i8 = 0_i8; + + /// Construct new Msg_with_value_table_sigs from values + pub fn new(sig_with_short_val_table: i8, sig_with_long_val_table_2: i8, sig_with_long_val_table_1: i8) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_sig_with_short_val_table(sig_with_short_val_table)?; + res.set_sig_with_long_val_table_2(sig_with_long_val_table_2)?; + res.set_sig_with_long_val_table_1(sig_with_long_val_table_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Sig_with_short_val_table + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_with_short_val_table(&self) -> MsgWithValueTableSigsSigWithShortValTable { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + match signal { + 1 => MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x1, + 0 => MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x0, + _ => MsgWithValueTableSigsSigWithShortValTable::_Other(self.sig_with_short_val_table_raw()), + } + } + + /// Get raw value of Sig_with_short_val_table + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_with_short_val_table_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_with_short_val_table + #[inline(always)] + pub fn set_sig_with_short_val_table(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Sig_with_long_val_table_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_with_long_val_table_2(&self) -> MsgWithValueTableSigsSigWithLongValTable2 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 13 => MsgWithValueTableSigsSigWithLongValTable2::Value0xD, + 12 => MsgWithValueTableSigsSigWithLongValTable2::Dvalue0xC, + 11 => MsgWithValueTableSigsSigWithLongValTable2::Value0xB, + 10 => MsgWithValueTableSigsSigWithLongValTable2::Value0xA, + 9 => MsgWithValueTableSigsSigWithLongValTable2::Value0x9, + 8 => MsgWithValueTableSigsSigWithLongValTable2::Value0x8, + 7 => MsgWithValueTableSigsSigWithLongValTable2::Value0x7, + 6 => MsgWithValueTableSigsSigWithLongValTable2::Value0x6, + 5 => MsgWithValueTableSigsSigWithLongValTable2::Value0x5, + 4 => MsgWithValueTableSigsSigWithLongValTable2::Value0x4, + 3 => MsgWithValueTableSigsSigWithLongValTable2::Value0x3, + 2 => MsgWithValueTableSigsSigWithLongValTable2::Value0x2, + 1 => MsgWithValueTableSigsSigWithLongValTable2::Value0x1, + 0 => MsgWithValueTableSigsSigWithLongValTable2::Value0x0, + _ => MsgWithValueTableSigsSigWithLongValTable2::_Other(self.sig_with_long_val_table_2_raw()), + } + } + + /// Get raw value of Sig_with_long_val_table_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_with_long_val_table_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_with_long_val_table_2 + #[inline(always)] + pub fn set_sig_with_long_val_table_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_with_long_val_table_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_with_long_val_table_1(&self) -> MsgWithValueTableSigsSigWithLongValTable1 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 3 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x3, + 2 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x2, + 1 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x1, + 0 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x0, + _ => MsgWithValueTableSigsSigWithLongValTable1::_Other(self.sig_with_long_val_table_1_raw()), + } + } + + /// Get raw value of Sig_with_long_val_table_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_with_long_val_table_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_with_long_val_table_1 + #[inline(always)] + pub fn set_sig_with_long_val_table_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgWithValueTableSigs { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgWithValueTableSigs { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Sig_with_short_val_table +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum MsgWithValueTableSigsSigWithShortValTable { + VeryLongLongLongDescriptionForTheValue0x1, + VeryLongLongLongDescriptionForTheValue0x0, + _Other(i8), +} + +impl From for i8 { + fn from(val: MsgWithValueTableSigsSigWithShortValTable) -> i8 { + match val { + MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x1 => 1, + MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x0 => 0, + MsgWithValueTableSigsSigWithShortValTable::_Other(x) => x, + } + } +} + +/// Defined values for Sig_with_long_val_table_2 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum MsgWithValueTableSigsSigWithLongValTable2 { + Value0xD, + Dvalue0xC, + Value0xB, + Value0xA, + Value0x9, + Value0x8, + Value0x7, + Value0x6, + Value0x5, + Value0x4, + Value0x3, + Value0x2, + Value0x1, + Value0x0, + _Other(i8), +} + +impl From for i8 { + fn from(val: MsgWithValueTableSigsSigWithLongValTable2) -> i8 { + match val { + MsgWithValueTableSigsSigWithLongValTable2::Value0xD => 13, + MsgWithValueTableSigsSigWithLongValTable2::Dvalue0xC => 12, + MsgWithValueTableSigsSigWithLongValTable2::Value0xB => 11, + MsgWithValueTableSigsSigWithLongValTable2::Value0xA => 10, + MsgWithValueTableSigsSigWithLongValTable2::Value0x9 => 9, + MsgWithValueTableSigsSigWithLongValTable2::Value0x8 => 8, + MsgWithValueTableSigsSigWithLongValTable2::Value0x7 => 7, + MsgWithValueTableSigsSigWithLongValTable2::Value0x6 => 6, + MsgWithValueTableSigsSigWithLongValTable2::Value0x5 => 5, + MsgWithValueTableSigsSigWithLongValTable2::Value0x4 => 4, + MsgWithValueTableSigsSigWithLongValTable2::Value0x3 => 3, + MsgWithValueTableSigsSigWithLongValTable2::Value0x2 => 2, + MsgWithValueTableSigsSigWithLongValTable2::Value0x1 => 1, + MsgWithValueTableSigsSigWithLongValTable2::Value0x0 => 0, + MsgWithValueTableSigsSigWithLongValTable2::_Other(x) => x, + } + } +} + +/// Defined values for Sig_with_long_val_table_1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum MsgWithValueTableSigsSigWithLongValTable1 { + DescriptionForTheValue0x3, + DescriptionForTheValue0x2, + DescriptionForTheValue0x1, + DescriptionForTheValue0x0, + _Other(i8), +} + +impl From for i8 { + fn from(val: MsgWithValueTableSigsSigWithLongValTable1) -> i8 { + match val { + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x3 => 3, + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x2 => 2, + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x1 => 1, + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x0 => 0, + MsgWithValueTableSigsSigWithLongValTable1::_Other(x) => x, + } + } +} + + +/// Msg_Long_Name_56789_1234567_0000 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgLongName5678912345670000 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgLongName5678912345670000 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const RX_TWICE_11111111111111111111111_MIN: i8 = 0_i8; + pub const RX_TWICE_11111111111111111111111_MAX: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0001_MIN: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0001_MAX: i8 = 0_i8; + + /// Construct new Msg_Long_Name_56789_1234567_0000 from values + pub fn new(rx_twice_11111111111111111111111: i8, sig_used_twice_efgh_abcdefg_0001: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rx_twice_11111111111111111111111(rx_twice_11111111111111111111111)?; + res.set_sig_used_twice_efgh_abcdefg_0001(sig_used_twice_efgh_abcdefg_0001)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// rx_twice_11111111111111111111111 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_11111111111111111111111(&self) -> i8 { + self.rx_twice_11111111111111111111111_raw() + } + + /// Get raw value of rx_twice_11111111111111111111111 + /// + /// - Start bit: 8 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_11111111111111111111111_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..10].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_11111111111111111111111 + #[inline(always)] + pub fn set_rx_twice_11111111111111111111111(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..10].store_le(value); + Ok(()) + } + + /// Sig_used_twice_efgh_abcdefg_0001 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0001(&self) -> i8 { + self.sig_used_twice_efgh_abcdefg_0001_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefg_0001 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0001_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefg_0001 + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefg_0001(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgLongName5678912345670000 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgLongName5678912345670000 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Msg_Long_Name_56789_1234567_0001 +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgLongName5678912345670001 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgLongName5678912345670001 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const RX_TWICE_SHORT_MIN: i8 = 0_i8; + pub const RX_TWICE_SHORT_MAX: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0002_MIN: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0002_MAX: i8 = 0_i8; + + /// Construct new Msg_Long_Name_56789_1234567_0001 from values + pub fn new(rx_twice_short: i8, sig_used_twice_efgh_abcdefg_0002: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rx_twice_short(rx_twice_short)?; + res.set_sig_used_twice_efgh_abcdefg_0002(sig_used_twice_efgh_abcdefg_0002)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// rx_twice_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_short(&self) -> i8 { + self.rx_twice_short_raw() + } + + /// Get raw value of rx_twice_short + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_short_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_short + #[inline(always)] + pub fn set_rx_twice_short(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_used_twice_efgh_abcdefg_0002 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0002(&self) -> i8 { + self.sig_used_twice_efgh_abcdefg_0002_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefg_0002 + /// + /// - Start bit: 0 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0002_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..6].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefg_0002 + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefg_0002(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..6].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgLongName5678912345670001 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgLongName5678912345670001 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.stderr b/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.stderr new file mode 100644 index 0000000..8b381e5 --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.stderr @@ -0,0 +1,186 @@ +error[E0428]: the name `MsgCaseTest` is defined multiple times + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:34:5 + | +32 | MsgCaseTest(MsgCaseTest), + | ------------------------ previous definition of the type `MsgCaseTest` here +33 | /// msg_case_test +34 | MsgCaseTest(MsgCaseTest), + | ^^^^^^^^^^^^^^^^^^^^^^^^ `MsgCaseTest` redefined here + | + = note: `MsgCaseTest` must be defined only once in the type namespace of this enum + +error[E0428]: the name `MsgCaseTest` is defined multiple times + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:697:1 + | +613 | pub struct MsgCaseTest { + | ---------------------- previous definition of the type `MsgCaseTest` here +... +697 | pub struct MsgCaseTest { + | ^^^^^^^^^^^^^^^^^^^^^^ `MsgCaseTest` redefined here + | + = note: `MsgCaseTest` must be defined only once in the type namespace of this module + +error[E0119]: conflicting implementations of trait `Clone` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:696:10 + | +612 | #[derive(Clone, Copy)] + | ----- first implementation here +... +696 | #[derive(Clone, Copy)] + | ^^^^^ conflicting implementation for `MsgCaseTest` + +error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:696:17 + | +612 | #[derive(Clone, Copy)] + | ---- first implementation here +... +696 | #[derive(Clone, Copy)] + | ^^^^ conflicting implementation for `MsgCaseTest` + +error[E0119]: conflicting implementations of trait `TryFrom<&[u8]>` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:727:1 + | +643 | impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + | -------------------------------------------------- first implementation here +... +727 | impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MsgCaseTest` + +error[E0119]: conflicting implementations of trait `Frame` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:739:1 + | +655 | impl embedded_can::Frame for MsgCaseTest { + | ---------------------------------------- first implementation here +... +739 | impl embedded_can::Frame for MsgCaseTest { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MsgCaseTest` + +error[E0592]: duplicate definitions with name `MESSAGE_ID` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `MESSAGE_ID` +... +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | -------------------------------------- other definition for `MESSAGE_ID` + +error[E0592]: duplicate definitions with name `new` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:631:5 + | +631 | pub fn new() -> Result { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `new` +... +715 | pub fn new() -> Result { + | -------------------------------------- other definition for `new` + +error[E0592]: duplicate definitions with name `raw` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:637:5 + | +637 | pub fn raw(&self) -> &[u8; 8] { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `raw` +... +721 | pub fn raw(&self) -> &[u8; 8] { + | ----------------------------- other definition for `raw` + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:61:26 + | + 61 | MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:62:26 + | + 62 | MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:657:31 + | +657 | if id.into() != Self::MESSAGE_ID { + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:680:15 + | +680 | Self::MESSAGE_ID + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:741:31 + | +741 | if id.into() != Self::MESSAGE_ID { + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:764:15 + | +764 | Self::MESSAGE_ID + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap b/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs b/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs new file mode 100644 index 0000000..ff1247a --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs @@ -0,0 +1,1528 @@ +// Generated code! +// +// Message definitions from file `long_names_multiple_relations_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Msg_Long_Name_56789_123456789_12 + MsgLongName5678912345678912(MsgLongName5678912345678912), + /// TX_twice + TxTwice(TxTwice), + /// RX_TX_1 + RxTx1(RxTx1), + /// MSG_CASE_TEST + MsgCaseTest(MsgCaseTest), + /// msg_case_test + MsgCaseTest(MsgCaseTest), + /// Msg_with_value_table_sigs + MsgWithValueTableSigs(MsgWithValueTableSigs), + /// Msg_Long_Name_56789_1234567_0000 + MsgLongName5678912345670000(MsgLongName5678912345670000), + /// Msg_Long_Name_56789_1234567_0001 + MsgLongName5678912345670001(MsgLongName5678912345670001), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + MsgLongName5678912345678912::MESSAGE_ID => Messages::MsgLongName5678912345678912(MsgLongName5678912345678912::try_from(payload)?), + TxTwice::MESSAGE_ID => Messages::TxTwice(TxTwice::try_from(payload)?), + RxTx1::MESSAGE_ID => Messages::RxTx1(RxTx1::try_from(payload)?), + MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + MsgWithValueTableSigs::MESSAGE_ID => Messages::MsgWithValueTableSigs(MsgWithValueTableSigs::try_from(payload)?), + MsgLongName5678912345670000::MESSAGE_ID => Messages::MsgLongName5678912345670000(MsgLongName5678912345670000::try_from(payload)?), + MsgLongName5678912345670001::MESSAGE_ID => Messages::MsgLongName5678912345670001(MsgLongName5678912345670001::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Msg_Long_Name_56789_123456789_12 +/// +/// - Standard ID: 85 (0x55) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgLongName5678912345678912 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgLongName5678912345678912 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x55)}); + + pub const RX_TWICE_SHORT_MIN: i32 = 0_i32; + pub const RX_TWICE_SHORT_MAX: i32 = 0_i32; + pub const RX_TWICE_11111111111111111111111_MIN: i8 = 0_i8; + pub const RX_TWICE_11111111111111111111111_MAX: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFGHI_AB_MIN: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFGHI_AB_MAX: i8 = 0_i8; + + /// Construct new Msg_Long_Name_56789_123456789_12 from values + pub fn new(rx_twice_short: i32, rx_twice_11111111111111111111111: i8, sig_used_twice_efgh_abcdefghi_ab: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rx_twice_short(rx_twice_short)?; + res.set_rx_twice_11111111111111111111111(rx_twice_11111111111111111111111)?; + res.set_sig_used_twice_efgh_abcdefghi_ab(sig_used_twice_efgh_abcdefghi_ab)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// rx_twice_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_short(&self) -> i32 { + self.rx_twice_short_raw() + } + + /// Get raw value of rx_twice_short + /// + /// - Start bit: 16 + /// - Signal size: 18 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_short_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[16..34].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_short + #[inline(always)] + pub fn set_rx_twice_short(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..34].store_le(value); + Ok(()) + } + + /// rx_twice_11111111111111111111111 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_11111111111111111111111(&self) -> i8 { + self.rx_twice_11111111111111111111111_raw() + } + + /// Get raw value of rx_twice_11111111111111111111111 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_11111111111111111111111_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_11111111111111111111111 + #[inline(always)] + pub fn set_rx_twice_11111111111111111111111(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_used_twice_efgh_abcdefghi_ab + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefghi_ab(&self) -> i8 { + self.sig_used_twice_efgh_abcdefghi_ab_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefghi_ab + /// + /// - Start bit: 0 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefghi_ab_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..6].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefghi_ab + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefghi_ab(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345678912::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..6].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgLongName5678912345678912 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgLongName5678912345678912 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TX_twice +/// +/// - Standard ID: 6 (0x6) +/// - Size: 2 bytes +/// - Transmitter: Node_6789_123456789_123456789_12 +#[derive(Clone, Copy)] +pub struct TxTwice { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TxTwice { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x6)}); + + pub const RX_TWICE_LONG_YYYYYYYYYYYYYYYYYY_MIN: i8 = 0_i8; + pub const RX_TWICE_LONG_YYYYYYYYYYYYYYYYYY_MAX: i8 = 0_i8; + pub const RX_TWICE_SHORT_MIN: i8 = 0_i8; + pub const RX_TWICE_SHORT_MAX: i8 = 0_i8; + + /// Construct new TX_twice from values + pub fn new(rx_twice_long_yyyyyyyyyyyyyyyyyy: i8, rx_twice_short: i8) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_rx_twice_long_yyyyyyyyyyyyyyyyyy(rx_twice_long_yyyyyyyyyyyyyyyyyy)?; + res.set_rx_twice_short(rx_twice_short)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// rx_twice_long_yyyyyyyyyyyyyyyyyy + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Receiver_1, Receiver_2_zzzzzzzzzzzzzzzzzzzzz + #[inline(always)] + pub fn rx_twice_long_yyyyyyyyyyyyyyyyyy(&self) -> i8 { + self.rx_twice_long_yyyyyyyyyyyyyyyyyy_raw() + } + + /// Get raw value of rx_twice_long_yyyyyyyyyyyyyyyyyy + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_long_yyyyyyyyyyyyyyyyyy_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_long_yyyyyyyyyyyyyyyyyy + #[inline(always)] + pub fn set_rx_twice_long_yyyyyyyyyyyyyyyyyy(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// rx_twice_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Receiver_2_zzzzzzzzzzzzzzzzzzzzz, Receiver_1 + #[inline(always)] + pub fn rx_twice_short(&self) -> i8 { + self.rx_twice_short_raw() + } + + /// Get raw value of rx_twice_short + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_short_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_short + #[inline(always)] + pub fn set_rx_twice_short(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TxTwice::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TxTwice { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TxTwice { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RX_TX_1 +/// +/// - Standard ID: 5 (0x5) +/// - Size: 8 bytes +/// - Transmitter: Node_6789_123456789_123456789_12 +#[derive(Clone, Copy)] +pub struct RxTx1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RxTx1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x5)}); + + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0000_MIN: i16 = 0_i16; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0000_MAX: i16 = 0_i16; + + /// Construct new RX_TX_1 from values + pub fn new(sig_used_twice_efgh_abcdefg_0000: i16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_used_twice_efgh_abcdefg_0000(sig_used_twice_efgh_abcdefg_0000)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_used_twice_efgh_abcdefg_0000 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0000(&self) -> i16 { + self.sig_used_twice_efgh_abcdefg_0000_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefg_0000 + /// + /// - Start bit: 0 + /// - Signal size: 9 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0000_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[0..9].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefg_0000 + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefg_0000(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 0_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: RxTx1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RxTx1::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..9].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RxTx1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RxTx1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MSG_CASE_TEST +/// +/// - Standard ID: 4 (0x4) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgCaseTest { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgCaseTest { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + + + /// Construct new MSG_CASE_TEST from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgCaseTest { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// msg_case_test +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgCaseTest { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgCaseTest { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + + /// Construct new msg_case_test from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 8] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgCaseTest { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Msg_with_value_table_sigs +/// +/// - Standard ID: 2 (0x2) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct MsgWithValueTableSigs { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgWithValueTableSigs { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const SIG_WITH_SHORT_VAL_TABLE_MIN: i8 = 0_i8; + pub const SIG_WITH_SHORT_VAL_TABLE_MAX: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_2_MIN: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_2_MAX: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_1_MIN: i8 = 0_i8; + pub const SIG_WITH_LONG_VAL_TABLE_1_MAX: i8 = 0_i8; + + /// Construct new Msg_with_value_table_sigs from values + pub fn new(sig_with_short_val_table: i8, sig_with_long_val_table_2: i8, sig_with_long_val_table_1: i8) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_sig_with_short_val_table(sig_with_short_val_table)?; + res.set_sig_with_long_val_table_2(sig_with_long_val_table_2)?; + res.set_sig_with_long_val_table_1(sig_with_long_val_table_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Sig_with_short_val_table + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_with_short_val_table(&self) -> MsgWithValueTableSigsSigWithShortValTable { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + match signal { + 1 => MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x1, + 0 => MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x0, + _ => MsgWithValueTableSigsSigWithShortValTable::_Other(self.sig_with_short_val_table_raw()), + } + } + + /// Get raw value of Sig_with_short_val_table + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_with_short_val_table_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_with_short_val_table + #[inline(always)] + pub fn set_sig_with_short_val_table(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Sig_with_long_val_table_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_with_long_val_table_2(&self) -> MsgWithValueTableSigsSigWithLongValTable2 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 13 => MsgWithValueTableSigsSigWithLongValTable2::Value0xD, + 12 => MsgWithValueTableSigsSigWithLongValTable2::Dvalue0xC, + 11 => MsgWithValueTableSigsSigWithLongValTable2::Value0xB, + 10 => MsgWithValueTableSigsSigWithLongValTable2::Value0xA, + 9 => MsgWithValueTableSigsSigWithLongValTable2::Value0x9, + 8 => MsgWithValueTableSigsSigWithLongValTable2::Value0x8, + 7 => MsgWithValueTableSigsSigWithLongValTable2::Value0x7, + 6 => MsgWithValueTableSigsSigWithLongValTable2::Value0x6, + 5 => MsgWithValueTableSigsSigWithLongValTable2::Value0x5, + 4 => MsgWithValueTableSigsSigWithLongValTable2::Value0x4, + 3 => MsgWithValueTableSigsSigWithLongValTable2::Value0x3, + 2 => MsgWithValueTableSigsSigWithLongValTable2::Value0x2, + 1 => MsgWithValueTableSigsSigWithLongValTable2::Value0x1, + 0 => MsgWithValueTableSigsSigWithLongValTable2::Value0x0, + _ => MsgWithValueTableSigsSigWithLongValTable2::_Other(self.sig_with_long_val_table_2_raw()), + } + } + + /// Get raw value of Sig_with_long_val_table_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_with_long_val_table_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_with_long_val_table_2 + #[inline(always)] + pub fn set_sig_with_long_val_table_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_with_long_val_table_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_with_long_val_table_1(&self) -> MsgWithValueTableSigsSigWithLongValTable1 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 3 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x3, + 2 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x2, + 1 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x1, + 0 => MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x0, + _ => MsgWithValueTableSigsSigWithLongValTable1::_Other(self.sig_with_long_val_table_1_raw()), + } + } + + /// Get raw value of Sig_with_long_val_table_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_with_long_val_table_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_with_long_val_table_1 + #[inline(always)] + pub fn set_sig_with_long_val_table_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWithValueTableSigs::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgWithValueTableSigs { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgWithValueTableSigs { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Sig_with_short_val_table +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum MsgWithValueTableSigsSigWithShortValTable { + VeryLongLongLongDescriptionForTheValue0x1, + VeryLongLongLongDescriptionForTheValue0x0, + _Other(i8), +} + +impl From for i8 { + fn from(val: MsgWithValueTableSigsSigWithShortValTable) -> i8 { + match val { + MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x1 => 1, + MsgWithValueTableSigsSigWithShortValTable::VeryLongLongLongDescriptionForTheValue0x0 => 0, + MsgWithValueTableSigsSigWithShortValTable::_Other(x) => x, + } + } +} + +/// Defined values for Sig_with_long_val_table_2 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum MsgWithValueTableSigsSigWithLongValTable2 { + Value0xD, + Dvalue0xC, + Value0xB, + Value0xA, + Value0x9, + Value0x8, + Value0x7, + Value0x6, + Value0x5, + Value0x4, + Value0x3, + Value0x2, + Value0x1, + Value0x0, + _Other(i8), +} + +impl From for i8 { + fn from(val: MsgWithValueTableSigsSigWithLongValTable2) -> i8 { + match val { + MsgWithValueTableSigsSigWithLongValTable2::Value0xD => 13, + MsgWithValueTableSigsSigWithLongValTable2::Dvalue0xC => 12, + MsgWithValueTableSigsSigWithLongValTable2::Value0xB => 11, + MsgWithValueTableSigsSigWithLongValTable2::Value0xA => 10, + MsgWithValueTableSigsSigWithLongValTable2::Value0x9 => 9, + MsgWithValueTableSigsSigWithLongValTable2::Value0x8 => 8, + MsgWithValueTableSigsSigWithLongValTable2::Value0x7 => 7, + MsgWithValueTableSigsSigWithLongValTable2::Value0x6 => 6, + MsgWithValueTableSigsSigWithLongValTable2::Value0x5 => 5, + MsgWithValueTableSigsSigWithLongValTable2::Value0x4 => 4, + MsgWithValueTableSigsSigWithLongValTable2::Value0x3 => 3, + MsgWithValueTableSigsSigWithLongValTable2::Value0x2 => 2, + MsgWithValueTableSigsSigWithLongValTable2::Value0x1 => 1, + MsgWithValueTableSigsSigWithLongValTable2::Value0x0 => 0, + MsgWithValueTableSigsSigWithLongValTable2::_Other(x) => x, + } + } +} + +/// Defined values for Sig_with_long_val_table_1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum MsgWithValueTableSigsSigWithLongValTable1 { + DescriptionForTheValue0x3, + DescriptionForTheValue0x2, + DescriptionForTheValue0x1, + DescriptionForTheValue0x0, + _Other(i8), +} + +impl From for i8 { + fn from(val: MsgWithValueTableSigsSigWithLongValTable1) -> i8 { + match val { + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x3 => 3, + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x2 => 2, + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x1 => 1, + MsgWithValueTableSigsSigWithLongValTable1::DescriptionForTheValue0x0 => 0, + MsgWithValueTableSigsSigWithLongValTable1::_Other(x) => x, + } + } +} + + +/// Msg_Long_Name_56789_1234567_0000 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgLongName5678912345670000 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgLongName5678912345670000 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const RX_TWICE_11111111111111111111111_MIN: i8 = 0_i8; + pub const RX_TWICE_11111111111111111111111_MAX: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0001_MIN: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0001_MAX: i8 = 0_i8; + + /// Construct new Msg_Long_Name_56789_1234567_0000 from values + pub fn new(rx_twice_11111111111111111111111: i8, sig_used_twice_efgh_abcdefg_0001: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rx_twice_11111111111111111111111(rx_twice_11111111111111111111111)?; + res.set_sig_used_twice_efgh_abcdefg_0001(sig_used_twice_efgh_abcdefg_0001)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// rx_twice_11111111111111111111111 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_11111111111111111111111(&self) -> i8 { + self.rx_twice_11111111111111111111111_raw() + } + + /// Get raw value of rx_twice_11111111111111111111111 + /// + /// - Start bit: 8 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_11111111111111111111111_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..10].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_11111111111111111111111 + #[inline(always)] + pub fn set_rx_twice_11111111111111111111111(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..10].store_le(value); + Ok(()) + } + + /// Sig_used_twice_efgh_abcdefg_0001 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0001(&self) -> i8 { + self.sig_used_twice_efgh_abcdefg_0001_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefg_0001 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0001_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefg_0001 + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefg_0001(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670000::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgLongName5678912345670000 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgLongName5678912345670000 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Msg_Long_Name_56789_1234567_0001 +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MsgLongName5678912345670001 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgLongName5678912345670001 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const RX_TWICE_SHORT_MIN: i8 = 0_i8; + pub const RX_TWICE_SHORT_MAX: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0002_MIN: i8 = 0_i8; + pub const SIG_USED_TWICE_EFGH_ABCDEFG_0002_MAX: i8 = 0_i8; + + /// Construct new Msg_Long_Name_56789_1234567_0001 from values + pub fn new(rx_twice_short: i8, sig_used_twice_efgh_abcdefg_0002: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rx_twice_short(rx_twice_short)?; + res.set_sig_used_twice_efgh_abcdefg_0002(sig_used_twice_efgh_abcdefg_0002)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// rx_twice_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rx_twice_short(&self) -> i8 { + self.rx_twice_short_raw() + } + + /// Get raw value of rx_twice_short + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rx_twice_short_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of rx_twice_short + #[inline(always)] + pub fn set_rx_twice_short(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_used_twice_efgh_abcdefg_0002 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0002(&self) -> i8 { + self.sig_used_twice_efgh_abcdefg_0002_raw() + } + + /// Get raw value of Sig_used_twice_efgh_abcdefg_0002 + /// + /// - Start bit: 0 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_used_twice_efgh_abcdefg_0002_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..6].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_used_twice_efgh_abcdefg_0002 + #[inline(always)] + pub fn set_sig_used_twice_efgh_abcdefg_0002(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgLongName5678912345670001::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..6].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgLongName5678912345670001 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgLongName5678912345670001 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.stderr b/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.stderr new file mode 100644 index 0000000..b55e796 --- /dev/null +++ b/tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.stderr @@ -0,0 +1,186 @@ +error[E0428]: the name `MsgCaseTest` is defined multiple times + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:34:5 + | +32 | MsgCaseTest(MsgCaseTest), + | ------------------------ previous definition of the type `MsgCaseTest` here +33 | /// msg_case_test +34 | MsgCaseTest(MsgCaseTest), + | ^^^^^^^^^^^^^^^^^^^^^^^^ `MsgCaseTest` redefined here + | + = note: `MsgCaseTest` must be defined only once in the type namespace of this enum + +error[E0428]: the name `MsgCaseTest` is defined multiple times + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:697:1 + | +613 | pub struct MsgCaseTest { + | ---------------------- previous definition of the type `MsgCaseTest` here +... +697 | pub struct MsgCaseTest { + | ^^^^^^^^^^^^^^^^^^^^^^ `MsgCaseTest` redefined here + | + = note: `MsgCaseTest` must be defined only once in the type namespace of this module + +error[E0119]: conflicting implementations of trait `Clone` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:696:10 + | +612 | #[derive(Clone, Copy)] + | ----- first implementation here +... +696 | #[derive(Clone, Copy)] + | ^^^^^ conflicting implementation for `MsgCaseTest` + +error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:696:17 + | +612 | #[derive(Clone, Copy)] + | ---- first implementation here +... +696 | #[derive(Clone, Copy)] + | ^^^^ conflicting implementation for `MsgCaseTest` + +error[E0119]: conflicting implementations of trait `TryFrom<&[u8]>` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:727:1 + | +643 | impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + | -------------------------------------------------- first implementation here +... +727 | impl core::convert::TryFrom<&[u8]> for MsgCaseTest { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MsgCaseTest` + +error[E0119]: conflicting implementations of trait `Frame` for type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:739:1 + | +655 | impl embedded_can::Frame for MsgCaseTest { + | ---------------------------------------- first implementation here +... +739 | impl embedded_can::Frame for MsgCaseTest { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MsgCaseTest` + +error[E0592]: duplicate definitions with name `MESSAGE_ID` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `MESSAGE_ID` +... +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | -------------------------------------- other definition for `MESSAGE_ID` + +error[E0592]: duplicate definitions with name `new` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:631:5 + | +631 | pub fn new() -> Result { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `new` +... +715 | pub fn new() -> Result { + | -------------------------------------- other definition for `new` + +error[E0592]: duplicate definitions with name `raw` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:637:5 + | +637 | pub fn raw(&self) -> &[u8; 8] { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `raw` +... +721 | pub fn raw(&self) -> &[u8; 8] { + | ----------------------------- other definition for `raw` + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:61:26 + | + 61 | MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:62:26 + | + 62 | MsgCaseTest::MESSAGE_ID => Messages::MsgCaseTest(MsgCaseTest::try_from(payload)?), + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:657:31 + | +657 | if id.into() != Self::MESSAGE_ID { + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:680:15 + | +680 | Self::MESSAGE_ID + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:741:31 + | +741 | if id.into() != Self::MESSAGE_ID { + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0034]: multiple applicable items in scope + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:764:15 + | +764 | Self::MESSAGE_ID + | ^^^^^^^^^^ multiple `MESSAGE_ID` found + | +note: candidate #1 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:627:5 + | +627 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl for the type `MsgCaseTest` + --> tests-snapshots/dbc-cantools/long_names_multiple_relations_dumped.snap.rs:711:5 + | +711 | pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests-snapshots/dbc-cantools/message-dlc-zero.snap b/tests-snapshots/dbc-cantools/message-dlc-zero.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/message-dlc-zero.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/message-dlc-zero.snap.rs b/tests-snapshots/dbc-cantools/message-dlc-zero.snap.rs new file mode 100644 index 0000000..3406207 --- /dev/null +++ b/tests-snapshots/dbc-cantools/message-dlc-zero.snap.rs @@ -0,0 +1,166 @@ +// Generated code! +// +// Message definitions from file `message-dlc-zero` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Standard ID: 1024 (0x400) +/// - Size: 0 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 0], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x400)}); + + + /// Construct new Message1 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 0] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 0] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 0 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 0]; + raw.copy_from_slice(&payload[..0]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/mod_name_len_dest.snap b/tests-snapshots/dbc-cantools/mod_name_len_dest.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/mod_name_len_dest.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/mod_name_len_dest.snap.rs b/tests-snapshots/dbc-cantools/mod_name_len_dest.snap.rs new file mode 100644 index 0000000..d3afbfa --- /dev/null +++ b/tests-snapshots/dbc-cantools/mod_name_len_dest.snap.rs @@ -0,0 +1,211 @@ +// Generated code! +// +// Message definitions from file `mod_name_len_dest` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// msg_now_short + MsgNowShort(MsgNowShort), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + MsgNowShort::MESSAGE_ID => Messages::MsgNowShort(MsgNowShort::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// msg_now_short +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +/// - Transmitter: node_now_short +#[derive(Clone, Copy)] +pub struct MsgNowShort { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgNowShort { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const SIG_NOW_SHORT_MIN: u8 = 0_u8; + pub const SIG_NOW_SHORT_MAX: u8 = 0_u8; + + /// Construct new msg_now_short from values + pub fn new(sig_now_short: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_now_short(sig_now_short)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// sig_now_short + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_now_short(&self) -> u8 { + self.sig_now_short_raw() + } + + /// Get raw value of sig_now_short + /// + /// - Start bit: 1 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sig_now_short_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[1..9].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of sig_now_short + #[inline(always)] + pub fn set_sig_now_short(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgNowShort::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgNowShort::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[1..9].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgNowShort { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgNowShort { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/mod_name_len_src.snap b/tests-snapshots/dbc-cantools/mod_name_len_src.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/mod_name_len_src.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/mod_name_len_src.snap.rs b/tests-snapshots/dbc-cantools/mod_name_len_src.snap.rs new file mode 100644 index 0000000..a99f4d2 --- /dev/null +++ b/tests-snapshots/dbc-cantools/mod_name_len_src.snap.rs @@ -0,0 +1,211 @@ +// Generated code! +// +// Message definitions from file `mod_name_len_src` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Msg_will_be_shortened_3456789_12 + MsgWillBeShortened345678912(MsgWillBeShortened345678912), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + MsgWillBeShortened345678912::MESSAGE_ID => Messages::MsgWillBeShortened345678912(MsgWillBeShortened345678912::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Msg_will_be_shortened_3456789_12 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +/// - Transmitter: Node_will_be_shortened_456789_12 +#[derive(Clone, Copy)] +pub struct MsgWillBeShortened345678912 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MsgWillBeShortened345678912 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const SIG_WILL_BE_SHORTENED_3456789_12_MIN: u8 = 0_u8; + pub const SIG_WILL_BE_SHORTENED_3456789_12_MAX: u8 = 0_u8; + + /// Construct new Msg_will_be_shortened_3456789_12 from values + pub fn new(sig_will_be_shortened_3456789_12: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_will_be_shortened_3456789_12(sig_will_be_shortened_3456789_12)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_will_be_shortened_3456789_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_will_be_shortened_3456789_12(&self) -> u8 { + self.sig_will_be_shortened_3456789_12_raw() + } + + /// Get raw value of Sig_will_be_shortened_3456789_12 + /// + /// - Start bit: 1 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sig_will_be_shortened_3456789_12_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[1..9].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_will_be_shortened_3456789_12 + #[inline(always)] + pub fn set_sig_will_be_shortened_3456789_12(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MsgWillBeShortened345678912::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MsgWillBeShortened345678912::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[1..9].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MsgWillBeShortened345678912 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MsgWillBeShortened345678912 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/motohawk.snap b/tests-snapshots/dbc-cantools/motohawk.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/motohawk.snap.rs b/tests-snapshots/dbc-cantools/motohawk.snap.rs new file mode 100644 index 0000000..0a6c3a1 --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk.snap.rs @@ -0,0 +1,327 @@ +// Generated code! +// +// Message definitions from file `motohawk` +// Version: 1.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ExampleMessage + ExampleMessage(ExampleMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExampleMessage::MESSAGE_ID => Messages::ExampleMessage(ExampleMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ExampleMessage +/// +/// - Standard ID: 496 (0x1f0) +/// - Size: 8 bytes +/// - Transmitter: PCM1 +/// +/// Example message used as template in MotoHawk models. +#[derive(Clone, Copy)] +pub struct ExampleMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExampleMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f0)}); + + pub const TEMPERATURE_MIN: f32 = 229.52_f32; + pub const TEMPERATURE_MAX: f32 = 270.47_f32; + pub const AVERAGE_RADIUS_MIN: f32 = 0_f32; + pub const AVERAGE_RADIUS_MAX: f32 = 5_f32; + + /// Construct new ExampleMessage from values + pub fn new(temperature: f32, average_radius: f32, enable: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_temperature(temperature)?; + res.set_average_radius(average_radius)?; + res.set_enable(enable)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Temperature + /// + /// - Min: 229.52 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: PCM1, FOO + #[inline(always)] + pub fn temperature(&self) -> f32 { + self.temperature_raw() + } + + /// Get raw value of Temperature + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature + #[inline(always)] + pub fn set_temperature(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.52_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + + /// AverageRadius + /// + /// - Min: 0 + /// - Max: 5 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn average_radius(&self) -> f32 { + self.average_radius_raw() + } + + /// Get raw value of AverageRadius + /// + /// - Start bit: 6 + /// - Signal size: 6 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn average_radius_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[1..7].load_be::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AverageRadius + #[inline(always)] + pub fn set_average_radius(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[1..7].store_be(value); + Ok(()) + } + + /// Enable + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "-" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn enable(&self) -> ExampleMessageEnable { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + match signal { + 0 => ExampleMessageEnable::Disabled, + 1 => ExampleMessageEnable::Enabled, + _ => ExampleMessageEnable::_Other(self.enable_raw()), + } + } + + /// Get raw value of Enable + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn enable_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of Enable + #[inline(always)] + pub fn set_enable(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExampleMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExampleMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Enable +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageEnable { + Disabled, + Enabled, + _Other(bool), +} + +impl From for bool { + fn from(val: ExampleMessageEnable) -> bool { + match val { + ExampleMessageEnable::Disabled => false, + ExampleMessageEnable::Enabled => true, + ExampleMessageEnable::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/motohawk_fd.snap b/tests-snapshots/dbc-cantools/motohawk_fd.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk_fd.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/motohawk_fd.snap.rs b/tests-snapshots/dbc-cantools/motohawk_fd.snap.rs new file mode 100644 index 0000000..d04dc71 --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk_fd.snap.rs @@ -0,0 +1,327 @@ +// Generated code! +// +// Message definitions from file `motohawk_fd` +// Version: 1.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ExampleMessage + ExampleMessage(ExampleMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExampleMessage::MESSAGE_ID => Messages::ExampleMessage(ExampleMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ExampleMessage +/// +/// - Extended ID: 496 (0x1f0) +/// - Size: 8 bytes +/// - Transmitter: PCM1 +/// +/// Example message used as template in MotoHawk models. +#[derive(Clone, Copy)] +pub struct ExampleMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExampleMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1f0)}); + + pub const TEMPERATURE_MIN: f32 = 229.52_f32; + pub const TEMPERATURE_MAX: f32 = 270.47_f32; + pub const AVERAGE_RADIUS_MIN: f32 = 0_f32; + pub const AVERAGE_RADIUS_MAX: f32 = 5_f32; + + /// Construct new ExampleMessage from values + pub fn new(temperature: f32, average_radius: f32, enable: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_temperature(temperature)?; + res.set_average_radius(average_radius)?; + res.set_enable(enable)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Temperature + /// + /// - Min: 229.52 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: PCM1, FOO + #[inline(always)] + pub fn temperature(&self) -> f32 { + self.temperature_raw() + } + + /// Get raw value of Temperature + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature + #[inline(always)] + pub fn set_temperature(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.52_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + + /// AverageRadius + /// + /// - Min: 0 + /// - Max: 5 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn average_radius(&self) -> f32 { + self.average_radius_raw() + } + + /// Get raw value of AverageRadius + /// + /// - Start bit: 6 + /// - Signal size: 6 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn average_radius_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[1..7].load_be::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AverageRadius + #[inline(always)] + pub fn set_average_radius(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[1..7].store_be(value); + Ok(()) + } + + /// Enable + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "-" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn enable(&self) -> ExampleMessageEnable { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + match signal { + 0 => ExampleMessageEnable::Disabled, + 1 => ExampleMessageEnable::Enabled, + _ => ExampleMessageEnable::_Other(self.enable_raw()), + } + } + + /// Get raw value of Enable + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn enable_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of Enable + #[inline(always)] + pub fn set_enable(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExampleMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExampleMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Enable +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageEnable { + Disabled, + Enabled, + _Other(bool), +} + +impl From for bool { + fn from(val: ExampleMessageEnable) -> bool { + match val { + ExampleMessageEnable::Disabled => false, + ExampleMessageEnable::Enabled => true, + ExampleMessageEnable::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/motohawk_use_round.snap b/tests-snapshots/dbc-cantools/motohawk_use_round.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk_use_round.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/motohawk_use_round.snap.rs b/tests-snapshots/dbc-cantools/motohawk_use_round.snap.rs new file mode 100644 index 0000000..601f5ce --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk_use_round.snap.rs @@ -0,0 +1,327 @@ +// Generated code! +// +// Message definitions from file `motohawk_use_round` +// Version: 1.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ExampleMessage + ExampleMessage(ExampleMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExampleMessage::MESSAGE_ID => Messages::ExampleMessage(ExampleMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ExampleMessage +/// +/// - Standard ID: 496 (0x1f0) +/// - Size: 8 bytes +/// - Transmitter: PCM1 +/// +/// Example message used as template in MotoHawk models. +#[derive(Clone, Copy)] +pub struct ExampleMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExampleMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f0)}); + + pub const TEMPERATURE_MIN: f32 = 229.52_f32; + pub const TEMPERATURE_MAX: f32 = 270.47_f32; + pub const AVERAGE_RADIUS_MIN: f32 = 0_f32; + pub const AVERAGE_RADIUS_MAX: f32 = 5_f32; + + /// Construct new ExampleMessage from values + pub fn new(temperature: f32, average_radius: f32, enable: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_temperature(temperature)?; + res.set_average_radius(average_radius)?; + res.set_enable(enable)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Temperature + /// + /// - Min: 229.52 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: PCM1, FOO + #[inline(always)] + pub fn temperature(&self) -> f32 { + self.temperature_raw() + } + + /// Get raw value of Temperature + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature + #[inline(always)] + pub fn set_temperature(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.52_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + + /// AverageRadius + /// + /// - Min: 0 + /// - Max: 5 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn average_radius(&self) -> f32 { + self.average_radius_raw() + } + + /// Get raw value of AverageRadius + /// + /// - Start bit: 6 + /// - Signal size: 6 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn average_radius_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[1..7].load_be::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AverageRadius + #[inline(always)] + pub fn set_average_radius(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[1..7].store_be(value); + Ok(()) + } + + /// Enable + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "-" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn enable(&self) -> ExampleMessageEnable { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + match signal { + 0 => ExampleMessageEnable::Disabled, + 1 => ExampleMessageEnable::Enabled, + _ => ExampleMessageEnable::_Other(self.enable_raw()), + } + } + + /// Get raw value of Enable + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn enable_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of Enable + #[inline(always)] + pub fn set_enable(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExampleMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExampleMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Enable +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageEnable { + Disabled, + Enabled, + _Other(bool), +} + +impl From for bool { + fn from(val: ExampleMessageEnable) -> bool { + match val { + ExampleMessageEnable::Disabled => false, + ExampleMessageEnable::Enabled => true, + ExampleMessageEnable::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/motohawk_with_comments.snap b/tests-snapshots/dbc-cantools/motohawk_with_comments.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk_with_comments.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/motohawk_with_comments.snap.rs b/tests-snapshots/dbc-cantools/motohawk_with_comments.snap.rs new file mode 100644 index 0000000..bbf873d --- /dev/null +++ b/tests-snapshots/dbc-cantools/motohawk_with_comments.snap.rs @@ -0,0 +1,333 @@ +// Generated code! +// +// Message definitions from file `motohawk_with_comments` +// Version: 1.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ExampleMessage + ExampleMessage(ExampleMessage), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ExampleMessage::MESSAGE_ID => Messages::ExampleMessage(ExampleMessage::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ExampleMessage +/// +/// - Standard ID: 496 (0x1f0) +/// - Size: 8 bytes +/// - Transmitter: PCM1 +/// +/// Example message used as template in MotoHawk models. +#[derive(Clone, Copy)] +pub struct ExampleMessage { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExampleMessage { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f0)}); + + pub const TEMPERATURE_MIN: f32 = 229.52_f32; + pub const TEMPERATURE_MAX: f32 = 270.47_f32; + pub const AVERAGE_RADIUS_MIN: f32 = 0_f32; + pub const AVERAGE_RADIUS_MAX: f32 = 5_f32; + + /// Construct new ExampleMessage from values + pub fn new(temperature: f32, average_radius: f32, enable: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_temperature(temperature)?; + res.set_average_radius(average_radius)?; + res.set_enable(enable)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Temperature + /// + /// Temperature with a really long and complicated comment that probably require many many lines in a decently wide terminal + /// + /// - Min: 229.52 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: PCM1, FOO + #[inline(always)] + pub fn temperature(&self) -> f32 { + self.temperature_raw() + } + + /// Get raw value of Temperature + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature + #[inline(always)] + pub fn set_temperature(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.52_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + + /// AverageRadius + /// + /// AverageRadius signal comment + /// + /// - Min: 0 + /// - Max: 5 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn average_radius(&self) -> f32 { + self.average_radius_raw() + } + + /// Get raw value of AverageRadius + /// + /// - Start bit: 6 + /// - Signal size: 6 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn average_radius_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[1..7].load_be::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AverageRadius + #[inline(always)] + pub fn set_average_radius(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 5_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExampleMessage::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[1..7].store_be(value); + Ok(()) + } + + /// Enable + /// + /// Enable signal comment + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "-" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn enable(&self) -> ExampleMessageEnable { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + match signal { + 0 => ExampleMessageEnable::Disabled, + 1 => ExampleMessageEnable::Enabled, + _ => ExampleMessageEnable::_Other(self.enable_raw()), + } + } + + /// Get raw value of Enable + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn enable_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of Enable + #[inline(always)] + pub fn set_enable(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExampleMessage { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExampleMessage { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Enable +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ExampleMessageEnable { + Disabled, + Enabled, + _Other(bool), +} + +impl From for bool { + fn from(val: ExampleMessageEnable) -> bool { + match val { + ExampleMessageEnable::Disabled => false, + ExampleMessageEnable::Enabled => true, + ExampleMessageEnable::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/msxii_system_can.snap b/tests-snapshots/dbc-cantools/msxii_system_can.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/msxii_system_can.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/msxii_system_can.snap.rs b/tests-snapshots/dbc-cantools/msxii_system_can.snap.rs new file mode 100644 index 0000000..fd93ad9 --- /dev/null +++ b/tests-snapshots/dbc-cantools/msxii_system_can.snap.rs @@ -0,0 +1,4718 @@ +// Generated code! +// +// Message definitions from file `msxii_system_can` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// BATTERY_VT + BatteryVt(BatteryVt), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + BatteryVt::MESSAGE_ID => Messages::BatteryVt(BatteryVt::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// BATTERY_VT +/// +/// - Standard ID: 1025 (0x401) +/// - Size: 6 bytes +/// - Transmitter: BMS +#[derive(Clone, Copy)] +pub struct BatteryVt { + raw: [u8; 6], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVt { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x401)}); + + pub const MODULE_TEMP_35_MIN: u16 = 0_u16; + pub const MODULE_TEMP_35_MAX: u16 = 0_u16; + pub const MODULE_TEMP_34_MIN: u16 = 0_u16; + pub const MODULE_TEMP_34_MAX: u16 = 0_u16; + pub const MODULE_TEMP_33_MIN: u16 = 0_u16; + pub const MODULE_TEMP_33_MAX: u16 = 0_u16; + pub const MODULE_TEMP_32_MIN: u16 = 0_u16; + pub const MODULE_TEMP_32_MAX: u16 = 0_u16; + pub const MODULE_TEMP_31_MIN: u16 = 0_u16; + pub const MODULE_TEMP_31_MAX: u16 = 0_u16; + pub const MODULE_TEMP_30_MIN: u16 = 0_u16; + pub const MODULE_TEMP_30_MAX: u16 = 0_u16; + pub const MODULE_TEMP_29_MIN: u16 = 0_u16; + pub const MODULE_TEMP_29_MAX: u16 = 0_u16; + pub const MODULE_TEMP_28_MIN: u16 = 0_u16; + pub const MODULE_TEMP_28_MAX: u16 = 0_u16; + pub const MODULE_TEMP_27_MIN: u16 = 0_u16; + pub const MODULE_TEMP_27_MAX: u16 = 0_u16; + pub const MODULE_TEMP_26_MIN: u16 = 0_u16; + pub const MODULE_TEMP_26_MAX: u16 = 0_u16; + pub const MODULE_TEMP_25_MIN: u16 = 0_u16; + pub const MODULE_TEMP_25_MAX: u16 = 0_u16; + pub const MODULE_TEMP_24_MIN: u16 = 0_u16; + pub const MODULE_TEMP_24_MAX: u16 = 0_u16; + pub const MODULE_TEMP_23_MIN: u16 = 0_u16; + pub const MODULE_TEMP_23_MAX: u16 = 0_u16; + pub const MODULE_TEMP_22_MIN: u16 = 0_u16; + pub const MODULE_TEMP_22_MAX: u16 = 0_u16; + pub const MODULE_TEMP_21_MIN: u16 = 0_u16; + pub const MODULE_TEMP_21_MAX: u16 = 0_u16; + pub const MODULE_TEMP_20_MIN: u16 = 0_u16; + pub const MODULE_TEMP_20_MAX: u16 = 0_u16; + pub const MODULE_TEMP_19_MIN: u16 = 0_u16; + pub const MODULE_TEMP_19_MAX: u16 = 0_u16; + pub const MODULE_TEMP_18_MIN: u16 = 0_u16; + pub const MODULE_TEMP_18_MAX: u16 = 0_u16; + pub const MODULE_TEMP_17_MIN: u16 = 0_u16; + pub const MODULE_TEMP_17_MAX: u16 = 0_u16; + pub const MODULE_TEMP_16_MIN: u16 = 0_u16; + pub const MODULE_TEMP_16_MAX: u16 = 0_u16; + pub const MODULE_TEMP_15_MIN: u16 = 0_u16; + pub const MODULE_TEMP_15_MAX: u16 = 0_u16; + pub const MODULE_TEMP_14_MIN: u16 = 0_u16; + pub const MODULE_TEMP_14_MAX: u16 = 0_u16; + pub const MODULE_TEMP_13_MIN: u16 = 0_u16; + pub const MODULE_TEMP_13_MAX: u16 = 0_u16; + pub const MODULE_TEMP_12_MIN: u16 = 0_u16; + pub const MODULE_TEMP_12_MAX: u16 = 0_u16; + pub const MODULE_TEMP_11_MIN: u16 = 0_u16; + pub const MODULE_TEMP_11_MAX: u16 = 0_u16; + pub const MODULE_TEMP_10_MIN: u16 = 0_u16; + pub const MODULE_TEMP_10_MAX: u16 = 0_u16; + pub const MODULE_TEMP_09_MIN: u16 = 0_u16; + pub const MODULE_TEMP_09_MAX: u16 = 0_u16; + pub const MODULE_TEMP_08_MIN: u16 = 0_u16; + pub const MODULE_TEMP_08_MAX: u16 = 0_u16; + pub const MODULE_TEMP_07_MIN: u16 = 0_u16; + pub const MODULE_TEMP_07_MAX: u16 = 0_u16; + pub const MODULE_TEMP_06_MIN: u16 = 0_u16; + pub const MODULE_TEMP_06_MAX: u16 = 0_u16; + pub const MODULE_TEMP_05_MIN: u16 = 0_u16; + pub const MODULE_TEMP_05_MAX: u16 = 0_u16; + pub const MODULE_TEMP_04_MIN: u16 = 0_u16; + pub const MODULE_TEMP_04_MAX: u16 = 0_u16; + pub const MODULE_TEMP_03_MIN: u16 = 0_u16; + pub const MODULE_TEMP_03_MAX: u16 = 0_u16; + pub const MODULE_TEMP_02_MIN: u16 = 0_u16; + pub const MODULE_TEMP_02_MAX: u16 = 0_u16; + pub const MODULE_TEMP_01_MIN: u16 = 0_u16; + pub const MODULE_TEMP_01_MAX: u16 = 0_u16; + pub const MODULE_TEMP_00_MIN: u16 = 0_u16; + pub const MODULE_TEMP_00_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_35_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_35_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_34_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_34_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_33_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_33_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_32_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_32_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_31_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_31_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_30_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_30_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_29_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_29_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_28_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_28_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_27_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_27_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_26_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_26_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_25_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_25_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_24_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_24_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_23_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_23_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_22_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_22_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_21_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_21_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_20_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_20_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_19_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_19_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_18_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_18_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_17_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_17_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_16_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_16_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_15_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_15_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_14_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_14_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_13_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_13_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_12_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_12_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_11_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_11_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_10_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_10_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_09_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_09_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_08_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_08_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_07_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_07_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_06_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_06_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_05_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_05_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_04_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_04_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_03_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_03_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_02_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_02_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_01_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_01_MAX: u16 = 0_u16; + pub const MODULE_VOLTAGE_00_MIN: u16 = 0_u16; + pub const MODULE_VOLTAGE_00_MAX: u16 = 0_u16; + pub const BATTERY_VT_INDEX_MIN: u16 = 0_u16; + pub const BATTERY_VT_INDEX_MAX: u16 = 0_u16; + + /// Construct new BATTERY_VT from values + pub fn new(battery_vt_index: u16) -> Result { + let mut res = Self { raw: [0u8; 6] }; + res.set_battery_vt_index(battery_vt_index)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 6] { + &self.raw + } + + /// Get raw value of BATTERY_VT_INDEX + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn battery_vt_index_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn battery_vt_index(&mut self) -> Result { + match self.battery_vt_index_raw() { + 0 => Ok(BatteryVtBatteryVtIndexIndex::M0(BatteryVtBatteryVtIndexM0{ raw: self.raw })), + 1 => Ok(BatteryVtBatteryVtIndexIndex::M1(BatteryVtBatteryVtIndexM1{ raw: self.raw })), + 2 => Ok(BatteryVtBatteryVtIndexIndex::M2(BatteryVtBatteryVtIndexM2{ raw: self.raw })), + 3 => Ok(BatteryVtBatteryVtIndexIndex::M3(BatteryVtBatteryVtIndexM3{ raw: self.raw })), + 4 => Ok(BatteryVtBatteryVtIndexIndex::M4(BatteryVtBatteryVtIndexM4{ raw: self.raw })), + 5 => Ok(BatteryVtBatteryVtIndexIndex::M5(BatteryVtBatteryVtIndexM5{ raw: self.raw })), + 6 => Ok(BatteryVtBatteryVtIndexIndex::M6(BatteryVtBatteryVtIndexM6{ raw: self.raw })), + 7 => Ok(BatteryVtBatteryVtIndexIndex::M7(BatteryVtBatteryVtIndexM7{ raw: self.raw })), + 8 => Ok(BatteryVtBatteryVtIndexIndex::M8(BatteryVtBatteryVtIndexM8{ raw: self.raw })), + 9 => Ok(BatteryVtBatteryVtIndexIndex::M9(BatteryVtBatteryVtIndexM9{ raw: self.raw })), + 10 => Ok(BatteryVtBatteryVtIndexIndex::M10(BatteryVtBatteryVtIndexM10{ raw: self.raw })), + 11 => Ok(BatteryVtBatteryVtIndexIndex::M11(BatteryVtBatteryVtIndexM11{ raw: self.raw })), + 12 => Ok(BatteryVtBatteryVtIndexIndex::M12(BatteryVtBatteryVtIndexM12{ raw: self.raw })), + 13 => Ok(BatteryVtBatteryVtIndexIndex::M13(BatteryVtBatteryVtIndexM13{ raw: self.raw })), + 14 => Ok(BatteryVtBatteryVtIndexIndex::M14(BatteryVtBatteryVtIndexM14{ raw: self.raw })), + 15 => Ok(BatteryVtBatteryVtIndexIndex::M15(BatteryVtBatteryVtIndexM15{ raw: self.raw })), + 16 => Ok(BatteryVtBatteryVtIndexIndex::M16(BatteryVtBatteryVtIndexM16{ raw: self.raw })), + 17 => Ok(BatteryVtBatteryVtIndexIndex::M17(BatteryVtBatteryVtIndexM17{ raw: self.raw })), + 18 => Ok(BatteryVtBatteryVtIndexIndex::M18(BatteryVtBatteryVtIndexM18{ raw: self.raw })), + 19 => Ok(BatteryVtBatteryVtIndexIndex::M19(BatteryVtBatteryVtIndexM19{ raw: self.raw })), + 20 => Ok(BatteryVtBatteryVtIndexIndex::M20(BatteryVtBatteryVtIndexM20{ raw: self.raw })), + 21 => Ok(BatteryVtBatteryVtIndexIndex::M21(BatteryVtBatteryVtIndexM21{ raw: self.raw })), + 22 => Ok(BatteryVtBatteryVtIndexIndex::M22(BatteryVtBatteryVtIndexM22{ raw: self.raw })), + 23 => Ok(BatteryVtBatteryVtIndexIndex::M23(BatteryVtBatteryVtIndexM23{ raw: self.raw })), + 24 => Ok(BatteryVtBatteryVtIndexIndex::M24(BatteryVtBatteryVtIndexM24{ raw: self.raw })), + 25 => Ok(BatteryVtBatteryVtIndexIndex::M25(BatteryVtBatteryVtIndexM25{ raw: self.raw })), + 26 => Ok(BatteryVtBatteryVtIndexIndex::M26(BatteryVtBatteryVtIndexM26{ raw: self.raw })), + 27 => Ok(BatteryVtBatteryVtIndexIndex::M27(BatteryVtBatteryVtIndexM27{ raw: self.raw })), + 28 => Ok(BatteryVtBatteryVtIndexIndex::M28(BatteryVtBatteryVtIndexM28{ raw: self.raw })), + 29 => Ok(BatteryVtBatteryVtIndexIndex::M29(BatteryVtBatteryVtIndexM29{ raw: self.raw })), + 30 => Ok(BatteryVtBatteryVtIndexIndex::M30(BatteryVtBatteryVtIndexM30{ raw: self.raw })), + 31 => Ok(BatteryVtBatteryVtIndexIndex::M31(BatteryVtBatteryVtIndexM31{ raw: self.raw })), + 32 => Ok(BatteryVtBatteryVtIndexIndex::M32(BatteryVtBatteryVtIndexM32{ raw: self.raw })), + 33 => Ok(BatteryVtBatteryVtIndexIndex::M33(BatteryVtBatteryVtIndexM33{ raw: self.raw })), + 34 => Ok(BatteryVtBatteryVtIndexIndex::M34(BatteryVtBatteryVtIndexM34{ raw: self.raw })), + 35 => Ok(BatteryVtBatteryVtIndexIndex::M35(BatteryVtBatteryVtIndexM35{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: BatteryVt::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + fn set_battery_vt_index(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m0(&mut self, value: BatteryVtBatteryVtIndexM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(0)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m1(&mut self, value: BatteryVtBatteryVtIndexM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(1)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m2(&mut self, value: BatteryVtBatteryVtIndexM2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(2)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m3(&mut self, value: BatteryVtBatteryVtIndexM3) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(3)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m4(&mut self, value: BatteryVtBatteryVtIndexM4) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(4)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m5(&mut self, value: BatteryVtBatteryVtIndexM5) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(5)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m6(&mut self, value: BatteryVtBatteryVtIndexM6) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(6)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m7(&mut self, value: BatteryVtBatteryVtIndexM7) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(7)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m8(&mut self, value: BatteryVtBatteryVtIndexM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(8)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m9(&mut self, value: BatteryVtBatteryVtIndexM9) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(9)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m10(&mut self, value: BatteryVtBatteryVtIndexM10) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(10)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m11(&mut self, value: BatteryVtBatteryVtIndexM11) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(11)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m12(&mut self, value: BatteryVtBatteryVtIndexM12) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(12)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m13(&mut self, value: BatteryVtBatteryVtIndexM13) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(13)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m14(&mut self, value: BatteryVtBatteryVtIndexM14) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(14)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m15(&mut self, value: BatteryVtBatteryVtIndexM15) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(15)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m16(&mut self, value: BatteryVtBatteryVtIndexM16) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(16)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m17(&mut self, value: BatteryVtBatteryVtIndexM17) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(17)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m18(&mut self, value: BatteryVtBatteryVtIndexM18) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(18)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m19(&mut self, value: BatteryVtBatteryVtIndexM19) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(19)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m20(&mut self, value: BatteryVtBatteryVtIndexM20) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(20)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m21(&mut self, value: BatteryVtBatteryVtIndexM21) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(21)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m22(&mut self, value: BatteryVtBatteryVtIndexM22) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(22)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m23(&mut self, value: BatteryVtBatteryVtIndexM23) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(23)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m24(&mut self, value: BatteryVtBatteryVtIndexM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(24)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m25(&mut self, value: BatteryVtBatteryVtIndexM25) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(25)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m26(&mut self, value: BatteryVtBatteryVtIndexM26) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(26)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m27(&mut self, value: BatteryVtBatteryVtIndexM27) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(27)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m28(&mut self, value: BatteryVtBatteryVtIndexM28) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(28)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m29(&mut self, value: BatteryVtBatteryVtIndexM29) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(29)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m30(&mut self, value: BatteryVtBatteryVtIndexM30) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(30)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m31(&mut self, value: BatteryVtBatteryVtIndexM31) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(31)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m32(&mut self, value: BatteryVtBatteryVtIndexM32) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(32)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m33(&mut self, value: BatteryVtBatteryVtIndexM33) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(33)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m34(&mut self, value: BatteryVtBatteryVtIndexM34) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(34)?; + Ok(()) + } + + /// Set value of BATTERY_VT_INDEX + #[inline(always)] + pub fn set_m35(&mut self, value: BatteryVtBatteryVtIndexM35) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_battery_vt_index(35)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for BatteryVt { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 6 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 6]; + raw.copy_from_slice(&payload[..6]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for BatteryVt { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal BATTERY_VT +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum BatteryVtBatteryVtIndexIndex { + M0(BatteryVtBatteryVtIndexM0), + M1(BatteryVtBatteryVtIndexM1), + M2(BatteryVtBatteryVtIndexM2), + M3(BatteryVtBatteryVtIndexM3), + M4(BatteryVtBatteryVtIndexM4), + M5(BatteryVtBatteryVtIndexM5), + M6(BatteryVtBatteryVtIndexM6), + M7(BatteryVtBatteryVtIndexM7), + M8(BatteryVtBatteryVtIndexM8), + M9(BatteryVtBatteryVtIndexM9), + M10(BatteryVtBatteryVtIndexM10), + M11(BatteryVtBatteryVtIndexM11), + M12(BatteryVtBatteryVtIndexM12), + M13(BatteryVtBatteryVtIndexM13), + M14(BatteryVtBatteryVtIndexM14), + M15(BatteryVtBatteryVtIndexM15), + M16(BatteryVtBatteryVtIndexM16), + M17(BatteryVtBatteryVtIndexM17), + M18(BatteryVtBatteryVtIndexM18), + M19(BatteryVtBatteryVtIndexM19), + M20(BatteryVtBatteryVtIndexM20), + M21(BatteryVtBatteryVtIndexM21), + M22(BatteryVtBatteryVtIndexM22), + M23(BatteryVtBatteryVtIndexM23), + M24(BatteryVtBatteryVtIndexM24), + M25(BatteryVtBatteryVtIndexM25), + M26(BatteryVtBatteryVtIndexM26), + M27(BatteryVtBatteryVtIndexM27), + M28(BatteryVtBatteryVtIndexM28), + M29(BatteryVtBatteryVtIndexM29), + M30(BatteryVtBatteryVtIndexM30), + M31(BatteryVtBatteryVtIndexM31), + M32(BatteryVtBatteryVtIndexM32), + M33(BatteryVtBatteryVtIndexM33), + M34(BatteryVtBatteryVtIndexM34), + M35(BatteryVtBatteryVtIndexM35), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM0 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM0 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_00 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_00(&self) -> u16 { + self.module_temp_00_raw() +} + +/// Get raw value of MODULE_TEMP_00 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_00_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_00 +#[inline(always)] +pub fn set_module_temp_00(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_00 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_00(&self) -> u16 { + self.module_voltage_00_raw() +} + +/// Get raw value of MODULE_VOLTAGE_00 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_00_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_00 +#[inline(always)] +pub fn set_module_voltage_00(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM1 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM1 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_01 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_01(&self) -> u16 { + self.module_temp_01_raw() +} + +/// Get raw value of MODULE_TEMP_01 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_01_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_01 +#[inline(always)] +pub fn set_module_temp_01(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_01 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_01(&self) -> u16 { + self.module_voltage_01_raw() +} + +/// Get raw value of MODULE_VOLTAGE_01 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_01_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_01 +#[inline(always)] +pub fn set_module_voltage_01(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM2 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM2 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_02 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_02(&self) -> u16 { + self.module_temp_02_raw() +} + +/// Get raw value of MODULE_TEMP_02 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_02_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_02 +#[inline(always)] +pub fn set_module_temp_02(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_02 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_02(&self) -> u16 { + self.module_voltage_02_raw() +} + +/// Get raw value of MODULE_VOLTAGE_02 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_02_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_02 +#[inline(always)] +pub fn set_module_voltage_02(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM3 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM3 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_03 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_03(&self) -> u16 { + self.module_temp_03_raw() +} + +/// Get raw value of MODULE_TEMP_03 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_03_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_03 +#[inline(always)] +pub fn set_module_temp_03(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_03 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_03(&self) -> u16 { + self.module_voltage_03_raw() +} + +/// Get raw value of MODULE_VOLTAGE_03 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_03_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_03 +#[inline(always)] +pub fn set_module_voltage_03(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM4 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM4 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_04 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_04(&self) -> u16 { + self.module_temp_04_raw() +} + +/// Get raw value of MODULE_TEMP_04 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_04_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_04 +#[inline(always)] +pub fn set_module_temp_04(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_04 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_04(&self) -> u16 { + self.module_voltage_04_raw() +} + +/// Get raw value of MODULE_VOLTAGE_04 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_04_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_04 +#[inline(always)] +pub fn set_module_voltage_04(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM5 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM5 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_05 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_05(&self) -> u16 { + self.module_temp_05_raw() +} + +/// Get raw value of MODULE_TEMP_05 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_05_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_05 +#[inline(always)] +pub fn set_module_temp_05(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_05 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_05(&self) -> u16 { + self.module_voltage_05_raw() +} + +/// Get raw value of MODULE_VOLTAGE_05 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_05_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_05 +#[inline(always)] +pub fn set_module_voltage_05(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM6 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM6 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_06 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_06(&self) -> u16 { + self.module_temp_06_raw() +} + +/// Get raw value of MODULE_TEMP_06 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_06_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_06 +#[inline(always)] +pub fn set_module_temp_06(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_06 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_06(&self) -> u16 { + self.module_voltage_06_raw() +} + +/// Get raw value of MODULE_VOLTAGE_06 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_06_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_06 +#[inline(always)] +pub fn set_module_voltage_06(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM7 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM7 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_07 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_07(&self) -> u16 { + self.module_temp_07_raw() +} + +/// Get raw value of MODULE_TEMP_07 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_07_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_07 +#[inline(always)] +pub fn set_module_temp_07(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_07 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_07(&self) -> u16 { + self.module_voltage_07_raw() +} + +/// Get raw value of MODULE_VOLTAGE_07 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_07_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_07 +#[inline(always)] +pub fn set_module_voltage_07(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM8 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM8 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_08 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_08(&self) -> u16 { + self.module_temp_08_raw() +} + +/// Get raw value of MODULE_TEMP_08 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_08_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_08 +#[inline(always)] +pub fn set_module_temp_08(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_08 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_08(&self) -> u16 { + self.module_voltage_08_raw() +} + +/// Get raw value of MODULE_VOLTAGE_08 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_08_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_08 +#[inline(always)] +pub fn set_module_voltage_08(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM9 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM9 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_09 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_09(&self) -> u16 { + self.module_temp_09_raw() +} + +/// Get raw value of MODULE_TEMP_09 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_09_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_09 +#[inline(always)] +pub fn set_module_temp_09(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_09 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_09(&self) -> u16 { + self.module_voltage_09_raw() +} + +/// Get raw value of MODULE_VOLTAGE_09 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_09_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_09 +#[inline(always)] +pub fn set_module_voltage_09(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM10 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM10 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_10 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_10(&self) -> u16 { + self.module_temp_10_raw() +} + +/// Get raw value of MODULE_TEMP_10 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_10_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_10 +#[inline(always)] +pub fn set_module_temp_10(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_10 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_10(&self) -> u16 { + self.module_voltage_10_raw() +} + +/// Get raw value of MODULE_VOLTAGE_10 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_10_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_10 +#[inline(always)] +pub fn set_module_voltage_10(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM11 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM11 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_11 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_11(&self) -> u16 { + self.module_temp_11_raw() +} + +/// Get raw value of MODULE_TEMP_11 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_11_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_11 +#[inline(always)] +pub fn set_module_temp_11(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_11 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_11(&self) -> u16 { + self.module_voltage_11_raw() +} + +/// Get raw value of MODULE_VOLTAGE_11 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_11_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_11 +#[inline(always)] +pub fn set_module_voltage_11(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM12 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM12 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_12 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_12(&self) -> u16 { + self.module_temp_12_raw() +} + +/// Get raw value of MODULE_TEMP_12 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_12_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_12 +#[inline(always)] +pub fn set_module_temp_12(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_12 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_12(&self) -> u16 { + self.module_voltage_12_raw() +} + +/// Get raw value of MODULE_VOLTAGE_12 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_12_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_12 +#[inline(always)] +pub fn set_module_voltage_12(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM13 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM13 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_13 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_13(&self) -> u16 { + self.module_temp_13_raw() +} + +/// Get raw value of MODULE_TEMP_13 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_13_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_13 +#[inline(always)] +pub fn set_module_temp_13(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_13 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_13(&self) -> u16 { + self.module_voltage_13_raw() +} + +/// Get raw value of MODULE_VOLTAGE_13 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_13_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_13 +#[inline(always)] +pub fn set_module_voltage_13(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM14 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM14 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_14 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_14(&self) -> u16 { + self.module_temp_14_raw() +} + +/// Get raw value of MODULE_TEMP_14 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_14_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_14 +#[inline(always)] +pub fn set_module_temp_14(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_14 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_14(&self) -> u16 { + self.module_voltage_14_raw() +} + +/// Get raw value of MODULE_VOLTAGE_14 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_14_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_14 +#[inline(always)] +pub fn set_module_voltage_14(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM15 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM15 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_15 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_15(&self) -> u16 { + self.module_temp_15_raw() +} + +/// Get raw value of MODULE_TEMP_15 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_15_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_15 +#[inline(always)] +pub fn set_module_temp_15(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_15 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_15(&self) -> u16 { + self.module_voltage_15_raw() +} + +/// Get raw value of MODULE_VOLTAGE_15 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_15_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_15 +#[inline(always)] +pub fn set_module_voltage_15(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM16 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM16 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_16 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_16(&self) -> u16 { + self.module_temp_16_raw() +} + +/// Get raw value of MODULE_TEMP_16 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_16_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_16 +#[inline(always)] +pub fn set_module_temp_16(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_16 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_16(&self) -> u16 { + self.module_voltage_16_raw() +} + +/// Get raw value of MODULE_VOLTAGE_16 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_16_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_16 +#[inline(always)] +pub fn set_module_voltage_16(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM17 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM17 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_17 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_17(&self) -> u16 { + self.module_temp_17_raw() +} + +/// Get raw value of MODULE_TEMP_17 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_17_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_17 +#[inline(always)] +pub fn set_module_temp_17(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_17 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_17(&self) -> u16 { + self.module_voltage_17_raw() +} + +/// Get raw value of MODULE_VOLTAGE_17 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_17_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_17 +#[inline(always)] +pub fn set_module_voltage_17(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM18 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM18 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_18 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_18(&self) -> u16 { + self.module_temp_18_raw() +} + +/// Get raw value of MODULE_TEMP_18 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_18_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_18 +#[inline(always)] +pub fn set_module_temp_18(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_18 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_18(&self) -> u16 { + self.module_voltage_18_raw() +} + +/// Get raw value of MODULE_VOLTAGE_18 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_18_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_18 +#[inline(always)] +pub fn set_module_voltage_18(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM19 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM19 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_19 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_19(&self) -> u16 { + self.module_temp_19_raw() +} + +/// Get raw value of MODULE_TEMP_19 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_19_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_19 +#[inline(always)] +pub fn set_module_temp_19(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_19 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_19(&self) -> u16 { + self.module_voltage_19_raw() +} + +/// Get raw value of MODULE_VOLTAGE_19 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_19_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_19 +#[inline(always)] +pub fn set_module_voltage_19(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM20 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM20 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_20 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_20(&self) -> u16 { + self.module_temp_20_raw() +} + +/// Get raw value of MODULE_TEMP_20 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_20_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_20 +#[inline(always)] +pub fn set_module_temp_20(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_20 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_20(&self) -> u16 { + self.module_voltage_20_raw() +} + +/// Get raw value of MODULE_VOLTAGE_20 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_20_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_20 +#[inline(always)] +pub fn set_module_voltage_20(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM21 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM21 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_21 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_21(&self) -> u16 { + self.module_temp_21_raw() +} + +/// Get raw value of MODULE_TEMP_21 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_21_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_21 +#[inline(always)] +pub fn set_module_temp_21(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_21 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_21(&self) -> u16 { + self.module_voltage_21_raw() +} + +/// Get raw value of MODULE_VOLTAGE_21 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_21_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_21 +#[inline(always)] +pub fn set_module_voltage_21(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM22 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM22 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_22 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_22(&self) -> u16 { + self.module_temp_22_raw() +} + +/// Get raw value of MODULE_TEMP_22 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_22_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_22 +#[inline(always)] +pub fn set_module_temp_22(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_22 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_22(&self) -> u16 { + self.module_voltage_22_raw() +} + +/// Get raw value of MODULE_VOLTAGE_22 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_22_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_22 +#[inline(always)] +pub fn set_module_voltage_22(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM23 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM23 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_23 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_23(&self) -> u16 { + self.module_temp_23_raw() +} + +/// Get raw value of MODULE_TEMP_23 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_23_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_23 +#[inline(always)] +pub fn set_module_temp_23(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_23 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_23(&self) -> u16 { + self.module_voltage_23_raw() +} + +/// Get raw value of MODULE_VOLTAGE_23 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_23_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_23 +#[inline(always)] +pub fn set_module_voltage_23(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM24 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM24 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_24 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_24(&self) -> u16 { + self.module_temp_24_raw() +} + +/// Get raw value of MODULE_TEMP_24 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_24_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_24 +#[inline(always)] +pub fn set_module_temp_24(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_24 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_24(&self) -> u16 { + self.module_voltage_24_raw() +} + +/// Get raw value of MODULE_VOLTAGE_24 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_24_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_24 +#[inline(always)] +pub fn set_module_voltage_24(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM25 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM25 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_25 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_25(&self) -> u16 { + self.module_temp_25_raw() +} + +/// Get raw value of MODULE_TEMP_25 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_25_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_25 +#[inline(always)] +pub fn set_module_temp_25(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_25 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_25(&self) -> u16 { + self.module_voltage_25_raw() +} + +/// Get raw value of MODULE_VOLTAGE_25 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_25_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_25 +#[inline(always)] +pub fn set_module_voltage_25(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM26 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM26 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_26 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_26(&self) -> u16 { + self.module_temp_26_raw() +} + +/// Get raw value of MODULE_TEMP_26 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_26_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_26 +#[inline(always)] +pub fn set_module_temp_26(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_26 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_26(&self) -> u16 { + self.module_voltage_26_raw() +} + +/// Get raw value of MODULE_VOLTAGE_26 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_26_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_26 +#[inline(always)] +pub fn set_module_voltage_26(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM27 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM27 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_27 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_27(&self) -> u16 { + self.module_temp_27_raw() +} + +/// Get raw value of MODULE_TEMP_27 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_27_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_27 +#[inline(always)] +pub fn set_module_temp_27(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_27 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_27(&self) -> u16 { + self.module_voltage_27_raw() +} + +/// Get raw value of MODULE_VOLTAGE_27 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_27_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_27 +#[inline(always)] +pub fn set_module_voltage_27(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM28 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM28 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_28 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_28(&self) -> u16 { + self.module_temp_28_raw() +} + +/// Get raw value of MODULE_TEMP_28 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_28_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_28 +#[inline(always)] +pub fn set_module_temp_28(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_28 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_28(&self) -> u16 { + self.module_voltage_28_raw() +} + +/// Get raw value of MODULE_VOLTAGE_28 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_28_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_28 +#[inline(always)] +pub fn set_module_voltage_28(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM29 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM29 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_29 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_29(&self) -> u16 { + self.module_temp_29_raw() +} + +/// Get raw value of MODULE_TEMP_29 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_29_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_29 +#[inline(always)] +pub fn set_module_temp_29(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_29 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_29(&self) -> u16 { + self.module_voltage_29_raw() +} + +/// Get raw value of MODULE_VOLTAGE_29 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_29_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_29 +#[inline(always)] +pub fn set_module_voltage_29(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM30 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM30 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_30 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_30(&self) -> u16 { + self.module_temp_30_raw() +} + +/// Get raw value of MODULE_TEMP_30 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_30_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_30 +#[inline(always)] +pub fn set_module_temp_30(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_30 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_30(&self) -> u16 { + self.module_voltage_30_raw() +} + +/// Get raw value of MODULE_VOLTAGE_30 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_30_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_30 +#[inline(always)] +pub fn set_module_voltage_30(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM31 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM31 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_31 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_31(&self) -> u16 { + self.module_temp_31_raw() +} + +/// Get raw value of MODULE_TEMP_31 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_31_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_31 +#[inline(always)] +pub fn set_module_temp_31(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_31 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_31(&self) -> u16 { + self.module_voltage_31_raw() +} + +/// Get raw value of MODULE_VOLTAGE_31 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_31_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_31 +#[inline(always)] +pub fn set_module_voltage_31(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM32 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM32 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_32 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_32(&self) -> u16 { + self.module_temp_32_raw() +} + +/// Get raw value of MODULE_TEMP_32 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_32_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_32 +#[inline(always)] +pub fn set_module_temp_32(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_32 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_32(&self) -> u16 { + self.module_voltage_32_raw() +} + +/// Get raw value of MODULE_VOLTAGE_32 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_32_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_32 +#[inline(always)] +pub fn set_module_voltage_32(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM33 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM33 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_33 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_33(&self) -> u16 { + self.module_temp_33_raw() +} + +/// Get raw value of MODULE_TEMP_33 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_33_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_33 +#[inline(always)] +pub fn set_module_temp_33(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_33 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_33(&self) -> u16 { + self.module_voltage_33_raw() +} + +/// Get raw value of MODULE_VOLTAGE_33 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_33_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_33 +#[inline(always)] +pub fn set_module_voltage_33(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM34 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM34 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_34 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_34(&self) -> u16 { + self.module_temp_34_raw() +} + +/// Get raw value of MODULE_TEMP_34 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_34_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_34 +#[inline(always)] +pub fn set_module_temp_34(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_34 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_34(&self) -> u16 { + self.module_voltage_34_raw() +} + +/// Get raw value of MODULE_VOLTAGE_34 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_34_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_34 +#[inline(always)] +pub fn set_module_voltage_34(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct BatteryVtBatteryVtIndexM35 { raw: [u8; 6] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl BatteryVtBatteryVtIndexM35 { +pub fn new() -> Self { Self { raw: [0u8; 6] } } +/// MODULE_TEMP_35 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_temp_35(&self) -> u16 { + self.module_temp_35_raw() +} + +/// Get raw value of MODULE_TEMP_35 +/// +/// - Start bit: 32 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_temp_35_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_TEMP_35 +#[inline(always)] +pub fn set_module_temp_35(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) +} + +/// MODULE_VOLTAGE_35 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn module_voltage_35(&self) -> u16 { + self.module_voltage_35_raw() +} + +/// Get raw value of MODULE_VOLTAGE_35 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn module_voltage_35_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MODULE_VOLTAGE_35 +#[inline(always)] +pub fn set_module_voltage_35(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: BatteryVt::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiple_senders.snap b/tests-snapshots/dbc-cantools/multiple_senders.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiple_senders.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiple_senders.snap.rs b/tests-snapshots/dbc-cantools/multiple_senders.snap.rs new file mode 100644 index 0000000..fdd7268 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiple_senders.snap.rs @@ -0,0 +1,213 @@ +// Generated code! +// +// Message definitions from file `multiple_senders` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Bar + Bar(Bar), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Bar::MESSAGE_ID => Messages::Bar(Bar::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Bar +/// +/// - Standard ID: 1 (0x1) +/// - Size: 4 bytes +/// - Transmitter: FOO +#[derive(Clone, Copy)] +pub struct Bar { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bar { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const BINARY32_MIN: i32 = 0_i32; + pub const BINARY32_MAX: i32 = 0_i32; + + /// Construct new Bar from values + pub fn new(binary32: i32) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_binary32(binary32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// Binary32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: FUM + #[inline(always)] + pub fn binary32(&self) -> i32 { + self.binary32_raw() + } + + /// Get raw value of Binary32 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn binary32_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Binary32 + #[inline(always)] + pub fn set_binary32(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bar { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bar { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiplex.snap b/tests-snapshots/dbc-cantools/multiplex.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiplex.snap.rs b/tests-snapshots/dbc-cantools/multiplex.snap.rs new file mode 100644 index 0000000..209181b --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex.snap.rs @@ -0,0 +1,665 @@ +// Generated code! +// +// Message definitions from file `multiplex` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Extended ID: 1193046 (0x123456) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123456)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message1 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message1MultiplexorIndex::M8(Message1MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message1MultiplexorIndex::M24(Message1MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message1::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message1MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message1MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Message1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message1MultiplexorIndex { + M8(Message1MultiplexorM8), + M24(Message1MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiplex_2.snap b/tests-snapshots/dbc-cantools/multiplex_2.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_2.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiplex_2.snap.rs b/tests-snapshots/dbc-cantools/multiplex_2.snap.rs new file mode 100644 index 0000000..07fa809 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_2.snap.rs @@ -0,0 +1,1603 @@ +// Generated code! +// +// Message definitions from file `multiplex_2` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Shared + Shared(Shared), + /// Normal + Normal(Normal), + /// Extended + Extended(Extended), + /// ExtendedTypes + ExtendedTypes(ExtendedTypes), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Shared::MESSAGE_ID => Messages::Shared(Shared::try_from(payload)?), + Normal::MESSAGE_ID => Messages::Normal(Normal::try_from(payload)?), + Extended::MESSAGE_ID => Messages::Extended(Extended::try_from(payload)?), + ExtendedTypes::MESSAGE_ID => Messages::ExtendedTypes(ExtendedTypes::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Shared +/// +/// - Extended ID: 201522942 (0xc02fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Shared { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Shared { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc02fefe)}); + + pub const S2_MIN: i8 = 0_i8; + pub const S2_MAX: i8 = 0_i8; + pub const S1_MIN: i8 = 0_i8; + pub const S1_MAX: i8 = 0_i8; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + + /// Construct new Shared from values + pub fn new(s0: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s0(s0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S0 + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 1 => Ok(SharedS0Index::M1(SharedS0M1{ raw: self.raw })), + 2 => Ok(SharedS0Index::M2(SharedS0M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Shared::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m1(&mut self, value: SharedS0M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(1)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m2(&mut self, value: SharedS0M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Shared { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Shared { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Shared +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum SharedS0Index { + M1(SharedS0M1), + M2(SharedS0M2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SharedS0M1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SharedS0M1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s1(&self) -> i8 { + self.s1_raw() +} + +/// Get raw value of S1 +/// +/// - Start bit: 4 +/// - Signal size: 4 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S1 +#[inline(always)] +pub fn set_s1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SharedS0M2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SharedS0M2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s2(&self) -> i8 { + self.s2_raw() +} + +/// Get raw value of S2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S2 +#[inline(always)] +pub fn set_s2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + +/// Normal +/// +/// - Extended ID: 201457406 (0xc01fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Normal { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Normal { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc01fefe)}); + + pub const S2_MIN: i8 = 0_i8; + pub const S2_MAX: i8 = 0_i8; + pub const S1_MIN: i8 = 0_i8; + pub const S1_MAX: i8 = 0_i8; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + + /// Construct new Normal from values + pub fn new(s0: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s0(s0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S0 + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 0 => Ok(NormalS0Index::M0(NormalS0M0{ raw: self.raw })), + 1 => Ok(NormalS0Index::M1(NormalS0M1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Normal::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m0(&mut self, value: NormalS0M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(0)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m1(&mut self, value: NormalS0M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Normal { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Normal { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Normal +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum NormalS0Index { + M0(NormalS0M0), + M1(NormalS0M1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct NormalS0M0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalS0M0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s1(&self) -> i8 { + self.s1_raw() +} + +/// Get raw value of S1 +/// +/// - Start bit: 4 +/// - Signal size: 4 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S1 +#[inline(always)] +pub fn set_s1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct NormalS0M1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalS0M1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s2(&self) -> i8 { + self.s2_raw() +} + +/// Get raw value of S2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S2 +#[inline(always)] +pub fn set_s2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + +/// Extended +/// +/// - Extended ID: 201391870 (0xc00fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Extended { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Extended { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc00fefe)}); + + pub const S8_MIN: i8 = 0_i8; + pub const S8_MAX: i8 = 0_i8; + pub const S7_MIN: i32 = 0_i32; + pub const S7_MAX: i32 = 0_i32; + pub const S6_MIN: i8 = 0_i8; + pub const S6_MAX: i8 = 0_i8; + pub const S5_MIN: i32 = 0_i32; + pub const S5_MAX: i32 = 0_i32; + pub const S4_MIN: i32 = 0_i32; + pub const S4_MAX: i32 = 0_i32; + pub const S3_MIN: i16 = 0_i16; + pub const S3_MAX: i16 = 0_i16; + pub const S2_MIN: i8 = 0_i8; + pub const S2_MAX: i8 = 0_i8; + pub const S1_MIN: i8 = 0_i8; + pub const S1_MAX: i8 = 0_i8; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + + /// Construct new Extended from values + pub fn new(s6: i8, s0: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s6(s6)?; + res.set_s0(s0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S6 + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s6_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s6(&mut self) -> Result { + match self.s6_raw() { + 0 => Ok(ExtendedS6Index::M0(ExtendedS6M0{ raw: self.raw })), + 1 => Ok(ExtendedS6Index::M1(ExtendedS6M1{ raw: self.raw })), + 2 => Ok(ExtendedS6Index::M2(ExtendedS6M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S6 + #[inline(always)] + fn set_s6(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// Set value of S6 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedS6M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s6(0)?; + Ok(()) + } + + /// Set value of S6 + #[inline(always)] + pub fn set_m1(&mut self, value: ExtendedS6M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s6(1)?; + Ok(()) + } + + /// Set value of S6 + #[inline(always)] + pub fn set_m2(&mut self, value: ExtendedS6M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s6(2)?; + Ok(()) + } + + /// Get raw value of S0 + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 0 => Ok(ExtendedS0Index::M0(ExtendedS0M0{ raw: self.raw })), + 1 => Ok(ExtendedS0Index::M1(ExtendedS0M1{ raw: self.raw })), + 2 => Ok(ExtendedS0Index::M2(ExtendedS0M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedS0M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(0)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m1(&mut self, value: ExtendedS0M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(1)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m2(&mut self, value: ExtendedS0M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Extended { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Extended { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Extended +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtendedS6Index { + M0(ExtendedS6M0), + M1(ExtendedS6M1), + M2(ExtendedS6M2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedS6M0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedS6M0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S3 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s3(&self) -> i16 { + self.s3_raw() +} + +/// Get raw value of S3 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s3_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S3 +#[inline(always)] +pub fn set_s3(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 0_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +/// S2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s2(&self) -> i8 { + self.s2_raw() +} + +/// Get raw value of S2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S2 +#[inline(always)] +pub fn set_s2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedS6M1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedS6M1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S7 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s7(&self) -> i32 { + self.s7_raw() +} + +/// Get raw value of S7 +/// +/// - Start bit: 40 +/// - Signal size: 24 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s7_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S7 +#[inline(always)] +pub fn set_s7(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) +} + +/// S5 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s5(&self) -> i32 { + self.s5_raw() +} + +/// Get raw value of S5 +/// +/// - Start bit: 4 +/// - Signal size: 28 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s5_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[4..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S5 +#[inline(always)] +pub fn set_s5(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedS6M2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedS6M2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S8 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s8(&self) -> i8 { + self.s8_raw() +} + +/// Get raw value of S8 +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s8_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S8 +#[inline(always)] +pub fn set_s8(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// S4 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s4(&self) -> i32 { + self.s4_raw() +} + +/// Get raw value of S4 +/// +/// - Start bit: 8 +/// - Signal size: 24 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s4_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S4 +#[inline(always)] +pub fn set_s4(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) +} + +} + + +/// ExtendedTypes +/// +/// - Extended ID: 201588478 (0xc03fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtendedTypes { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedTypes { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc03fefe)}); + + pub const S9_MIN: i32 = -1.34_i32; + pub const S9_MAX: i32 = 1235_i32; + pub const S10_MIN: i32 = -340000000000000000000000000000000000000_i32; + pub const S10_MAX: i32 = 340000000000000000000000000000000000000_i32; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + pub const S11_MIN: u8 = 2_u8; + pub const S11_MAX: u8 = 6_u8; + + /// Construct new ExtendedTypes from values + pub fn new(s11: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s11(s11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S11 + /// + /// - Start bit: 0 + /// - Signal size: 5 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn s11_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..5].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s11(&mut self) -> Result { + match self.s11_raw() { + 0 => Ok(ExtendedTypesS11Index::M0(ExtendedTypesS11M0{ raw: self.raw })), + 5 => Ok(ExtendedTypesS11Index::M5(ExtendedTypesS11M5{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtendedTypes::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S11 + #[inline(always)] + fn set_s11(&mut self, value: u8) -> Result<(), CanError> { + if value < 2_u8 || 6_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..5].store_le(value); + Ok(()) + } + + /// Set value of S11 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedTypesS11M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s11(0)?; + Ok(()) + } + + /// Set value of S11 + #[inline(always)] + pub fn set_m5(&mut self, value: ExtendedTypesS11M5) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s11(5)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtendedTypes { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtendedTypes { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ExtendedTypes +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtendedTypesS11Index { + M0(ExtendedTypesS11M0), + M5(ExtendedTypesS11M5), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedTypesS11M0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedTypesS11M0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S10 +/// +/// - Min: -340000000000000000000000000000000000000 +/// - Max: 340000000000000000000000000000000000000 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s10(&self) -> i32 { + self.s10_raw() +} + +/// Get raw value of S10 +/// +/// - Start bit: 16 +/// - Signal size: 32 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s10_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[16..48].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S10 +#[inline(always)] +pub fn set_s10(&mut self, value: i32) -> Result<(), CanError> { + if value < -340000000000000000000000000000000000000_i32 || 340000000000000000000000000000000000000_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..48].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedTypesS11M5 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedTypesS11M5 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S9 +/// +/// - Min: -1.34 +/// - Max: 1235 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s9(&self) -> i32 { + self.s9_raw() +} + +/// Get raw value of S9 +/// +/// - Start bit: 24 +/// - Signal size: 32 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s9_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[24..56].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S9 +#[inline(always)] +pub fn set_s9(&mut self, value: i32) -> Result<(), CanError> { + if value < -1.34_i32 || 1235_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..56].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiplex_2.snap.stderr b/tests-snapshots/dbc-cantools/multiplex_2.snap.stderr new file mode 100644 index 0000000..49244aa --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_2.snap.stderr @@ -0,0 +1,190 @@ +error[E0412]: cannot find type `ExtendedS0Index` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:809:36 + | +809 | pub fn s0(&mut self) -> Result { + | ^^^^^^^^^^^^^^^ +... +923 | pub enum ExtendedS6Index { + | ------------------------ similarly named enum `ExtendedS6Index` defined here + | +help: an enum with a similar name exists + | +809 - pub fn s0(&mut self) -> Result { +809 + pub fn s0(&mut self) -> Result { + | +help: you might be missing a type parameter + | +686 | impl Extended { + | +++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtendedS0M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:811:41 + | +811 | 0 => Ok(ExtendedS0Index::M0(ExtendedS0M0{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M0` +... +939 | pub struct ExtendedS6M0 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M0` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedS0M1` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:812:41 + | + 812 | 1 => Ok(ExtendedS0Index::M1(ExtendedS0M1{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M1` +... +1052 | pub struct ExtendedS6M1 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M1` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedS0M2` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:813:41 + | + 813 | 2 => Ok(ExtendedS0Index::M2(ExtendedS0M2{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M2` +... +1165 | pub struct ExtendedS6M2 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M2` defined here + +error[E0412]: cannot find type `ExtendedS0M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:835:37 + | +835 | pub fn set_m0(&mut self, value: ExtendedS0M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M0` +... +939 | pub struct ExtendedS6M0 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M0` defined here + +error[E0412]: cannot find type `ExtendedS0M1` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:845:37 + | + 845 | pub fn set_m1(&mut self, value: ExtendedS0M1) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M1` +... +1052 | pub struct ExtendedS6M1 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M1` defined here + +error[E0412]: cannot find type `ExtendedS0M2` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:855:37 + | + 855 | pub fn set_m2(&mut self, value: ExtendedS0M2) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M2` +... +1165 | pub struct ExtendedS6M2 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M2` defined here + +error: invalid suffix `i32` for float literal + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:1290:30 + | +1290 | pub const S9_MIN: i32 = -1.34_i32; + | ^^^^^^^^ invalid suffix `i32` + | + = help: valid suffixes are `f32` and `f64` + +error: invalid suffix `i32` for float literal + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:1557:17 + | +1557 | if value < -1.34_i32 || 1235_i32 < value { + | ^^^^^^^^ invalid suffix `i32` + | + = help: valid suffixes are `f32` and `f64` + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:835:5 + | +764 | pub fn set_m0(&mut self, value: ExtendedS6M0) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m0` +... +835 | pub fn set_m0(&mut self, value: ExtendedS0M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m1` + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:845:5 + | +774 | pub fn set_m1(&mut self, value: ExtendedS6M1) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m1` +... +845 | pub fn set_m1(&mut self, value: ExtendedS0M1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m1` + +error[E0592]: duplicate definitions with name `set_m2` + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:855:5 + | +784 | pub fn set_m2(&mut self, value: ExtendedS6M2) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m2` +... +855 | pub fn set_m2(&mut self, value: ExtendedS0M2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m2` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:121:120 + | +121 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Shared::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:425:120 + | +425 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Normal::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:743:122 + | +743 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS0Index` + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:811:21 + | +811 | 0 => Ok(ExtendedS0Index::M0(ExtendedS0M0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS0Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS0Index` + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:812:21 + | +812 | 1 => Ok(ExtendedS0Index::M1(ExtendedS0M1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS0Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS0Index` + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:813:21 + | +813 | 2 => Ok(ExtendedS0Index::M2(ExtendedS0M2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS0Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2.snap.rs:814:122 + | +814 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` diff --git a/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap b/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs b/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs new file mode 100644 index 0000000..8f99398 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs @@ -0,0 +1,1736 @@ +// Generated code! +// +// Message definitions from file `multiplex_2_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Shared + Shared(Shared), + /// Normal + Normal(Normal), + /// Extended + Extended(Extended), + /// ExtendedTypes + ExtendedTypes(ExtendedTypes), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Shared::MESSAGE_ID => Messages::Shared(Shared::try_from(payload)?), + Normal::MESSAGE_ID => Messages::Normal(Normal::try_from(payload)?), + Extended::MESSAGE_ID => Messages::Extended(Extended::try_from(payload)?), + ExtendedTypes::MESSAGE_ID => Messages::ExtendedTypes(ExtendedTypes::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Shared +/// +/// - Extended ID: 201522942 (0xc02fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Shared { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Shared { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc02fefe)}); + + pub const S2_MIN: i8 = 0_i8; + pub const S2_MAX: i8 = 0_i8; + pub const S1_MIN: i8 = 0_i8; + pub const S1_MAX: i8 = 0_i8; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + + /// Construct new Shared from values + pub fn new(s0: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s0(s0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S0 + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 1 => Ok(SharedS0Index::M1(SharedS0M1{ raw: self.raw })), + 2 => Ok(SharedS0Index::M2(SharedS0M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Shared::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m1(&mut self, value: SharedS0M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(1)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m2(&mut self, value: SharedS0M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Shared { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Shared { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Shared +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum SharedS0Index { + M1(SharedS0M1), + M2(SharedS0M2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SharedS0M1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SharedS0M1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s1(&self) -> i8 { + self.s1_raw() +} + +/// Get raw value of S1 +/// +/// - Start bit: 4 +/// - Signal size: 4 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S1 +#[inline(always)] +pub fn set_s1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SharedS0M2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SharedS0M2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s2(&self) -> i8 { + self.s2_raw() +} + +/// Get raw value of S2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S2 +#[inline(always)] +pub fn set_s2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Shared::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + +/// Normal +/// +/// - Extended ID: 201457406 (0xc01fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Normal { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Normal { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc01fefe)}); + + pub const S2_MIN: i8 = 0_i8; + pub const S2_MAX: i8 = 0_i8; + pub const S1_MIN: i8 = 0_i8; + pub const S1_MAX: i8 = 0_i8; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + + /// Construct new Normal from values + pub fn new(s0: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s0(s0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S0 + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 0 => Ok(NormalS0Index::M0(NormalS0M0{ raw: self.raw })), + 1 => Ok(NormalS0Index::M1(NormalS0M1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Normal::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m0(&mut self, value: NormalS0M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(0)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m1(&mut self, value: NormalS0M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Normal { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Normal { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Normal +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum NormalS0Index { + M0(NormalS0M0), + M1(NormalS0M1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct NormalS0M0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalS0M0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S1 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s1(&self) -> i8 { + self.s1_raw() +} + +/// Get raw value of S1 +/// +/// - Start bit: 4 +/// - Signal size: 4 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S1 +#[inline(always)] +pub fn set_s1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct NormalS0M1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalS0M1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s2(&self) -> i8 { + self.s2_raw() +} + +/// Get raw value of S2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S2 +#[inline(always)] +pub fn set_s2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Normal::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + +/// Extended +/// +/// - Extended ID: 201391870 (0xc00fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Extended { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Extended { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc00fefe)}); + + pub const S7_MIN: i32 = 0_i32; + pub const S7_MAX: i32 = 0_i32; + pub const S8_MIN: i8 = 0_i8; + pub const S8_MAX: i8 = 0_i8; + pub const S6_MIN: i8 = 0_i8; + pub const S6_MAX: i8 = 0_i8; + pub const S3_MIN: i16 = 0_i16; + pub const S3_MAX: i16 = 0_i16; + pub const S2_MIN: i8 = 0_i8; + pub const S2_MAX: i8 = 0_i8; + pub const S4_MIN: i32 = 0_i32; + pub const S4_MAX: i32 = 0_i32; + pub const S1_MIN: i8 = 0_i8; + pub const S1_MAX: i8 = 0_i8; + pub const S5_MIN: i32 = 0_i32; + pub const S5_MAX: i32 = 0_i32; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + + /// Construct new Extended from values + pub fn new(s6: i8, s1: i8, s0: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s6(s6)?; + res.set_s1(s1)?; + res.set_s0(s0)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S6 + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s6_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s6(&mut self) -> Result { + match self.s6_raw() { + 0 => Ok(ExtendedS6Index::M0(ExtendedS6M0{ raw: self.raw })), + 1 => Ok(ExtendedS6Index::M1(ExtendedS6M1{ raw: self.raw })), + 2 => Ok(ExtendedS6Index::M2(ExtendedS6M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S6 + #[inline(always)] + fn set_s6(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// Set value of S6 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedS6M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s6(0)?; + Ok(()) + } + + /// Set value of S6 + #[inline(always)] + pub fn set_m1(&mut self, value: ExtendedS6M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s6(1)?; + Ok(()) + } + + /// Set value of S6 + #[inline(always)] + pub fn set_m2(&mut self, value: ExtendedS6M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s6(2)?; + Ok(()) + } + + /// Get raw value of S1 + /// + /// - Start bit: 4 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s1(&mut self) -> Result { + match self.s1_raw() { + 0 => Ok(ExtendedS1Index::M0(ExtendedS1M0{ raw: self.raw })), + 1 => Ok(ExtendedS1Index::M1(ExtendedS1M1{ raw: self.raw })), + 2 => Ok(ExtendedS1Index::M2(ExtendedS1M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S1 + #[inline(always)] + fn set_s1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) + } + + /// Set value of S1 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedS1M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s1(0)?; + Ok(()) + } + + /// Set value of S1 + #[inline(always)] + pub fn set_m1(&mut self, value: ExtendedS1M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s1(1)?; + Ok(()) + } + + /// Set value of S1 + #[inline(always)] + pub fn set_m2(&mut self, value: ExtendedS1M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s1(2)?; + Ok(()) + } + + /// Get raw value of S0 + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 0 => Ok(ExtendedS0Index::M0(ExtendedS0M0{ raw: self.raw })), + 1 => Ok(ExtendedS0Index::M1(ExtendedS0M1{ raw: self.raw })), + 2 => Ok(ExtendedS0Index::M2(ExtendedS0M2{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedS0M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(0)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m1(&mut self, value: ExtendedS0M1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(1)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m2(&mut self, value: ExtendedS0M2) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(2)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Extended { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Extended { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Extended +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtendedS6Index { + M0(ExtendedS6M0), + M1(ExtendedS6M1), + M2(ExtendedS6M2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedS6M0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedS6M0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S3 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s3(&self) -> i16 { + self.s3_raw() +} + +/// Get raw value of S3 +/// +/// - Start bit: 16 +/// - Signal size: 16 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s3_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S3 +#[inline(always)] +pub fn set_s3(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 0_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) +} + +/// S2 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s2(&self) -> i8 { + self.s2_raw() +} + +/// Get raw value of S2 +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S2 +#[inline(always)] +pub fn set_s2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedS6M1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedS6M1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S7 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s7(&self) -> i32 { + self.s7_raw() +} + +/// Get raw value of S7 +/// +/// - Start bit: 40 +/// - Signal size: 24 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s7_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S7 +#[inline(always)] +pub fn set_s7(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) +} + +/// S5 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s5(&self) -> i32 { + self.s5_raw() +} + +/// Get raw value of S5 +/// +/// - Start bit: 4 +/// - Signal size: 28 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s5_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[4..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S5 +#[inline(always)] +pub fn set_s5(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[4..32].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedS6M2 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedS6M2 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S8 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s8(&self) -> i8 { + self.s8_raw() +} + +/// Get raw value of S8 +/// +/// - Start bit: 40 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s8_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S8 +#[inline(always)] +pub fn set_s8(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) +} + +/// S4 +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s4(&self) -> i32 { + self.s4_raw() +} + +/// Get raw value of S4 +/// +/// - Start bit: 8 +/// - Signal size: 24 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s4_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S4 +#[inline(always)] +pub fn set_s4(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Extended::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) +} + +} + + +/// ExtendedTypes +/// +/// - Extended ID: 201588478 (0xc03fefe) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct ExtendedTypes { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedTypes { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xc03fefe)}); + + pub const S9_MIN: i32 = -1.34_i32; + pub const S9_MAX: i32 = 1235_i32; + pub const S10_MIN: i32 = -340000000000000000000000000000000000000_i32; + pub const S10_MAX: i32 = 340000000000000000000000000000000000000_i32; + pub const S0_MIN: i8 = 0_i8; + pub const S0_MAX: i8 = 0_i8; + pub const S11_MIN: u8 = 2_u8; + pub const S11_MAX: u8 = 6_u8; + + /// Construct new ExtendedTypes from values + pub fn new(s0: i8, s11: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s0(s0)?; + res.set_s11(s11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of S0 + /// + /// - Start bit: 8 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s0_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..12].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s0(&mut self) -> Result { + match self.s0_raw() { + 0 => Ok(ExtendedTypesS0Index::M0(ExtendedTypesS0M0{ raw: self.raw })), + 5 => Ok(ExtendedTypesS0Index::M5(ExtendedTypesS0M5{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtendedTypes::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S0 + #[inline(always)] + fn set_s0(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..12].store_le(value); + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedTypesS0M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(0)?; + Ok(()) + } + + /// Set value of S0 + #[inline(always)] + pub fn set_m5(&mut self, value: ExtendedTypesS0M5) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s0(5)?; + Ok(()) + } + + /// Get raw value of S11 + /// + /// - Start bit: 0 + /// - Signal size: 5 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn s11_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..5].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn s11(&mut self) -> Result { + match self.s11_raw() { + 0 => Ok(ExtendedTypesS11Index::M0(ExtendedTypesS11M0{ raw: self.raw })), + 5 => Ok(ExtendedTypesS11Index::M5(ExtendedTypesS11M5{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtendedTypes::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of S11 + #[inline(always)] + fn set_s11(&mut self, value: u8) -> Result<(), CanError> { + if value < 2_u8 || 6_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..5].store_le(value); + Ok(()) + } + + /// Set value of S11 + #[inline(always)] + pub fn set_m0(&mut self, value: ExtendedTypesS11M0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s11(0)?; + Ok(()) + } + + /// Set value of S11 + #[inline(always)] + pub fn set_m5(&mut self, value: ExtendedTypesS11M5) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_s11(5)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ExtendedTypes { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ExtendedTypes { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal ExtendedTypes +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum ExtendedTypesS0Index { + M0(ExtendedTypesS0M0), + M5(ExtendedTypesS0M5), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedTypesS0M0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedTypesS0M0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S10 +/// +/// - Min: -340000000000000000000000000000000000000 +/// - Max: 340000000000000000000000000000000000000 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s10(&self) -> i32 { + self.s10_raw() +} + +/// Get raw value of S10 +/// +/// - Start bit: 16 +/// - Signal size: 32 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s10_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[16..48].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S10 +#[inline(always)] +pub fn set_s10(&mut self, value: i32) -> Result<(), CanError> { + if value < -340000000000000000000000000000000000000_i32 || 340000000000000000000000000000000000000_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..48].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct ExtendedTypesS0M5 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ExtendedTypesS0M5 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// S9 +/// +/// - Min: -1.34 +/// - Max: 1235 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn s9(&self) -> i32 { + self.s9_raw() +} + +/// Get raw value of S9 +/// +/// - Start bit: 24 +/// - Signal size: 32 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn s9_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[24..56].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of S9 +#[inline(always)] +pub fn set_s9(&mut self, value: i32) -> Result<(), CanError> { + if value < -1.34_i32 || 1235_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ExtendedTypes::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..56].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.stderr b/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.stderr new file mode 100644 index 0000000..1b0e3e3 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.stderr @@ -0,0 +1,432 @@ +error[E0412]: cannot find type `ExtendedS1Index` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:810:36 + | +810 | pub fn s1(&mut self) -> Result { + | ^^^^^^^^^^^^^^^ +... +995 | pub enum ExtendedS6Index { + | ------------------------ similarly named enum `ExtendedS6Index` defined here + | +help: an enum with a similar name exists + | +810 - pub fn s1(&mut self) -> Result { +810 + pub fn s1(&mut self) -> Result { + | +help: you might be missing a type parameter + | +686 | impl Extended { + | +++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtendedS1M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:812:41 + | + 812 | 0 => Ok(ExtendedS1Index::M0(ExtendedS1M0{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M0` +... +1011 | pub struct ExtendedS6M0 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M0` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedS1M1` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:813:41 + | + 813 | 1 => Ok(ExtendedS1Index::M1(ExtendedS1M1{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M1` +... +1124 | pub struct ExtendedS6M1 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M1` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedS1M2` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:814:41 + | + 814 | 2 => Ok(ExtendedS1Index::M2(ExtendedS1M2{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M2` +... +1237 | pub struct ExtendedS6M2 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M2` defined here + +error[E0412]: cannot find type `ExtendedS1M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:836:37 + | + 836 | pub fn set_m0(&mut self, value: ExtendedS1M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M0` +... +1011 | pub struct ExtendedS6M0 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M0` defined here + +error[E0412]: cannot find type `ExtendedS1M1` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:846:37 + | + 846 | pub fn set_m1(&mut self, value: ExtendedS1M1) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M1` +... +1124 | pub struct ExtendedS6M1 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M1` defined here + +error[E0412]: cannot find type `ExtendedS1M2` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:856:37 + | + 856 | pub fn set_m2(&mut self, value: ExtendedS1M2) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M2` +... +1237 | pub struct ExtendedS6M2 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M2` defined here + +error[E0412]: cannot find type `ExtendedS0Index` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:881:36 + | +881 | pub fn s0(&mut self) -> Result { + | ^^^^^^^^^^^^^^^ +... +995 | pub enum ExtendedS6Index { + | ------------------------ similarly named enum `ExtendedS6Index` defined here + | +help: an enum with a similar name exists + | +881 - pub fn s0(&mut self) -> Result { +881 + pub fn s0(&mut self) -> Result { + | +help: you might be missing a type parameter + | +686 | impl Extended { + | +++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtendedS0M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:883:41 + | + 883 | 0 => Ok(ExtendedS0Index::M0(ExtendedS0M0{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M0` +... +1011 | pub struct ExtendedS6M0 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M0` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedS0M1` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:884:41 + | + 884 | 1 => Ok(ExtendedS0Index::M1(ExtendedS0M1{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M1` +... +1124 | pub struct ExtendedS6M1 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M1` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedS0M2` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:885:41 + | + 885 | 2 => Ok(ExtendedS0Index::M2(ExtendedS0M2{ raw: self.raw })), + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M2` +... +1237 | pub struct ExtendedS6M2 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M2` defined here + +error[E0412]: cannot find type `ExtendedS0M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:907:37 + | + 907 | pub fn set_m0(&mut self, value: ExtendedS0M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M0` +... +1011 | pub struct ExtendedS6M0 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M0` defined here + +error[E0412]: cannot find type `ExtendedS0M1` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:917:37 + | + 917 | pub fn set_m1(&mut self, value: ExtendedS0M1) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M1` +... +1124 | pub struct ExtendedS6M1 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M1` defined here + +error[E0412]: cannot find type `ExtendedS0M2` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:927:37 + | + 927 | pub fn set_m2(&mut self, value: ExtendedS0M2) -> Result<(), CanError> { + | ^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedS6M2` +... +1237 | pub struct ExtendedS6M2 { raw: [u8; 8] } + | ----------------------- similarly named struct `ExtendedS6M2` defined here + +error[E0412]: cannot find type `ExtendedTypesS11Index` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1460:37 + | +1460 | pub fn s11(&mut self) -> Result { + | ^^^^^^^^^^^^^^^^^^^^^ +... +1562 | pub enum ExtendedTypesS0Index { + | ----------------------------- similarly named enum `ExtendedTypesS0Index` defined here + | +help: an enum with a similar name exists + | +1460 - pub fn s11(&mut self) -> Result { +1460 + pub fn s11(&mut self) -> Result { + | +help: you might be missing a type parameter + | +1359 | impl ExtendedTypes { + | +++++++++++++++++++++++ + +error[E0422]: cannot find struct, variant or union type `ExtendedTypesS11M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1462:47 + | +1462 | 0 => Ok(ExtendedTypesS11Index::M0(ExtendedTypesS11M0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedTypesS0M0` +... +1577 | pub struct ExtendedTypesS0M0 { raw: [u8; 8] } + | ---------------------------- similarly named struct `ExtendedTypesS0M0` defined here + +error[E0422]: cannot find struct, variant or union type `ExtendedTypesS11M5` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1463:47 + | +1463 | 5 => Ok(ExtendedTypesS11Index::M5(ExtendedTypesS11M5{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedTypesS0M5` +... +1646 | pub struct ExtendedTypesS0M5 { raw: [u8; 8] } + | ---------------------------- similarly named struct `ExtendedTypesS0M5` defined here + +error[E0412]: cannot find type `ExtendedTypesS11M0` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1484:37 + | +1484 | pub fn set_m0(&mut self, value: ExtendedTypesS11M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedTypesS0M0` +... +1577 | pub struct ExtendedTypesS0M0 { raw: [u8; 8] } + | ---------------------------- similarly named struct `ExtendedTypesS0M0` defined here + +error[E0412]: cannot find type `ExtendedTypesS11M5` in this scope + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1494:37 + | +1494 | pub fn set_m5(&mut self, value: ExtendedTypesS11M5) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^ help: a struct with a similar name exists: `ExtendedTypesS0M5` +... +1646 | pub struct ExtendedTypesS0M5 { raw: [u8; 8] } + | ---------------------------- similarly named struct `ExtendedTypesS0M5` defined here + +error: invalid suffix `i32` for float literal + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1362:30 + | +1362 | pub const S9_MIN: i32 = -1.34_i32; + | ^^^^^^^^ invalid suffix `i32` + | + = help: valid suffixes are `f32` and `f64` + +error: invalid suffix `i32` for float literal + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1690:17 + | +1690 | if value < -1.34_i32 || 1235_i32 < value { + | ^^^^^^^^ invalid suffix `i32` + | + = help: valid suffixes are `f32` and `f64` + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:836:5 + | +765 | pub fn set_m0(&mut self, value: ExtendedS6M0) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m0` +... +836 | pub fn set_m0(&mut self, value: ExtendedS1M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m1` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:846:5 + | +775 | pub fn set_m1(&mut self, value: ExtendedS6M1) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m1` +... +846 | pub fn set_m1(&mut self, value: ExtendedS1M1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m1` + +error[E0592]: duplicate definitions with name `set_m2` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:856:5 + | +785 | pub fn set_m2(&mut self, value: ExtendedS6M2) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m2` +... +856 | pub fn set_m2(&mut self, value: ExtendedS1M2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m2` + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:907:5 + | +765 | pub fn set_m0(&mut self, value: ExtendedS6M0) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m0` +... +907 | pub fn set_m0(&mut self, value: ExtendedS0M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m1` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:917:5 + | +775 | pub fn set_m1(&mut self, value: ExtendedS6M1) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m1` +... +917 | pub fn set_m1(&mut self, value: ExtendedS0M1) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m1` + +error[E0592]: duplicate definitions with name `set_m2` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:927:5 + | +785 | pub fn set_m2(&mut self, value: ExtendedS6M2) -> Result<(), CanError> { + | --------------------------------------------------------------------- other definition for `set_m2` +... +927 | pub fn set_m2(&mut self, value: ExtendedS0M2) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m2` + +error[E0592]: duplicate definitions with name `set_m0` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1484:5 + | +1426 | pub fn set_m0(&mut self, value: ExtendedTypesS0M0) -> Result<(), CanError> { + | -------------------------------------------------------------------------- other definition for `set_m0` +... +1484 | pub fn set_m0(&mut self, value: ExtendedTypesS11M0) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m0` + +error[E0592]: duplicate definitions with name `set_m5` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1494:5 + | +1436 | pub fn set_m5(&mut self, value: ExtendedTypesS0M5) -> Result<(), CanError> { + | -------------------------------------------------------------------------- other definition for `set_m5` +... +1494 | pub fn set_m5(&mut self, value: ExtendedTypesS11M5) -> Result<(), CanError> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `set_m5` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:121:120 + | +121 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Shared::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:425:120 + | +425 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Normal::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:744:122 + | +744 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS1Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:812:21 + | +812 | 0 => Ok(ExtendedS1Index::M0(ExtendedS1M0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS1Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS1Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:813:21 + | +813 | 1 => Ok(ExtendedS1Index::M1(ExtendedS1M1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS1Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS1Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:814:21 + | +814 | 2 => Ok(ExtendedS1Index::M2(ExtendedS1M2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS1Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:815:122 + | +815 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS0Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:883:21 + | +883 | 0 => Ok(ExtendedS0Index::M0(ExtendedS0M0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS0Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS0Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:884:21 + | +884 | 1 => Ok(ExtendedS0Index::M1(ExtendedS0M1{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS0Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedS0Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:885:21 + | +885 | 2 => Ok(ExtendedS0Index::M2(ExtendedS0M2{ raw: self.raw })), + | ^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedS0Index` + | help: an enum with a similar name exists: `ExtendedS6Index` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:886:122 + | +886 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: Extended::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0277]: the trait bound `u16: From` is not satisfied + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1405:127 + | +1405 | multiplexor => Err(CanError::InvalidMultiplexor { message_id: ExtendedTypes::MESSAGE_ID, multiplexor: multiplexor.into() }), + | ^^^^ the trait `From` is not implemented for `u16` + | + = help: the following other types implement trait `From`: + `u16` implements `From` + `u16` implements `From` + `u16` implements `From` + = note: required for `i8` to implement `Into` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedTypesS11Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1462:21 + | +1462 | 0 => Ok(ExtendedTypesS11Index::M0(ExtendedTypesS11M0{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedTypesS11Index` + | help: an enum with a similar name exists: `ExtendedTypesS0Index` + +error[E0433]: failed to resolve: use of undeclared type `ExtendedTypesS11Index` + --> tests-snapshots/dbc-cantools/multiplex_2_dumped.snap.rs:1463:21 + | +1463 | 5 => Ok(ExtendedTypesS11Index::M5(ExtendedTypesS11M5{ raw: self.raw })), + | ^^^^^^^^^^^^^^^^^^^^^ + | | + | use of undeclared type `ExtendedTypesS11Index` + | help: an enum with a similar name exists: `ExtendedTypesS0Index` diff --git a/tests-snapshots/dbc-cantools/multiplex_choices.snap b/tests-snapshots/dbc-cantools/multiplex_choices.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_choices.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiplex_choices.snap.rs b/tests-snapshots/dbc-cantools/multiplex_choices.snap.rs new file mode 100644 index 0000000..d93d87c --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_choices.snap.rs @@ -0,0 +1,1657 @@ +// Generated code! +// +// Message definitions from file `multiplex_choices` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), + /// Message2 + Message2(Message2), + /// Message3 + Message3(Message3), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + Message3::MESSAGE_ID => Messages::Message3(Message3::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Extended ID: 1193046 (0x123456) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123456)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message1 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message1MultiplexorIndex::M8(Message1MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message1MultiplexorIndex::M24(Message1MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message1::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message1MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message1MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for BIT_L +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message1BitL { + Off, + On, + _Other(bool), +} + +impl From for bool { + fn from(val: Message1BitL) -> bool { + match val { + Message1BitL::Off => false, + Message1BitL::On => true, + Message1BitL::_Other(x) => x, + } + } +} + +/// Defined values for Multiplexor +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message1Multiplexor { + Multiplexor8, + Multiplexor16, + Multiplexor24, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message1Multiplexor) -> u8 { + match val { + Message1Multiplexor::Multiplexor8 => 8, + Message1Multiplexor::Multiplexor16 => 16, + Message1Multiplexor::Multiplexor24 => 24, + Message1Multiplexor::_Other(x) => x, + } + } +} + +/// Defined values for multiplexed signal Message1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message1MultiplexorIndex { + M8(Message1MultiplexorM8), + M24(Message1MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> Message1BitL { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + match signal { + 0 => Message1BitL::Off, + 1 => Message1BitL::On, + _ => Message1BitL::_Other(self.bit_l_raw()), + } +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + +/// Message2 +/// +/// - Extended ID: 1193047 (0x123457) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123457)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message2 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message2MultiplexorIndex::M8(Message2MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message2MultiplexorIndex::M24(Message2MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message2::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message2MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message2MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Multiplexor +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message2Multiplexor { + Multiplexor4NoSignals, + Multiplexor8, + Multiplexor16, + Multiplexor24, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message2Multiplexor) -> u8 { + match val { + Message2Multiplexor::Multiplexor4NoSignals => 4, + Message2Multiplexor::Multiplexor8 => 8, + Message2Multiplexor::Multiplexor16 => 16, + Message2Multiplexor::Multiplexor24 => 24, + Message2Multiplexor::_Other(x) => x, + } + } +} + +/// Defined values for multiplexed signal Message2 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message2MultiplexorIndex { + M8(Message2MultiplexorM8), + M24(Message2MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message2MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message2MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + +/// Message3 +/// +/// - Extended ID: 1193048 (0x123458) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message3 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123458)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message3 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message3MultiplexorIndex::M8(Message3MultiplexorM8{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message3::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message3::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message3::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message3MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Message3 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message3MultiplexorIndex { + M8(Message3MultiplexorM8), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message3MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message3MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiplex_choices_dumped.snap b/tests-snapshots/dbc-cantools/multiplex_choices_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_choices_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiplex_choices_dumped.snap.rs b/tests-snapshots/dbc-cantools/multiplex_choices_dumped.snap.rs new file mode 100644 index 0000000..e0ffd1b --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_choices_dumped.snap.rs @@ -0,0 +1,1657 @@ +// Generated code! +// +// Message definitions from file `multiplex_choices_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), + /// Message2 + Message2(Message2), + /// Message3 + Message3(Message3), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + Message3::MESSAGE_ID => Messages::Message3(Message3::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Extended ID: 1193046 (0x123456) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123456)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message1 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message1MultiplexorIndex::M8(Message1MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message1MultiplexorIndex::M24(Message1MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message1::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message1MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message1MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for BIT_L +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message1BitL { + Off, + On, + _Other(bool), +} + +impl From for bool { + fn from(val: Message1BitL) -> bool { + match val { + Message1BitL::Off => false, + Message1BitL::On => true, + Message1BitL::_Other(x) => x, + } + } +} + +/// Defined values for Multiplexor +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message1Multiplexor { + Multiplexor8, + Multiplexor16, + Multiplexor24, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message1Multiplexor) -> u8 { + match val { + Message1Multiplexor::Multiplexor8 => 8, + Message1Multiplexor::Multiplexor16 => 16, + Message1Multiplexor::Multiplexor24 => 24, + Message1Multiplexor::_Other(x) => x, + } + } +} + +/// Defined values for multiplexed signal Message1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message1MultiplexorIndex { + M8(Message1MultiplexorM8), + M24(Message1MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> Message1BitL { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + match signal { + 0 => Message1BitL::Off, + 1 => Message1BitL::On, + _ => Message1BitL::_Other(self.bit_l_raw()), + } +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + +/// Message2 +/// +/// - Extended ID: 1193047 (0x123457) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123457)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message2 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message2MultiplexorIndex::M8(Message2MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message2MultiplexorIndex::M24(Message2MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message2::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message2MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message2MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Multiplexor +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message2Multiplexor { + Multiplexor4NoSignals, + Multiplexor8, + Multiplexor16, + Multiplexor24, + _Other(u8), +} + +impl From for u8 { + fn from(val: Message2Multiplexor) -> u8 { + match val { + Message2Multiplexor::Multiplexor4NoSignals => 4, + Message2Multiplexor::Multiplexor8 => 8, + Message2Multiplexor::Multiplexor16 => 16, + Message2Multiplexor::Multiplexor24 => 24, + Message2Multiplexor::_Other(x) => x, + } + } +} + +/// Defined values for multiplexed signal Message2 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message2MultiplexorIndex { + M8(Message2MultiplexorM8), + M24(Message2MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message2MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message2MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + +/// Message3 +/// +/// - Extended ID: 1193048 (0x123458) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message3 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123458)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message3 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message3MultiplexorIndex::M8(Message3MultiplexorM8{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message3::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message3::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message3::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message3MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Message3 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message3MultiplexorIndex { + M8(Message3MultiplexorM8), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message3MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message3MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/multiplex_dumped.snap b/tests-snapshots/dbc-cantools/multiplex_dumped.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_dumped.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/multiplex_dumped.snap.rs b/tests-snapshots/dbc-cantools/multiplex_dumped.snap.rs new file mode 100644 index 0000000..96737aa --- /dev/null +++ b/tests-snapshots/dbc-cantools/multiplex_dumped.snap.rs @@ -0,0 +1,665 @@ +// Generated code! +// +// Message definitions from file `multiplex_dumped` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Extended ID: 1193046 (0x123456) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x123456)}); + + pub const MULTIPLEXOR_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_MAX: u8 = 0_u8; + + /// Construct new Message1 from values + pub fn new(multiplexor: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_multiplexor(multiplexor)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of Multiplexor + /// + /// - Start bit: 2 + /// - Signal size: 6 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[2..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor(&mut self) -> Result { + match self.multiplexor_raw() { + 8 => Ok(Message1MultiplexorIndex::M8(Message1MultiplexorM8{ raw: self.raw })), + 24 => Ok(Message1MultiplexorIndex::M24(Message1MultiplexorM24{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: Message1::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of Multiplexor + #[inline(always)] + fn set_multiplexor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[2..8].store_le(value); + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m8(&mut self, value: Message1MultiplexorM8) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(8)?; + Ok(()) + } + + /// Set value of Multiplexor + #[inline(always)] + pub fn set_m24(&mut self, value: Message1MultiplexorM24) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor(24)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal Message1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum Message1MultiplexorIndex { + M8(Message1MultiplexorM8), + M24(Message1MultiplexorM24), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM8 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM8 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_L +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_l(&self) -> bool { + self.bit_l_raw() +} + +/// Get raw value of BIT_L +/// +/// - Start bit: 24 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_l_raw(&self) -> bool { + let signal = self.raw.view_bits::()[24..25].load_le::(); + + signal == 1 +} + +/// Set value of BIT_L +#[inline(always)] +pub fn set_bit_l(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[24..25].store_le(value); + Ok(()) +} + +/// BIT_G +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_g(&self) -> bool { + self.bit_g_raw() +} + +/// Get raw value of BIT_G +/// +/// - Start bit: 23 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 +} + +/// Set value of BIT_G +#[inline(always)] +pub fn set_bit_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) +} + +/// BIT_C +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_c(&self) -> bool { + self.bit_c_raw() +} + +/// Get raw value of BIT_C +/// +/// - Start bit: 19 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_c_raw(&self) -> bool { + let signal = self.raw.view_bits::()[19..20].load_le::(); + + signal == 1 +} + +/// Set value of BIT_C +#[inline(always)] +pub fn set_bit_c(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[19..20].store_le(value); + Ok(()) +} + +/// BIT_J +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_j(&self) -> bool { + self.bit_j_raw() +} + +/// Get raw value of BIT_J +/// +/// - Start bit: 18 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_j_raw(&self) -> bool { + let signal = self.raw.view_bits::()[18..19].load_le::(); + + signal == 1 +} + +/// Set value of BIT_J +#[inline(always)] +pub fn set_bit_j(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[18..19].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct Message1MultiplexorM24 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1MultiplexorM24 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// BIT_F +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_f(&self) -> bool { + self.bit_f_raw() +} + +/// Get raw value of BIT_F +/// +/// - Start bit: 39 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_f_raw(&self) -> bool { + let signal = self.raw.view_bits::()[39..40].load_le::(); + + signal == 1 +} + +/// Set value of BIT_F +#[inline(always)] +pub fn set_bit_f(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[39..40].store_le(value); + Ok(()) +} + +/// BIT_H +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_h(&self) -> bool { + self.bit_h_raw() +} + +/// Get raw value of BIT_H +/// +/// - Start bit: 38 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_h_raw(&self) -> bool { + let signal = self.raw.view_bits::()[38..39].load_le::(); + + signal == 1 +} + +/// Set value of BIT_H +#[inline(always)] +pub fn set_bit_h(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[38..39].store_le(value); + Ok(()) +} + +/// BIT_B +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_b(&self) -> bool { + self.bit_b_raw() +} + +/// Get raw value of BIT_B +/// +/// - Start bit: 33 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[33..34].load_le::(); + + signal == 1 +} + +/// Set value of BIT_B +#[inline(always)] +pub fn set_bit_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[33..34].store_le(value); + Ok(()) +} + +/// BIT_D +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_d(&self) -> bool { + self.bit_d_raw() +} + +/// Get raw value of BIT_D +/// +/// - Start bit: 32 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 +} + +/// Set value of BIT_D +#[inline(always)] +pub fn set_bit_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) +} + +/// BIT_E +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_e(&self) -> bool { + self.bit_e_raw() +} + +/// Get raw value of BIT_E +/// +/// - Start bit: 29 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[29..30].load_le::(); + + signal == 1 +} + +/// Set value of BIT_E +#[inline(always)] +pub fn set_bit_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[29..30].store_le(value); + Ok(()) +} + +/// BIT_K +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_k(&self) -> bool { + self.bit_k_raw() +} + +/// Get raw value of BIT_K +/// +/// - Start bit: 28 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_k_raw(&self) -> bool { + let signal = self.raw.view_bits::()[28..29].load_le::(); + + signal == 1 +} + +/// Set value of BIT_K +#[inline(always)] +pub fn set_bit_k(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[28..29].store_le(value); + Ok(()) +} + +/// BIT_A +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn bit_a(&self) -> bool { + self.bit_a_raw() +} + +/// Get raw value of BIT_A +/// +/// - Start bit: 26 +/// - Signal size: 1 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn bit_a_raw(&self) -> bool { + let signal = self.raw.view_bits::()[26..27].load_le::(); + + signal == 1 +} + +/// Set value of BIT_A +#[inline(always)] +pub fn set_bit_a(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[26..27].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/no_sender.snap b/tests-snapshots/dbc-cantools/no_sender.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/no_sender.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/no_sender.snap.rs b/tests-snapshots/dbc-cantools/no_sender.snap.rs new file mode 100644 index 0000000..0fced87 --- /dev/null +++ b/tests-snapshots/dbc-cantools/no_sender.snap.rs @@ -0,0 +1,214 @@ +// Generated code! +// +// Message definitions from file `no_sender` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Foo + Foo(Foo), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Foo::MESSAGE_ID => Messages::Foo(Foo::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Foo +/// +/// - Standard ID: 472 (0x1d8) +/// - Size: 1 bytes +/// +/// No sender message. +#[derive(Clone, Copy)] +pub struct Foo { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foo { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1d8)}); + + pub const SIGNAL_WITHOUT_SENDER_MIN: i8 = 0_i8; + pub const SIGNAL_WITHOUT_SENDER_MAX: i8 = 0_i8; + + /// Construct new Foo from values + pub fn new(signal_without_sender: i8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_signal_without_sender(signal_without_sender)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// signal_without_sender + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal_without_sender(&self) -> i8 { + self.signal_without_sender_raw() + } + + /// Get raw value of signal_without_sender + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal_without_sender_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of signal_without_sender + #[inline(always)] + pub fn set_signal_without_sender(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foo { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foo { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/no_signals.snap b/tests-snapshots/dbc-cantools/no_signals.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/no_signals.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/no_signals.snap.rs b/tests-snapshots/dbc-cantools/no_signals.snap.rs new file mode 100644 index 0000000..163d81f --- /dev/null +++ b/tests-snapshots/dbc-cantools/no_signals.snap.rs @@ -0,0 +1,254 @@ +// Generated code! +// +// Message definitions from file `no_signals` +// Version: HIPBNYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY/4/%%%/4/'%**4YYY/// + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), + /// Message2 + Message2(Message2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + Message2::MESSAGE_ID => Messages::Message2(Message2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Standard ID: 1024 (0x400) +/// - Size: 5 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 5], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x400)}); + + + /// Construct new Message1 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 5] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 5] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 5 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 5]; + raw.copy_from_slice(&payload[..5]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message2 +/// +/// - Standard ID: 1025 (0x401) +/// - Size: 0 bytes +/// - Transmitter: TestNode +#[derive(Clone, Copy)] +pub struct Message2 { + raw: [u8; 0], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x401)}); + + + /// Construct new Message2 from values + pub fn new() -> Result { + let res = Self { raw: [0u8; 0] }; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 0] { + &self.raw + } + +} + +impl core::convert::TryFrom<&[u8]> for Message2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 0 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 0]; + raw.copy_from_slice(&payload[..0]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/open_actuator.snap b/tests-snapshots/dbc-cantools/open_actuator.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/open_actuator.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/open_actuator.snap.rs b/tests-snapshots/dbc-cantools/open_actuator.snap.rs new file mode 100644 index 0000000..4a4d681 --- /dev/null +++ b/tests-snapshots/dbc-cantools/open_actuator.snap.rs @@ -0,0 +1,1525 @@ +// Generated code! +// +// Message definitions from file `open_actuator` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// ControlCmd + ControlCmd(ControlCmd), + /// LimitsCmd + LimitsCmd(LimitsCmd), + /// ControlStatus + ControlStatus(ControlStatus), + /// SystemStatus + SystemStatus(SystemStatus), + /// TorqueSensorData + TorqueSensorData(TorqueSensorData), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + ControlCmd::MESSAGE_ID => Messages::ControlCmd(ControlCmd::try_from(payload)?), + LimitsCmd::MESSAGE_ID => Messages::LimitsCmd(LimitsCmd::try_from(payload)?), + ControlStatus::MESSAGE_ID => Messages::ControlStatus(ControlStatus::try_from(payload)?), + SystemStatus::MESSAGE_ID => Messages::SystemStatus(SystemStatus::try_from(payload)?), + TorqueSensorData::MESSAGE_ID => Messages::TorqueSensorData(TorqueSensorData::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// ControlCmd +/// +/// - Standard ID: 250 (0xfa) +/// - Size: 7 bytes +/// - Transmitter: Driver +#[derive(Clone, Copy)] +pub struct ControlCmd { + raw: [u8; 7], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ControlCmd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xfa)}); + + pub const CRC8_CMD1_MIN: u8 = 0_u8; + pub const CRC8_CMD1_MAX: u8 = 255_u8; + pub const COUNTER_CMD1_MIN: u8 = 0_u8; + pub const COUNTER_CMD1_MAX: u8 = 15_u8; + pub const TARGET_MOTOR_ID_CMD1_MIN: u8 = 0_u8; + pub const TARGET_MOTOR_ID_CMD1_MAX: u8 = 3_u8; + pub const TARGET_MODE_MIN: u8 = 0_u8; + pub const TARGET_MODE_MAX: u8 = 3_u8; + pub const POSITION_CMD_64_MIN: f32 = -450_f32; + pub const POSITION_CMD_64_MAX: f32 = 450_f32; + pub const TORQUE_COMMAND_8_MIN: f32 = -8_f32; + pub const TORQUE_COMMAND_8_MAX: f32 = 8_f32; + pub const TORQUE_CLOSE_LOOP_MAX_32_MIN: f32 = 0_f32; + pub const TORQUE_CLOSE_LOOP_MAX_32_MAX: f32 = 8_f32; + + /// Construct new ControlCmd from values + pub fn new(crc8_cmd1: u8, counter_cmd1: u8, target_motor_id_cmd1: u8, target_mode: u8, position_cmd_64: f32, torque_command_8: f32, torque_close_loop_max_32: f32) -> Result { + let mut res = Self { raw: [0u8; 7] }; + res.set_crc8_cmd1(crc8_cmd1)?; + res.set_counter_cmd1(counter_cmd1)?; + res.set_target_motor_id_cmd1(target_motor_id_cmd1)?; + res.set_target_mode(target_mode)?; + res.set_position_cmd_64(position_cmd_64)?; + res.set_torque_command_8(torque_command_8)?; + res.set_torque_close_loop_max_32(torque_close_loop_max_32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 7] { + &self.raw + } + + /// CRC8_CMD1 + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn crc8_cmd1(&self) -> u8 { + self.crc8_cmd1_raw() + } + + /// Get raw value of CRC8_CMD1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn crc8_cmd1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CRC8_CMD1 + #[inline(always)] + pub fn set_crc8_cmd1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Counter_CMD1 + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn counter_cmd1(&self) -> u8 { + self.counter_cmd1_raw() + } + + /// Get raw value of Counter_CMD1 + /// + /// - Start bit: 48 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn counter_cmd1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..52].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Counter_CMD1 + #[inline(always)] + pub fn set_counter_cmd1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..52].store_le(value); + Ok(()) + } + + /// TargetMotorID_CMD1 + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn target_motor_id_cmd1(&self) -> u8 { + self.target_motor_id_cmd1_raw() + } + + /// Get raw value of TargetMotorID_CMD1 + /// + /// - Start bit: 12 + /// - Signal size: 2 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn target_motor_id_cmd1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[12..14].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TargetMotorID_CMD1 + #[inline(always)] + pub fn set_target_motor_id_cmd1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[12..14].store_le(value); + Ok(()) + } + + /// TargetMode + /// + /// - Min: 0 + /// - Max: 3 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn target_mode(&self) -> ControlCmdTargetMode { + let signal = self.raw.view_bits::()[8..11].load_le::(); + + match signal { + 0 => ControlCmdTargetMode::Off, + 1 => ControlCmdTargetMode::Assist, + 2 => ControlCmdTargetMode::PositionRelative, + 3 => ControlCmdTargetMode::Torque, + 4 => ControlCmdTargetMode::PositionAbsolute, + _ => ControlCmdTargetMode::_Other(self.target_mode_raw()), + } + } + + /// Get raw value of TargetMode + /// + /// - Start bit: 8 + /// - Signal size: 3 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn target_mode_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..11].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TargetMode + #[inline(always)] + pub fn set_target_mode(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 3_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..11].store_le(value); + Ok(()) + } + + /// PositionCmd_64 + /// + /// Output relative position. + /// Alternative usage - absolute output position + /// Factor = 64_const / 200steps / 256microsteps *360deg / FinalGearRatio / GearboxRatio + /// + /// - Min: -450 + /// - Max: 450 + /// - Unit: "deg" + /// - Receivers: Actuator + #[inline(always)] + pub fn position_cmd_64(&self) -> f32 { + self.position_cmd_64_raw() + } + + /// Get raw value of PositionCmd_64 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.0154286 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn position_cmd_64_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.0154286_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of PositionCmd_64 + #[inline(always)] + pub fn set_position_cmd_64(&mut self, value: f32) -> Result<(), CanError> { + if value < -450_f32 || 450_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 0.0154286_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// TorqueCommand_8 + /// + /// Factor: + /// 8_const * 1A/1000mA * MotorRatedTorque / MotorRatedCurrent * GearboxRatio * FinalGearRatio + /// + /// - Min: -8 + /// - Max: 8 + /// - Unit: "N*m" + /// - Receivers: Actuator + #[inline(always)] + pub fn torque_command_8(&self) -> f32 { + self.torque_command_8_raw() + } + + /// Get raw value of TorqueCommand_8 + /// + /// - Start bit: 32 + /// - Signal size: 10 bits + /// - Factor: 0.0166667 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn torque_command_8_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..42].load_le::(); + + let factor = 0.0166667_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of TorqueCommand_8 + #[inline(always)] + pub fn set_torque_command_8(&mut self, value: f32) -> Result<(), CanError> { + if value < -8_f32 || 8_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 0.0166667_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..42].store_le(value); + Ok(()) + } + + /// TorqueCloseLoopMax_32 + /// + /// For TorqueCmd > 0 + /// Max positive close loop torque on top of TorqueCmd (outward torque) and below 0 (centering torque). + /// For TorqueCmd < 0; + /// Max negative close loop torque on top of TorqueCmd (outward torque) and above 0 (centering torque). + /// Factor: + /// 32_const * 1A/1000mA * MotorRatedTorque / MotorRatedCurrent * GearboxRatio * FinalGearRatio + /// + /// - Min: 0 + /// - Max: 8 + /// - Unit: "N*m" + /// - Receivers: Actuator + #[inline(always)] + pub fn torque_close_loop_max_32(&self) -> f32 { + self.torque_close_loop_max_32_raw() + } + + /// Get raw value of TorqueCloseLoopMax_32 + /// + /// - Start bit: 42 + /// - Signal size: 6 bits + /// - Factor: 0.186666 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn torque_close_loop_max_32_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[42..48].load_le::(); + + let factor = 0.186666_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of TorqueCloseLoopMax_32 + #[inline(always)] + pub fn set_torque_close_loop_max_32(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 8_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlCmd::MESSAGE_ID }); + } + let factor = 0.186666_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[42..48].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ControlCmd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 7 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 7]; + raw.copy_from_slice(&payload[..7]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ControlCmd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for TargetMode +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum ControlCmdTargetMode { + Off, + Assist, + PositionRelative, + Torque, + PositionAbsolute, + _Other(u8), +} + +impl From for u8 { + fn from(val: ControlCmdTargetMode) -> u8 { + match val { + ControlCmdTargetMode::Off => 0, + ControlCmdTargetMode::Assist => 1, + ControlCmdTargetMode::PositionRelative => 2, + ControlCmdTargetMode::Torque => 3, + ControlCmdTargetMode::PositionAbsolute => 4, + ControlCmdTargetMode::_Other(x) => x, + } + } +} + + +/// LimitsCmd +/// +/// - Standard ID: 251 (0xfb) +/// - Size: 6 bytes +/// - Transmitter: Driver +#[derive(Clone, Copy)] +pub struct LimitsCmd { + raw: [u8; 6], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl LimitsCmd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xfb)}); + + pub const CRC8_CMD2_MIN: u8 = 0_u8; + pub const CRC8_CMD2_MAX: u8 = 255_u8; + pub const COUNTER_CMD2_MIN: u8 = 0_u8; + pub const COUNTER_CMD2_MAX: u8 = 15_u8; + pub const VELOCITY_LIMIT_MIN: u16 = 0_u16; + pub const VELOCITY_LIMIT_MAX: u16 = 0_u16; + pub const ACCEL_LIMIT_MIN: u16 = 0_u16; + pub const ACCEL_LIMIT_MAX: u16 = 0_u16; + + /// Construct new LimitsCmd from values + pub fn new(crc8_cmd2: u8, counter_cmd2: u8, velocity_limit: u16, accel_limit: u16) -> Result { + let mut res = Self { raw: [0u8; 6] }; + res.set_crc8_cmd2(crc8_cmd2)?; + res.set_counter_cmd2(counter_cmd2)?; + res.set_velocity_limit(velocity_limit)?; + res.set_accel_limit(accel_limit)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 6] { + &self.raw + } + + /// CRC8_CMD2 + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn crc8_cmd2(&self) -> u8 { + self.crc8_cmd2_raw() + } + + /// Get raw value of CRC8_CMD2 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn crc8_cmd2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CRC8_CMD2 + #[inline(always)] + pub fn set_crc8_cmd2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Counter_CMD2 + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn counter_cmd2(&self) -> u8 { + self.counter_cmd2_raw() + } + + /// Get raw value of Counter_CMD2 + /// + /// - Start bit: 12 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn counter_cmd2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[12..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Counter_CMD2 + #[inline(always)] + pub fn set_counter_cmd2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[12..16].store_le(value); + Ok(()) + } + + /// VelocityLimit + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn velocity_limit(&self) -> u16 { + self.velocity_limit_raw() + } + + /// Get raw value of VelocityLimit + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn velocity_limit_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of VelocityLimit + #[inline(always)] + pub fn set_velocity_limit(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// AccelLimit + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Actuator + #[inline(always)] + pub fn accel_limit(&self) -> u16 { + self.accel_limit_raw() + } + + /// Get raw value of AccelLimit + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accel_limit_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of AccelLimit + #[inline(always)] + pub fn set_accel_limit(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: LimitsCmd::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for LimitsCmd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 6 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 6]; + raw.copy_from_slice(&payload[..6]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for LimitsCmd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// ControlStatus +/// +/// - Standard ID: 252 (0xfc) +/// - Size: 4 bytes +/// - Transmitter: Actuator +#[derive(Clone, Copy)] +pub struct ControlStatus { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl ControlStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xfc)}); + + pub const CRC8_STAT1_MIN: u8 = 0_u8; + pub const CRC8_STAT1_MAX: u8 = 255_u8; + pub const COUNTER_STAT1_MIN: u8 = 0_u8; + pub const COUNTER_STAT1_MAX: u8 = 15_u8; + pub const TORQUE_ACTUAL_MIN: f32 = -8_f32; + pub const TORQUE_ACTUAL_MAX: f32 = 8_f32; + pub const TORQUE_CLOSE_LOOP_ACTUAL_MIN: f32 = 0_f32; + pub const TORQUE_CLOSE_LOOP_ACTUAL_MAX: f32 = 8_f32; + + /// Construct new ControlStatus from values + pub fn new(crc8_stat1: u8, counter_stat1: u8, torque_actual: f32, torque_close_loop_actual: f32) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_crc8_stat1(crc8_stat1)?; + res.set_counter_stat1(counter_stat1)?; + res.set_torque_actual(torque_actual)?; + res.set_torque_close_loop_actual(torque_close_loop_actual)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// CRC8_STAT1 + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Driver, Actuator + #[inline(always)] + pub fn crc8_stat1(&self) -> u8 { + self.crc8_stat1_raw() + } + + /// Get raw value of CRC8_STAT1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn crc8_stat1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CRC8_STAT1 + #[inline(always)] + pub fn set_crc8_stat1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ControlStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Counter_STAT1 + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Driver + #[inline(always)] + pub fn counter_stat1(&self) -> u8 { + self.counter_stat1_raw() + } + + /// Get raw value of Counter_STAT1 + /// + /// - Start bit: 12 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn counter_stat1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[12..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Counter_STAT1 + #[inline(always)] + pub fn set_counter_stat1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: ControlStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[12..16].store_le(value); + Ok(()) + } + + /// TorqueActual + /// + /// - Min: -8 + /// - Max: 8 + /// - Unit: "N*m" + /// - Receivers: Driver + #[inline(always)] + pub fn torque_actual(&self) -> f32 { + self.torque_actual_raw() + } + + /// Get raw value of TorqueActual + /// + /// - Start bit: 16 + /// - Signal size: 10 bits + /// - Factor: 0.015625 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn torque_actual_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..26].load_le::(); + + let factor = 0.015625_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of TorqueActual + #[inline(always)] + pub fn set_torque_actual(&mut self, value: f32) -> Result<(), CanError> { + if value < -8_f32 || 8_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlStatus::MESSAGE_ID }); + } + let factor = 0.015625_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..26].store_le(value); + Ok(()) + } + + /// TorqueCloseLoopActual + /// + /// - Min: 0 + /// - Max: 8 + /// - Unit: "N*m" + /// - Receivers: Driver + #[inline(always)] + pub fn torque_close_loop_actual(&self) -> f32 { + self.torque_close_loop_actual_raw() + } + + /// Get raw value of TorqueCloseLoopActual + /// + /// - Start bit: 26 + /// - Signal size: 6 bits + /// - Factor: 0.125 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn torque_close_loop_actual_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[26..32].load_le::(); + + let factor = 0.125_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of TorqueCloseLoopActual + #[inline(always)] + pub fn set_torque_close_loop_actual(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 8_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: ControlStatus::MESSAGE_ID }); + } + let factor = 0.125_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[26..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for ControlStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for ControlStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SystemStatus +/// +/// - Standard ID: 253 (0xfd) +/// - Size: 3 bytes +/// - Transmitter: Actuator +#[derive(Clone, Copy)] +pub struct SystemStatus { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SystemStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xfd)}); + + pub const CRC8_STAT2_MIN: u8 = 0_u8; + pub const CRC8_STAT2_MAX: u8 = 255_u8; + pub const COUNTER_STAT2_MIN: u8 = 0_u8; + pub const COUNTER_STAT2_MAX: u8 = 15_u8; + pub const CHIP_TEMP_MIN: i16 = -60_i16; + pub const CHIP_TEMP_MAX: i16 = 195_i16; + + /// Construct new SystemStatus from values + pub fn new(crc8_stat2: u8, counter_stat2: u8, chip_temp: i16) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_crc8_stat2(crc8_stat2)?; + res.set_counter_stat2(counter_stat2)?; + res.set_chip_temp(chip_temp)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// CRC8_STAT2 + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Driver + #[inline(always)] + pub fn crc8_stat2(&self) -> u8 { + self.crc8_stat2_raw() + } + + /// Get raw value of CRC8_STAT2 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn crc8_stat2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CRC8_STAT2 + #[inline(always)] + pub fn set_crc8_stat2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SystemStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SystemStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Counter_STAT2 + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Driver + #[inline(always)] + pub fn counter_stat2(&self) -> u8 { + self.counter_stat2_raw() + } + + /// Get raw value of Counter_STAT2 + /// + /// - Start bit: 12 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn counter_stat2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[12..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Counter_STAT2 + #[inline(always)] + pub fn set_counter_stat2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SystemStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SystemStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[12..16].store_le(value); + Ok(()) + } + + /// ChipTemp + /// + /// - Min: -60 + /// - Max: 195 + /// - Unit: "C" + /// - Receivers: Driver + #[inline(always)] + pub fn chip_temp(&self) -> i16 { + self.chip_temp_raw() + } + + /// Get raw value of ChipTemp + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: -60 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn chip_temp_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + i16::from(signal).saturating_mul(factor).saturating_sub(60) + } + + /// Set value of ChipTemp + #[inline(always)] + pub fn set_chip_temp(&mut self, value: i16) -> Result<(), CanError> { + if value < -60_i16 || 195_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: SystemStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(60) + .ok_or(CanError::ParameterOutOfRange { message_id: SystemStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SystemStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SystemStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TorqueSensorData +/// +/// - Standard ID: 113 (0x71) +/// - Size: 3 bytes +/// - Transmitter: Sensor +#[derive(Clone, Copy)] +pub struct TorqueSensorData { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TorqueSensorData { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x71)}); + + pub const CRC8_DATA1_MIN: u8 = 0_u8; + pub const CRC8_DATA1_MAX: u8 = 255_u8; + pub const COUNTER_DATA1_MIN: u8 = 0_u8; + pub const COUNTER_DATA1_MAX: u8 = 15_u8; + pub const TORQUE_SENSE_MIN: f32 = -20_f32; + pub const TORQUE_SENSE_MAX: f32 = 20_f32; + + /// Construct new TorqueSensorData from values + pub fn new(crc8_data1: u8, counter_data1: u8, torque_sense: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_crc8_data1(crc8_data1)?; + res.set_counter_data1(counter_data1)?; + res.set_torque_sense(torque_sense)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// CRC8_DATA1 + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Driver + #[inline(always)] + pub fn crc8_data1(&self) -> u8 { + self.crc8_data1_raw() + } + + /// Get raw value of CRC8_DATA1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn crc8_data1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of CRC8_DATA1 + #[inline(always)] + pub fn set_crc8_data1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TorqueSensorData::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TorqueSensorData::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Counter_DATA1 + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: Driver + #[inline(always)] + pub fn counter_data1(&self) -> u8 { + self.counter_data1_raw() + } + + /// Get raw value of Counter_DATA1 + /// + /// - Start bit: 8 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn counter_data1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..12].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Counter_DATA1 + #[inline(always)] + pub fn set_counter_data1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TorqueSensorData::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TorqueSensorData::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..12].store_le(value); + Ok(()) + } + + /// TorqueSense + /// + /// Strain gauge torque measured + /// + /// - Min: -20 + /// - Max: 20 + /// - Unit: "N*m" + /// - Receivers: Driver + #[inline(always)] + pub fn torque_sense(&self) -> f32 { + self.torque_sense_raw() + } + + /// Get raw value of TorqueSense + /// + /// - Start bit: 12 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn torque_sense_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[12..24].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of TorqueSense + #[inline(always)] + pub fn set_torque_sense(&mut self, value: f32) -> Result<(), CanError> { + if value < -20_f32 || 20_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: TorqueSensorData::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[12..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TorqueSensorData { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TorqueSensorData { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/padding_bit_order.snap b/tests-snapshots/dbc-cantools/padding_bit_order.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/padding_bit_order.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/padding_bit_order.snap.rs b/tests-snapshots/dbc-cantools/padding_bit_order.snap.rs new file mode 100644 index 0000000..a930d2c --- /dev/null +++ b/tests-snapshots/dbc-cantools/padding_bit_order.snap.rs @@ -0,0 +1,1063 @@ +// Generated code! +// +// Message definitions from file `padding_bit_order` +// Version: VER + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// MSG0 + Msg0(Msg0), + /// MSG1 + Msg1(Msg1), + /// MSG2 + Msg2(Msg2), + /// MSG3 + Msg3(Msg3), + /// MSG4 + Msg4(Msg4), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Msg0::MESSAGE_ID => Messages::Msg0(Msg0::try_from(payload)?), + Msg1::MESSAGE_ID => Messages::Msg1(Msg1::try_from(payload)?), + Msg2::MESSAGE_ID => Messages::Msg2(Msg2::try_from(payload)?), + Msg3::MESSAGE_ID => Messages::Msg3(Msg3::try_from(payload)?), + Msg4::MESSAGE_ID => Messages::Msg4(Msg4::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// MSG0 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +/// - Transmitter: E1 +#[derive(Clone, Copy)] +pub struct Msg0 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg0 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const A_MIN: u16 = 0_u16; + pub const A_MAX: u16 = 32767_u16; + pub const C_MIN: u16 = 0_u16; + pub const C_MAX: u16 = 32767_u16; + + /// Construct new MSG0 from values + pub fn new(a: u16, b: bool, c: u16, d: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_a(a)?; + res.set_b(b)?; + res.set_c(c)?; + res.set_d(d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// A + /// + /// - Min: 0 + /// - Max: 32767 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn a(&self) -> u16 { + self.a_raw() + } + + /// Get raw value of A + /// + /// - Start bit: 6 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn a_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[1..16].load_be::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of A + #[inline(always)] + pub fn set_a(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 32767_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg0::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg0::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[1..16].store_be(value); + Ok(()) + } + + /// B + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn b(&self) -> bool { + self.b_raw() + } + + /// Get raw value of B + /// + /// - Start bit: 7 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn b_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_be::(); + + signal == 1 + } + + /// Set value of B + #[inline(always)] + pub fn set_b(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_be(value); + Ok(()) + } + + /// C + /// + /// - Min: 0 + /// - Max: 32767 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn c(&self) -> u16 { + self.c_raw() + } + + /// Get raw value of C + /// + /// - Start bit: 38 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn c_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[33..48].load_be::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of C + #[inline(always)] + pub fn set_c(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 32767_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg0::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg0::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[33..48].store_be(value); + Ok(()) + } + + /// D + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn d(&self) -> bool { + self.d_raw() + } + + /// Get raw value of D + /// + /// - Start bit: 39 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_be::(); + + signal == 1 + } + + /// Set value of D + #[inline(always)] + pub fn set_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg0 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg0 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MSG1 +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +/// - Transmitter: E1 +#[derive(Clone, Copy)] +pub struct Msg1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const F_MIN: u16 = 0_u16; + pub const F_MAX: u16 = 32767_u16; + pub const H_MIN: u16 = 0_u16; + pub const H_MAX: u16 = 32767_u16; + + /// Construct new MSG1 from values + pub fn new(e: bool, f: u16, g: bool, h: u16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_e(e)?; + res.set_f(f)?; + res.set_g(g)?; + res.set_h(h)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// E + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn e(&self) -> bool { + self.e_raw() + } + + /// Get raw value of E + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of E + #[inline(always)] + pub fn set_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + + /// F + /// + /// - Min: 0 + /// - Max: 32767 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn f(&self) -> u16 { + self.f_raw() + } + + /// Get raw value of F + /// + /// - Start bit: 1 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn f_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[1..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of F + #[inline(always)] + pub fn set_f(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 32767_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[1..16].store_le(value); + Ok(()) + } + + /// G + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn g(&self) -> bool { + self.g_raw() + } + + /// Get raw value of G + /// + /// - Start bit: 32 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn g_raw(&self) -> bool { + let signal = self.raw.view_bits::()[32..33].load_le::(); + + signal == 1 + } + + /// Set value of G + #[inline(always)] + pub fn set_g(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[32..33].store_le(value); + Ok(()) + } + + /// H + /// + /// - Min: 0 + /// - Max: 32767 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn h(&self) -> u16 { + self.h_raw() + } + + /// Get raw value of H + /// + /// - Start bit: 33 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn h_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[33..48].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of H + #[inline(always)] + pub fn set_h(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 32767_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg1::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[33..48].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MSG2 +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +/// - Transmitter: E1 +#[derive(Clone, Copy)] +pub struct Msg2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + pub const I_MIN: u8 = 0_u8; + pub const I_MAX: u8 = 15_u8; + pub const J_MIN: u8 = 0_u8; + pub const J_MAX: u8 = 15_u8; + pub const K_MIN: u8 = 0_u8; + pub const K_MAX: u8 = 15_u8; + + /// Construct new MSG2 from values + pub fn new(i: u8, j: u8, k: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_i(i)?; + res.set_j(j)?; + res.set_k(k)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// I + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn i(&self) -> u8 { + self.i_raw() + } + + /// Get raw value of I + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn i_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of I + #[inline(always)] + pub fn set_i(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// J + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn j(&self) -> u8 { + self.j_raw() + } + + /// Get raw value of J + /// + /// - Start bit: 4 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn j_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of J + #[inline(always)] + pub fn set_j(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) + } + + /// K + /// + /// - Min: 0 + /// - Max: 15 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn k(&self) -> u8 { + self.k_raw() + } + + /// Get raw value of K + /// + /// - Start bit: 8 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn k_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..12].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of K + #[inline(always)] + pub fn set_k(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 15_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..12].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MSG3 +/// +/// - Standard ID: 4 (0x4) +/// - Size: 8 bytes +/// - Transmitter: E1 +#[derive(Clone, Copy)] +pub struct Msg3 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + + pub const L_MIN: u64 = 0_u64; + pub const L_MAX: u64 = 18446744073709552000_u64; + + /// Construct new MSG3 from values + pub fn new(l: u64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_l(l)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// L + /// + /// - Min: 0 + /// - Max: 18446744073709552000 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn l(&self) -> u64 { + self.l_raw() + } + + /// Get raw value of L + /// + /// - Start bit: 7 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn l_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[0..64].load_be::(); + + let factor = 1; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of L + #[inline(always)] + pub fn set_l(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 18446744073709552000_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg3::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg3::MESSAGE_ID })?; + let value = (value / factor) as u64; + + self.raw.view_bits_mut::()[0..64].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MSG4 +/// +/// - Standard ID: 5 (0x5) +/// - Size: 8 bytes +/// - Transmitter: E1 +#[derive(Clone, Copy)] +pub struct Msg4 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Msg4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x5)}); + + pub const M_MIN: u64 = 0_u64; + pub const M_MAX: u64 = 18446744073709552000_u64; + + /// Construct new MSG4 from values + pub fn new(m: u64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_m(m)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// M + /// + /// - Min: 0 + /// - Max: 18446744073709552000 + /// - Unit: "" + /// - Receivers: E1 + #[inline(always)] + pub fn m(&self) -> u64 { + self.m_raw() + } + + /// Get raw value of M + /// + /// - Start bit: 0 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn m_raw(&self) -> u64 { + let signal = self.raw.view_bits::()[0..64].load_le::(); + + let factor = 1; + u64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of M + #[inline(always)] + pub fn set_m(&mut self, value: u64) -> Result<(), CanError> { + if value < 0_u64 || 18446744073709552000_u64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Msg4::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Msg4::MESSAGE_ID })?; + let value = (value / factor) as u64; + + self.raw.view_bits_mut::()[0..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Msg4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Msg4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/padding_bit_order.snap.stderr b/tests-snapshots/dbc-cantools/padding_bit_order.snap.stderr new file mode 100644 index 0000000..4359013 --- /dev/null +++ b/tests-snapshots/dbc-cantools/padding_bit_order.snap.stderr @@ -0,0 +1,32 @@ +error: literal out of range for `u64` + --> tests-snapshots/dbc-cantools/padding_bit_order.snap.rs:796:28 + | +796 | pub const L_MAX: u64 = 18446744073709552000_u64; + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `18446744073709552000_u64` does not fit into the type `u64` whose range is `0..=18446744073709551615` + = note: `#[deny(overflowing_literals)]` on by default + +error: literal out of range for `u64` + --> tests-snapshots/dbc-cantools/padding_bit_order.snap.rs:840:29 + | +840 | if value < 0_u64 || 18446744073709552000_u64 < value { + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `18446744073709552000_u64` does not fit into the type `u64` whose range is `0..=18446744073709551615` + +error: literal out of range for `u64` + --> tests-snapshots/dbc-cantools/padding_bit_order.snap.rs:926:28 + | +926 | pub const M_MAX: u64 = 18446744073709552000_u64; + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `18446744073709552000_u64` does not fit into the type `u64` whose range is `0..=18446744073709551615` + +error: literal out of range for `u64` + --> tests-snapshots/dbc-cantools/padding_bit_order.snap.rs:970:29 + | +970 | if value < 0_u64 || 18446744073709552000_u64 < value { + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `18446744073709552000_u64` does not fit into the type `u64` whose range is `0..=18446744073709551615` diff --git a/tests-snapshots/dbc-cantools/sig_groups.snap b/tests-snapshots/dbc-cantools/sig_groups.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/sig_groups.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/sig_groups.snap.rs b/tests-snapshots/dbc-cantools/sig_groups.snap.rs new file mode 100644 index 0000000..cbca28d --- /dev/null +++ b/tests-snapshots/dbc-cantools/sig_groups.snap.rs @@ -0,0 +1,897 @@ +// Generated code! +// +// Message definitions from file `sig_groups` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Test + Test(Test), + /// SGMsg_m + SgMsgM(SgMsgM), + /// SGMsg + SgMsg(SgMsg), + /// NormalMsg + NormalMsg(NormalMsg), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Test::MESSAGE_ID => Messages::Test(Test::try_from(payload)?), + SgMsgM::MESSAGE_ID => Messages::SgMsgM(SgMsgM::try_from(payload)?), + SgMsg::MESSAGE_ID => Messages::SgMsg(SgMsg::try_from(payload)?), + NormalMsg::MESSAGE_ID => Messages::NormalMsg(NormalMsg::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Test +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +/// - Transmitter: Tester +#[derive(Clone, Copy)] +pub struct Test { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Test { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + pub const TEST_SIG_MIN: i8 = 0_i8; + pub const TEST_SIG_MAX: i8 = 0_i8; + + /// Construct new Test from values + pub fn new(test_sig: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig(test_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Tester + #[inline(always)] + pub fn test_sig(&self) -> i8 { + self.test_sig_raw() + } + + /// Get raw value of TestSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig + #[inline(always)] + pub fn set_test_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Test::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Test::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Test { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Test { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SGMsg_m +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsgM { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsgM { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SUB_SIG2_1_MIN: i8 = 0_i8; + pub const SUB_SIG2_1_MAX: i8 = 0_i8; + pub const SUB_SIG1_2_MIN: i8 = 0_i8; + pub const SUB_SIG1_2_MAX: i8 = 0_i8; + pub const SUB_SIG1_1_MIN: i8 = 0_i8; + pub const SUB_SIG1_1_MAX: i8 = 0_i8; + + /// Construct new SGMsg_m from values + pub fn new(dupsig: i8, sub_sig2_1: i8, sub_sig1_2: i8, sub_sig1_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sub_sig2_1(sub_sig2_1)?; + res.set_sub_sig1_2(sub_sig1_2)?; + res.set_sub_sig1_1(sub_sig1_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// subSig2_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig2_1(&self) -> i8 { + self.sub_sig2_1_raw() + } + + /// Get raw value of subSig2_1 + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig2_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig2_1 + #[inline(always)] + pub fn set_sub_sig2_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// subSig1_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig1_2(&self) -> i8 { + self.sub_sig1_2_raw() + } + + /// Get raw value of subSig1_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig1_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig1_2 + #[inline(always)] + pub fn set_sub_sig1_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// subSig1_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig1_1(&self) -> i8 { + self.sub_sig1_1_raw() + } + + /// Get raw value of subSig1_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig1_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig1_1 + #[inline(always)] + pub fn set_sub_sig1_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsgM { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsgM { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SGMsg +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SG2_MIN: i8 = 0_i8; + pub const SG2_MAX: i8 = 0_i8; + pub const SG1_MIN: i8 = 0_i8; + pub const SG1_MAX: i8 = 0_i8; + + /// Construct new SGMsg from values + pub fn new(dupsig: i8, sg2: i8, sg1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sg2(sg2)?; + res.set_sg1(sg1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// SG2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg2(&self) -> i8 { + self.sg2_raw() + } + + /// Get raw value of SG2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG2 + #[inline(always)] + pub fn set_sg2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// SG1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg1(&self) -> i8 { + self.sg1_raw() + } + + /// Get raw value of SG1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG1 + #[inline(always)] + pub fn set_sg1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// NormalMsg +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct NormalMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const SIG_2_MIN: i8 = 0_i8; + pub const SIG_2_MAX: i8 = 0_i8; + pub const SIG_1_MIN: i8 = 0_i8; + pub const SIG_1_MAX: i8 = 0_i8; + + /// Construct new NormalMsg from values + pub fn new(sig_2: i8, sig_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_2(sig_2)?; + res.set_sig_1(sig_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_2(&self) -> i8 { + self.sig_2_raw() + } + + /// Get raw value of Sig_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_2 + #[inline(always)] + pub fn set_sig_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_1(&self) -> i8 { + self.sig_1_raw() + } + + /// Get raw value of Sig_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_1 + #[inline(always)] + pub fn set_sig_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for NormalMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for NormalMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/sig_groups_del.snap b/tests-snapshots/dbc-cantools/sig_groups_del.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/sig_groups_del.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/sig_groups_del.snap.rs b/tests-snapshots/dbc-cantools/sig_groups_del.snap.rs new file mode 100644 index 0000000..9e659da --- /dev/null +++ b/tests-snapshots/dbc-cantools/sig_groups_del.snap.rs @@ -0,0 +1,897 @@ +// Generated code! +// +// Message definitions from file `sig_groups_del` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Test + Test(Test), + /// SGMsg_m + SgMsgM(SgMsgM), + /// SGMsg + SgMsg(SgMsg), + /// NormalMsg + NormalMsg(NormalMsg), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Test::MESSAGE_ID => Messages::Test(Test::try_from(payload)?), + SgMsgM::MESSAGE_ID => Messages::SgMsgM(SgMsgM::try_from(payload)?), + SgMsg::MESSAGE_ID => Messages::SgMsg(SgMsg::try_from(payload)?), + NormalMsg::MESSAGE_ID => Messages::NormalMsg(NormalMsg::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Test +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +/// - Transmitter: Tester +#[derive(Clone, Copy)] +pub struct Test { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Test { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + pub const TEST_SIG_MIN: i8 = 0_i8; + pub const TEST_SIG_MAX: i8 = 0_i8; + + /// Construct new Test from values + pub fn new(test_sig: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig(test_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Tester + #[inline(always)] + pub fn test_sig(&self) -> i8 { + self.test_sig_raw() + } + + /// Get raw value of TestSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig + #[inline(always)] + pub fn set_test_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Test::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Test::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Test { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Test { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SGMsg_m +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsgM { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsgM { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SUB_SIG2_1_MIN: i8 = 0_i8; + pub const SUB_SIG2_1_MAX: i8 = 0_i8; + pub const SUB_SIG1_2_MIN: i8 = 0_i8; + pub const SUB_SIG1_2_MAX: i8 = 0_i8; + pub const SUB_SIG1_1_MIN: i8 = 0_i8; + pub const SUB_SIG1_1_MAX: i8 = 0_i8; + + /// Construct new SGMsg_m from values + pub fn new(dupsig: i8, sub_sig2_1: i8, sub_sig1_2: i8, sub_sig1_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sub_sig2_1(sub_sig2_1)?; + res.set_sub_sig1_2(sub_sig1_2)?; + res.set_sub_sig1_1(sub_sig1_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// subSig2_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig2_1(&self) -> i8 { + self.sub_sig2_1_raw() + } + + /// Get raw value of subSig2_1 + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig2_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig2_1 + #[inline(always)] + pub fn set_sub_sig2_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// subSig1_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig1_2(&self) -> i8 { + self.sub_sig1_2_raw() + } + + /// Get raw value of subSig1_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig1_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig1_2 + #[inline(always)] + pub fn set_sub_sig1_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// subSig1_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig1_1(&self) -> i8 { + self.sub_sig1_1_raw() + } + + /// Get raw value of subSig1_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig1_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig1_1 + #[inline(always)] + pub fn set_sub_sig1_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsgM { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsgM { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SGMsg +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SG2_MIN: i8 = 0_i8; + pub const SG2_MAX: i8 = 0_i8; + pub const SG1_MIN: i8 = 0_i8; + pub const SG1_MAX: i8 = 0_i8; + + /// Construct new SGMsg from values + pub fn new(dupsig: i8, sg2: i8, sg1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sg2(sg2)?; + res.set_sg1(sg1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// SG2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg2(&self) -> i8 { + self.sg2_raw() + } + + /// Get raw value of SG2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG2 + #[inline(always)] + pub fn set_sg2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// SG1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg1(&self) -> i8 { + self.sg1_raw() + } + + /// Get raw value of SG1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG1 + #[inline(always)] + pub fn set_sg1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// NormalMsg +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct NormalMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const SIG_2_MIN: i8 = 0_i8; + pub const SIG_2_MAX: i8 = 0_i8; + pub const SIG_1_MIN: i8 = 0_i8; + pub const SIG_1_MAX: i8 = 0_i8; + + /// Construct new NormalMsg from values + pub fn new(sig_2: i8, sig_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_2(sig_2)?; + res.set_sig_1(sig_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_2(&self) -> i8 { + self.sig_2_raw() + } + + /// Get raw value of Sig_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_2 + #[inline(always)] + pub fn set_sig_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_1(&self) -> i8 { + self.sig_1_raw() + } + + /// Get raw value of Sig_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_1 + #[inline(always)] + pub fn set_sig_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for NormalMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for NormalMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/sig_groups_out.snap b/tests-snapshots/dbc-cantools/sig_groups_out.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/sig_groups_out.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/sig_groups_out.snap.rs b/tests-snapshots/dbc-cantools/sig_groups_out.snap.rs new file mode 100644 index 0000000..0985098 --- /dev/null +++ b/tests-snapshots/dbc-cantools/sig_groups_out.snap.rs @@ -0,0 +1,897 @@ +// Generated code! +// +// Message definitions from file `sig_groups_out` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Test + Test(Test), + /// SGMsg_m + SgMsgM(SgMsgM), + /// SGMsg + SgMsg(SgMsg), + /// NormalMsg + NormalMsg(NormalMsg), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Test::MESSAGE_ID => Messages::Test(Test::try_from(payload)?), + SgMsgM::MESSAGE_ID => Messages::SgMsgM(SgMsgM::try_from(payload)?), + SgMsg::MESSAGE_ID => Messages::SgMsg(SgMsg::try_from(payload)?), + NormalMsg::MESSAGE_ID => Messages::NormalMsg(NormalMsg::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Test +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +/// - Transmitter: Tester +#[derive(Clone, Copy)] +pub struct Test { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Test { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + pub const TEST_SIG_MIN: i8 = 0_i8; + pub const TEST_SIG_MAX: i8 = 0_i8; + + /// Construct new Test from values + pub fn new(test_sig: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_test_sig(test_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// TestSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Tester + #[inline(always)] + pub fn test_sig(&self) -> i8 { + self.test_sig_raw() + } + + /// Get raw value of TestSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn test_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of TestSig + #[inline(always)] + pub fn set_test_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Test::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Test::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Test { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Test { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SGMsg_m +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsgM { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsgM { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SUB_SIG2_1_MIN: i8 = 0_i8; + pub const SUB_SIG2_1_MAX: i8 = 0_i8; + pub const SUB_SIG1_2_MIN: i8 = 0_i8; + pub const SUB_SIG1_2_MAX: i8 = 0_i8; + pub const SUB_SIG1_1_MIN: i8 = 0_i8; + pub const SUB_SIG1_1_MAX: i8 = 0_i8; + + /// Construct new SGMsg_m from values + pub fn new(dupsig: i8, sub_sig2_1: i8, sub_sig1_2: i8, sub_sig1_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sub_sig2_1(sub_sig2_1)?; + res.set_sub_sig1_2(sub_sig1_2)?; + res.set_sub_sig1_1(sub_sig1_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// subSig2_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig2_1(&self) -> i8 { + self.sub_sig2_1_raw() + } + + /// Get raw value of subSig2_1 + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig2_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig2_1 + #[inline(always)] + pub fn set_sub_sig2_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// subSig1_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig1_2(&self) -> i8 { + self.sub_sig1_2_raw() + } + + /// Get raw value of subSig1_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig1_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig1_2 + #[inline(always)] + pub fn set_sub_sig1_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// subSig1_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sub_sig1_1(&self) -> i8 { + self.sub_sig1_1_raw() + } + + /// Get raw value of subSig1_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sub_sig1_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of subSig1_1 + #[inline(always)] + pub fn set_sub_sig1_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsgM::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsgM { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsgM { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SGMsg +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SgMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SgMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const DUPSIG_MIN: i8 = 0_i8; + pub const DUPSIG_MAX: i8 = 0_i8; + pub const SG2_MIN: i8 = 0_i8; + pub const SG2_MAX: i8 = 0_i8; + pub const SG1_MIN: i8 = 0_i8; + pub const SG1_MAX: i8 = 0_i8; + + /// Construct new SGMsg from values + pub fn new(dupsig: i8, sg2: i8, sg1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_dupsig(dupsig)?; + res.set_sg2(sg2)?; + res.set_sg1(sg1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// dupsig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn dupsig(&self) -> i8 { + self.dupsig_raw() + } + + /// Get raw value of dupsig + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn dupsig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of dupsig + #[inline(always)] + pub fn set_dupsig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// SG2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg2(&self) -> i8 { + self.sg2_raw() + } + + /// Get raw value of SG2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG2 + #[inline(always)] + pub fn set_sg2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// SG1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sg1(&self) -> i8 { + self.sg1_raw() + } + + /// Get raw value of SG1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sg1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SG1 + #[inline(always)] + pub fn set_sg1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SgMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SgMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SgMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// NormalMsg +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct NormalMsg { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl NormalMsg { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const SIG_2_MIN: i8 = 0_i8; + pub const SIG_2_MAX: i8 = 0_i8; + pub const SIG_1_MIN: i8 = 0_i8; + pub const SIG_1_MAX: i8 = 0_i8; + + /// Construct new NormalMsg from values + pub fn new(sig_2: i8, sig_1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sig_2(sig_2)?; + res.set_sig_1(sig_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Sig_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_2(&self) -> i8 { + self.sig_2_raw() + } + + /// Get raw value of Sig_2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_2_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_2 + #[inline(always)] + pub fn set_sig_2(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Sig_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn sig_1(&self) -> i8 { + self.sig_1_raw() + } + + /// Get raw value of Sig_1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn sig_1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Sig_1 + #[inline(always)] + pub fn set_sig_1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: NormalMsg::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for NormalMsg { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for NormalMsg { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/signed.snap b/tests-snapshots/dbc-cantools/signed.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/signed.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/signed.snap.rs b/tests-snapshots/dbc-cantools/signed.snap.rs new file mode 100644 index 0000000..7c4a380 --- /dev/null +++ b/tests-snapshots/dbc-cantools/signed.snap.rs @@ -0,0 +1,1881 @@ +// Generated code! +// +// Message definitions from file `signed` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message378910 + Message378910(Message378910), + /// Message63big_1 + Message63big1(Message63big1), + /// Message63_1 + Message631(Message631), + /// Message63big + Message63big(Message63big), + /// Message63 + Message63(Message63), + /// Message32big + Message32big(Message32big), + /// Message33big + Message33big(Message33big), + /// Message64big + Message64big(Message64big), + /// Message64 + Message64(Message64), + /// Message33 + Message33(Message33), + /// Message32 + Message32(Message32), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message378910::MESSAGE_ID => Messages::Message378910(Message378910::try_from(payload)?), + Message63big1::MESSAGE_ID => Messages::Message63big1(Message63big1::try_from(payload)?), + Message631::MESSAGE_ID => Messages::Message631(Message631::try_from(payload)?), + Message63big::MESSAGE_ID => Messages::Message63big(Message63big::try_from(payload)?), + Message63::MESSAGE_ID => Messages::Message63(Message63::try_from(payload)?), + Message32big::MESSAGE_ID => Messages::Message32big(Message32big::try_from(payload)?), + Message33big::MESSAGE_ID => Messages::Message33big(Message33big::try_from(payload)?), + Message64big::MESSAGE_ID => Messages::Message64big(Message64big::try_from(payload)?), + Message64::MESSAGE_ID => Messages::Message64(Message64::try_from(payload)?), + Message33::MESSAGE_ID => Messages::Message33(Message33::try_from(payload)?), + Message32::MESSAGE_ID => Messages::Message32(Message32::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message378910 +/// +/// - Standard ID: 10 (0xa) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message378910 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message378910 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xa)}); + + pub const S3BIG_MIN: i8 = 0_i8; + pub const S3BIG_MAX: i8 = 0_i8; + pub const S3_MIN: i8 = 0_i8; + pub const S3_MAX: i8 = 0_i8; + pub const S10BIG_MIN: i16 = 0_i16; + pub const S10BIG_MAX: i16 = 0_i16; + pub const S8BIG_MIN: i8 = 0_i8; + pub const S8BIG_MAX: i8 = 0_i8; + pub const S7BIG_MIN: i8 = 0_i8; + pub const S7BIG_MAX: i8 = 0_i8; + pub const S9_MIN: i16 = 0_i16; + pub const S9_MAX: i16 = 0_i16; + pub const S8_MIN: i8 = 0_i8; + pub const S8_MAX: i8 = 0_i8; + pub const S7_MIN: i8 = 0_i8; + pub const S7_MAX: i8 = 0_i8; + + /// Construct new Message378910 from values + pub fn new(s3big: i8, s3: i8, s10big: i16, s8big: i8, s7big: i8, s9: i16, s8: i8, s7: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s3big(s3big)?; + res.set_s3(s3)?; + res.set_s10big(s10big)?; + res.set_s8big(s8big)?; + res.set_s7big(s7big)?; + res.set_s9(s9)?; + res.set_s8(s8)?; + res.set_s7(s7)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s3big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s3big(&self) -> i8 { + self.s3big_raw() + } + + /// Get raw value of s3big + /// + /// - Start bit: 39 + /// - Signal size: 3 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s3big_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[32..35].load_be::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s3big + #[inline(always)] + pub fn set_s3big(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..35].store_be(value); + Ok(()) + } + + /// s3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s3(&self) -> i8 { + self.s3_raw() + } + + /// Get raw value of s3 + /// + /// - Start bit: 34 + /// - Signal size: 3 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s3_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[34..37].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s3 + #[inline(always)] + pub fn set_s3(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[34..37].store_le(value); + Ok(()) + } + + /// s10big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s10big(&self) -> i16 { + self.s10big_raw() + } + + /// Get raw value of s10big + /// + /// - Start bit: 40 + /// - Signal size: 10 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s10big_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[47..57].load_be::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s10big + #[inline(always)] + pub fn set_s10big(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 0_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[47..57].store_be(value); + Ok(()) + } + + /// s8big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s8big(&self) -> i8 { + self.s8big_raw() + } + + /// Get raw value of s8big + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s8big_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[7..15].load_be::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s8big + #[inline(always)] + pub fn set_s8big(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..15].store_be(value); + Ok(()) + } + + /// s7big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s7big(&self) -> i8 { + self.s7big_raw() + } + + /// Get raw value of s7big + /// + /// - Start bit: 62 + /// - Signal size: 7 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s7big_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[57..64].load_be::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s7big + #[inline(always)] + pub fn set_s7big(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[57..64].store_be(value); + Ok(()) + } + + /// s9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s9(&self) -> i16 { + self.s9_raw() + } + + /// Get raw value of s9 + /// + /// - Start bit: 17 + /// - Signal size: 9 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s9_raw(&self) -> i16 { + let signal = self.raw.view_bits::()[17..26].load_le::(); + + let factor = 1; + let signal = signal as i16; + i16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s9 + #[inline(always)] + pub fn set_s9(&mut self, value: i16) -> Result<(), CanError> { + if value < 0_i16 || 0_i16 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[17..26].store_le(value); + Ok(()) + } + + /// s8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s8(&self) -> i8 { + self.s8_raw() + } + + /// Get raw value of s8 + /// + /// - Start bit: 26 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s8_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[26..34].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s8 + #[inline(always)] + pub fn set_s8(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[26..34].store_le(value); + Ok(()) + } + + /// s7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s7(&self) -> i8 { + self.s7_raw() + } + + /// Get raw value of s7 + /// + /// - Start bit: 1 + /// - Signal size: 7 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s7_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[1..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s7 + #[inline(always)] + pub fn set_s7(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message378910::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[1..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message378910 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message378910 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message63big_1 +/// +/// - Standard ID: 9 (0x9) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message63big1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message63big1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x9)}); + + pub const S63BIG_MIN: i64 = 0_i64; + pub const S63BIG_MAX: i64 = 0_i64; + + /// Construct new Message63big_1 from values + pub fn new(s63big: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s63big(s63big)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s63big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s63big(&self) -> i64 { + self.s63big_raw() + } + + /// Get raw value of s63big + /// + /// - Start bit: 6 + /// - Signal size: 63 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s63big_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[1..64].load_be::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s63big + #[inline(always)] + pub fn set_s63big(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message63big1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message63big1::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[1..64].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message63big1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message63big1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message63_1 +/// +/// - Standard ID: 8 (0x8) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message631 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message631 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x8)}); + + pub const S63_MIN: i64 = 0_i64; + pub const S63_MAX: i64 = 0_i64; + + /// Construct new Message63_1 from values + pub fn new(s63: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s63(s63)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s63 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s63(&self) -> i64 { + self.s63_raw() + } + + /// Get raw value of s63 + /// + /// - Start bit: 1 + /// - Signal size: 63 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s63_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[1..64].load_le::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s63 + #[inline(always)] + pub fn set_s63(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message631::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message631::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[1..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message631 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message631 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message63big +/// +/// - Standard ID: 7 (0x7) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message63big { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message63big { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x7)}); + + pub const S63BIG_MIN: i64 = 0_i64; + pub const S63BIG_MAX: i64 = 0_i64; + + /// Construct new Message63big from values + pub fn new(s63big: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s63big(s63big)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s63big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s63big(&self) -> i64 { + self.s63big_raw() + } + + /// Get raw value of s63big + /// + /// - Start bit: 7 + /// - Signal size: 63 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s63big_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..63].load_be::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s63big + #[inline(always)] + pub fn set_s63big(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message63big::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message63big::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..63].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message63big { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message63big { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message63 +/// +/// - Standard ID: 6 (0x6) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message63 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message63 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x6)}); + + pub const S63_MIN: i64 = 0_i64; + pub const S63_MAX: i64 = 0_i64; + + /// Construct new Message63 from values + pub fn new(s63: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s63(s63)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s63 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s63(&self) -> i64 { + self.s63_raw() + } + + /// Get raw value of s63 + /// + /// - Start bit: 0 + /// - Signal size: 63 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s63_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..63].load_le::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s63 + #[inline(always)] + pub fn set_s63(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message63::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message63::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..63].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message63 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message63 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message32big +/// +/// - Standard ID: 5 (0x5) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message32big { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message32big { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x5)}); + + pub const S32BIG_MIN: i32 = 0_i32; + pub const S32BIG_MAX: i32 = 0_i32; + + /// Construct new Message32big from values + pub fn new(s32big: i32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s32big(s32big)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s32big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s32big(&self) -> i32 { + self.s32big_raw() + } + + /// Get raw value of s32big + /// + /// - Start bit: 7 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s32big_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_be::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s32big + #[inline(always)] + pub fn set_s32big(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message32big::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message32big::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message32big { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message32big { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message33big +/// +/// - Standard ID: 4 (0x4) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message33big { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message33big { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x4)}); + + pub const S33BIG_MIN: i64 = 0_i64; + pub const S33BIG_MAX: i64 = 0_i64; + + /// Construct new Message33big from values + pub fn new(s33big: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s33big(s33big)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s33big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s33big(&self) -> i64 { + self.s33big_raw() + } + + /// Get raw value of s33big + /// + /// - Start bit: 7 + /// - Signal size: 33 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s33big_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..33].load_be::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s33big + #[inline(always)] + pub fn set_s33big(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message33big::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message33big::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..33].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message33big { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message33big { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message64big +/// +/// - Standard ID: 3 (0x3) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message64big { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message64big { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x3)}); + + pub const S64BIG_MIN: i64 = 0_i64; + pub const S64BIG_MAX: i64 = 0_i64; + + /// Construct new Message64big from values + pub fn new(s64big: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s64big(s64big)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s64big + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s64big(&self) -> i64 { + self.s64big_raw() + } + + /// Get raw value of s64big + /// + /// - Start bit: 7 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn s64big_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..64].load_be::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s64big + #[inline(always)] + pub fn set_s64big(&mut self, value: i64) -> Result<(), CanError> { + if value < 0_i64 || 0_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message64big::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message64big::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..64].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message64big { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message64big { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message64 +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message64 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message64 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const S64_MIN: i64 = -9223372036854780000_i64; + pub const S64_MAX: i64 = 9223372036854780000_i64; + + /// Construct new Message64 from values + pub fn new(s64: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s64(s64)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s64 + /// + /// - Min: -9223372036854780000 + /// - Max: 9223372036854780000 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s64(&self) -> i64 { + self.s64_raw() + } + + /// Get raw value of s64 + /// + /// - Start bit: 0 + /// - Signal size: 64 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s64_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..64].load_le::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s64 + #[inline(always)] + pub fn set_s64(&mut self, value: i64) -> Result<(), CanError> { + if value < -9223372036854780000_i64 || 9223372036854780000_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message64::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message64::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..64].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message64 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message64 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message33 +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message33 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message33 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const S33_MIN: i64 = -4294967296_i64; + pub const S33_MAX: i64 = 4294967295_i64; + + /// Construct new Message33 from values + pub fn new(s33: i64) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s33(s33)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s33 + /// + /// - Min: -4294967296 + /// - Max: 4294967295 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s33(&self) -> i64 { + self.s33_raw() + } + + /// Get raw value of s33 + /// + /// - Start bit: 0 + /// - Signal size: 33 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s33_raw(&self) -> i64 { + let signal = self.raw.view_bits::()[0..33].load_le::(); + + let factor = 1; + let signal = signal as i64; + i64::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s33 + #[inline(always)] + pub fn set_s33(&mut self, value: i64) -> Result<(), CanError> { + if value < -4294967296_i64 || 4294967295_i64 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message33::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message33::MESSAGE_ID })?; + let value = (value / factor) as i64; + + let value = u64::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..33].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message33 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message33 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Message32 +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message32 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message32 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const S32_MIN: i32 = 0_i32; + pub const S32_MAX: i32 = 0_i32; + + /// Construct new Message32 from values + pub fn new(s32: i32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_s32(s32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// s32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn s32(&self) -> i32 { + self.s32_raw() + } + + /// Get raw value of s32 + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn s32_raw(&self) -> i32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 1; + let signal = signal as i32; + i32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of s32 + #[inline(always)] + pub fn set_s32(&mut self, value: i32) -> Result<(), CanError> { + if value < 0_i32 || 0_i32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message32::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message32::MESSAGE_ID })?; + let value = (value / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message32 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message32 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/signed.snap.stderr b/tests-snapshots/dbc-cantools/signed.snap.stderr new file mode 100644 index 0000000..09fb287 --- /dev/null +++ b/tests-snapshots/dbc-cantools/signed.snap.stderr @@ -0,0 +1,36 @@ +error: literal out of range for `i64` + --> tests-snapshots/dbc-cantools/signed.snap.rs:1479:30 + | +1479 | pub const S64_MIN: i64 = -9223372036854780000_i64; + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `-9223372036854780000_i64` does not fit into the type `i64` whose range is `-9223372036854775808..=9223372036854775807` + = help: consider using the type `i128` instead + = note: `#[deny(overflowing_literals)]` on by default + +error: literal out of range for `i64` + --> tests-snapshots/dbc-cantools/signed.snap.rs:1480:30 + | +1480 | pub const S64_MAX: i64 = 9223372036854780000_i64; + | ^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `9223372036854780000_i64` does not fit into the type `i64` whose range is `-9223372036854775808..=9223372036854775807` + = help: consider using the type `u64` instead + +error: literal out of range for `i64` + --> tests-snapshots/dbc-cantools/signed.snap.rs:1525:20 + | +1525 | if value < -9223372036854780000_i64 || 9223372036854780000_i64 < value { + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `-9223372036854780000_i64` does not fit into the type `i64` whose range is `-9223372036854775808..=9223372036854775807` + = help: consider using the type `i128` instead + +error: literal out of range for `i64` + --> tests-snapshots/dbc-cantools/signed.snap.rs:1525:48 + | +1525 | if value < -9223372036854780000_i64 || 9223372036854780000_i64 < value { + | ^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: the literal `9223372036854780000_i64` does not fit into the type `i64` whose range is `-9223372036854775808..=9223372036854775807` + = help: consider using the type `u64` instead diff --git a/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-default-sort-signals.snap b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-default-sort-signals.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-default-sort-signals.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-default-sort-signals.snap.rs b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-default-sort-signals.snap.rs new file mode 100644 index 0000000..4d0d8e7 --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-default-sort-signals.snap.rs @@ -0,0 +1,1511 @@ +// Generated code! +// +// Message definitions from file `socialledge-written-by-cantools-with-default-sort-signals` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// DRIVER_HEARTBEAT + DriverHeartbeat(DriverHeartbeat), + /// IO_DEBUG + IoDebug(IoDebug), + /// MOTOR_CMD + MotorCmd(MotorCmd), + /// MOTOR_STATUS + MotorStatus(MotorStatus), + /// SENSOR_SONARS + SensorSonars(SensorSonars), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DriverHeartbeat::MESSAGE_ID => Messages::DriverHeartbeat(DriverHeartbeat::try_from(payload)?), + IoDebug::MESSAGE_ID => Messages::IoDebug(IoDebug::try_from(payload)?), + MotorCmd::MESSAGE_ID => Messages::MotorCmd(MotorCmd::try_from(payload)?), + MotorStatus::MESSAGE_ID => Messages::MotorStatus(MotorStatus::try_from(payload)?), + SensorSonars::MESSAGE_ID => Messages::SensorSonars(SensorSonars::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// DRIVER_HEARTBEAT +/// +/// - Standard ID: 100 (0x64) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +/// +/// Sync message used to synchronize the controllers +#[derive(Clone, Copy)] +pub struct DriverHeartbeat { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DriverHeartbeat { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x64)}); + + pub const DRIVER_HEARTBEAT_CMD_MIN: u8 = 0_u8; + pub const DRIVER_HEARTBEAT_CMD_MAX: u8 = 0_u8; + + /// Construct new DRIVER_HEARTBEAT from values + pub fn new(driver_heartbeat_cmd: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_driver_heartbeat_cmd(driver_heartbeat_cmd)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// DRIVER_HEARTBEAT_cmd + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: SENSOR, MOTOR + #[inline(always)] + pub fn driver_heartbeat_cmd(&self) -> DriverHeartbeatDriverHeartbeatCmd { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 2 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot, + 1 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync, + 0 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop, + _ => DriverHeartbeatDriverHeartbeatCmd::_Other(self.driver_heartbeat_cmd_raw()), + } + } + + /// Get raw value of DRIVER_HEARTBEAT_cmd + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn driver_heartbeat_cmd_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of DRIVER_HEARTBEAT_cmd + #[inline(always)] + pub fn set_driver_heartbeat_cmd(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for DriverHeartbeat { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DriverHeartbeat { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DRIVER_HEARTBEAT_cmd +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum DriverHeartbeatDriverHeartbeatCmd { + DriverHeartbeatCmdReboot, + DriverHeartbeatCmdSync, + DriverHeartbeatCmdNoop, + _Other(u8), +} + +impl From for u8 { + fn from(val: DriverHeartbeatDriverHeartbeatCmd) -> u8 { + match val { + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot => 2, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync => 1, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop => 0, + DriverHeartbeatDriverHeartbeatCmd::_Other(x) => x, + } + } +} + + +/// IO_DEBUG +/// +/// - Standard ID: 500 (0x1f4) +/// - Size: 4 bytes +/// - Transmitter: IO +#[derive(Clone, Copy)] +pub struct IoDebug { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl IoDebug { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f4)}); + + pub const IO_DEBUG_TEST_FLOAT_MIN: f32 = 0_f32; + pub const IO_DEBUG_TEST_FLOAT_MAX: f32 = 0_f32; + pub const IO_DEBUG_TEST_SIGNED_MIN: i8 = 0_i8; + pub const IO_DEBUG_TEST_SIGNED_MAX: i8 = 0_i8; + pub const IO_DEBUG_TEST_ENUM_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_ENUM_MAX: u8 = 0_u8; + pub const IO_DEBUG_TEST_UNSIGNED_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_UNSIGNED_MAX: u8 = 0_u8; + + /// Construct new IO_DEBUG from values + pub fn new(io_debug_test_float: f32, io_debug_test_signed: i8, io_debug_test_enum: u8, io_debug_test_unsigned: u8) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_io_debug_test_float(io_debug_test_float)?; + res.set_io_debug_test_signed(io_debug_test_signed)?; + res.set_io_debug_test_enum(io_debug_test_enum)?; + res.set_io_debug_test_unsigned(io_debug_test_unsigned)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// IO_DEBUG_test_float + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_float(&self) -> f32 { + self.io_debug_test_float_raw() + } + + /// Get raw value of IO_DEBUG_test_float + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 0.5 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_float_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 0.5_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IO_DEBUG_test_float + #[inline(always)] + pub fn set_io_debug_test_float(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 0.5_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_signed + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_signed(&self) -> i8 { + self.io_debug_test_signed_raw() + } + + /// Get raw value of IO_DEBUG_test_signed + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn io_debug_test_signed_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_signed + #[inline(always)] + pub fn set_io_debug_test_signed(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_enum + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_enum(&self) -> IoDebugIoDebugTestEnum { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 2 => IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo, + 1 => IoDebugIoDebugTestEnum::IoDebugTest2EnumOne, + _ => IoDebugIoDebugTestEnum::_Other(self.io_debug_test_enum_raw()), + } + } + + /// Get raw value of IO_DEBUG_test_enum + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_enum_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_enum + #[inline(always)] + pub fn set_io_debug_test_enum(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_unsigned + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_unsigned(&self) -> u8 { + self.io_debug_test_unsigned_raw() + } + + /// Get raw value of IO_DEBUG_test_unsigned + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_unsigned_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_unsigned + #[inline(always)] + pub fn set_io_debug_test_unsigned(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for IoDebug { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for IoDebug { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for IO_DEBUG_test_enum +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum IoDebugIoDebugTestEnum { + IoDebugTest2EnumTwo, + IoDebugTest2EnumOne, + _Other(u8), +} + +impl From for u8 { + fn from(val: IoDebugIoDebugTestEnum) -> u8 { + match val { + IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo => 2, + IoDebugIoDebugTestEnum::IoDebugTest2EnumOne => 1, + IoDebugIoDebugTestEnum::_Other(x) => x, + } + } +} + + +/// MOTOR_CMD +/// +/// - Standard ID: 101 (0x65) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +#[derive(Clone, Copy)] +pub struct MotorCmd { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorCmd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x65)}); + + pub const MOTOR_CMD_DRIVE_MIN: u8 = 0_u8; + pub const MOTOR_CMD_DRIVE_MAX: u8 = 9_u8; + pub const MOTOR_CMD_STEER_MIN: i8 = -5_i8; + pub const MOTOR_CMD_STEER_MAX: i8 = 5_i8; + + /// Construct new MOTOR_CMD from values + pub fn new(motor_cmd_drive: u8, motor_cmd_steer: i8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_motor_cmd_drive(motor_cmd_drive)?; + res.set_motor_cmd_steer(motor_cmd_steer)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// MOTOR_CMD_drive + /// + /// - Min: 0 + /// - Max: 9 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_drive(&self) -> u8 { + self.motor_cmd_drive_raw() + } + + /// Get raw value of MOTOR_CMD_drive + /// + /// - Start bit: 4 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_cmd_drive_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MOTOR_CMD_drive + #[inline(always)] + pub fn set_motor_cmd_drive(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 9_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) + } + + /// MOTOR_CMD_steer + /// + /// - Min: -5 + /// - Max: 5 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_steer(&self) -> i8 { + self.motor_cmd_steer_raw() + } + + /// Get raw value of MOTOR_CMD_steer + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: -5 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn motor_cmd_steer_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_sub(5) + } + + /// Set value of MOTOR_CMD_steer + #[inline(always)] + pub fn set_motor_cmd_steer(&mut self, value: i8) -> Result<(), CanError> { + if value < -5_i8 || 5_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(5) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorCmd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorCmd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MOTOR_STATUS +/// +/// - Standard ID: 400 (0x190) +/// - Size: 3 bytes +/// - Transmitter: MOTOR +#[derive(Clone, Copy)] +pub struct MotorStatus { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x190)}); + + pub const MOTOR_STATUS_SPEED_KPH_MIN: f32 = 0_f32; + pub const MOTOR_STATUS_SPEED_KPH_MAX: f32 = 0_f32; + + /// Construct new MOTOR_STATUS from values + pub fn new(motor_status_speed_kph: f32, motor_status_wheel_error: bool) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_motor_status_speed_kph(motor_status_speed_kph)?; + res.set_motor_status_wheel_error(motor_status_wheel_error)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// MOTOR_STATUS_speed_kph + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "kph" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_speed_kph(&self) -> f32 { + self.motor_status_speed_kph_raw() + } + + /// Get raw value of MOTOR_STATUS_speed_kph + /// + /// - Start bit: 8 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_speed_kph_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..24].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of MOTOR_STATUS_speed_kph + #[inline(always)] + pub fn set_motor_status_speed_kph(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorStatus::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[8..24].store_le(value); + Ok(()) + } + + /// MOTOR_STATUS_wheel_error + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_wheel_error(&self) -> bool { + self.motor_status_wheel_error_raw() + } + + /// Get raw value of MOTOR_STATUS_wheel_error + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_wheel_error_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of MOTOR_STATUS_wheel_error + #[inline(always)] + pub fn set_motor_status_wheel_error(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SENSOR_SONARS +/// +/// - Standard ID: 200 (0xc8) +/// - Size: 8 bytes +/// - Transmitter: SENSOR +#[derive(Clone, Copy)] +pub struct SensorSonars { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonars { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc8)}); + + pub const SENSOR_SONARS_NO_FILT_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_ERR_COUNT_MIN: u16 = 0_u16; + pub const SENSOR_SONARS_ERR_COUNT_MAX: u16 = 0_u16; + pub const SENSOR_SONARS_MUX_MIN: u8 = 0_u8; + pub const SENSOR_SONARS_MUX_MAX: u8 = 0_u8; + + /// Construct new SENSOR_SONARS from values + pub fn new(sensor_sonars_err_count: u16, sensor_sonars_mux: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sensor_sonars_err_count(sensor_sonars_err_count)?; + res.set_sensor_sonars_mux(sensor_sonars_mux)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SENSOR_SONARS_err_count + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn sensor_sonars_err_count(&self) -> u16 { + self.sensor_sonars_err_count_raw() + } + + /// Get raw value of SENSOR_SONARS_err_count + /// + /// - Start bit: 4 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_err_count_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[4..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SENSOR_SONARS_err_count + #[inline(always)] + pub fn set_sensor_sonars_err_count(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[4..16].store_le(value); + Ok(()) + } + + /// Get raw value of SENSOR_SONARS_mux + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_mux_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn sensor_sonars_mux(&mut self) -> Result { + match self.sensor_sonars_mux_raw() { + 0 => Ok(SensorSonarsSensorSonarsMuxIndex::M0(SensorSonarsSensorSonarsMuxM0{ raw: self.raw })), + 1 => Ok(SensorSonarsSensorSonarsMuxIndex::M1(SensorSonarsSensorSonarsMuxM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: SensorSonars::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + fn set_sensor_sonars_mux(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m0(&mut self, value: SensorSonarsSensorSonarsMuxM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(0)?; + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m1(&mut self, value: SensorSonarsSensorSonarsMuxM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SensorSonars { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SensorSonars { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal SENSOR_SONARS +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum SensorSonarsSensorSonarsMuxIndex { + M0(SensorSonarsSensorSonarsMuxM0), + M1(SensorSonarsSensorSonarsMuxM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_rear(&self) -> f32 { + self.sensor_sonars_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_rear +#[inline(always)] +pub fn set_sensor_sonars_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_right(&self) -> f32 { + self.sensor_sonars_right_raw() +} + +/// Get raw value of SENSOR_SONARS_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_right +#[inline(always)] +pub fn set_sensor_sonars_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_middle(&self) -> f32 { + self.sensor_sonars_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_middle +#[inline(always)] +pub fn set_sensor_sonars_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_left(&self) -> f32 { + self.sensor_sonars_left_raw() +} + +/// Get raw value of SENSOR_SONARS_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_left +#[inline(always)] +pub fn set_sensor_sonars_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_no_filt_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_rear(&self) -> f32 { + self.sensor_sonars_no_filt_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_rear +#[inline(always)] +pub fn set_sensor_sonars_no_filt_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_right(&self) -> f32 { + self.sensor_sonars_no_filt_right_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_right +#[inline(always)] +pub fn set_sensor_sonars_no_filt_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_middle(&self) -> f32 { + self.sensor_sonars_no_filt_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_middle +#[inline(always)] +pub fn set_sensor_sonars_no_filt_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_left(&self) -> f32 { + self.sensor_sonars_no_filt_left_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_left +#[inline(always)] +pub fn set_sensor_sonars_no_filt_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-sort-signals-by-name.snap b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-sort-signals-by-name.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-sort-signals-by-name.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-sort-signals-by-name.snap.rs b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-sort-signals-by-name.snap.rs new file mode 100644 index 0000000..2e7bc9f --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools-with-sort-signals-by-name.snap.rs @@ -0,0 +1,1511 @@ +// Generated code! +// +// Message definitions from file `socialledge-written-by-cantools-with-sort-signals-by-name` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// DRIVER_HEARTBEAT + DriverHeartbeat(DriverHeartbeat), + /// IO_DEBUG + IoDebug(IoDebug), + /// MOTOR_CMD + MotorCmd(MotorCmd), + /// MOTOR_STATUS + MotorStatus(MotorStatus), + /// SENSOR_SONARS + SensorSonars(SensorSonars), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DriverHeartbeat::MESSAGE_ID => Messages::DriverHeartbeat(DriverHeartbeat::try_from(payload)?), + IoDebug::MESSAGE_ID => Messages::IoDebug(IoDebug::try_from(payload)?), + MotorCmd::MESSAGE_ID => Messages::MotorCmd(MotorCmd::try_from(payload)?), + MotorStatus::MESSAGE_ID => Messages::MotorStatus(MotorStatus::try_from(payload)?), + SensorSonars::MESSAGE_ID => Messages::SensorSonars(SensorSonars::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// DRIVER_HEARTBEAT +/// +/// - Standard ID: 100 (0x64) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +/// +/// Sync message used to synchronize the controllers +#[derive(Clone, Copy)] +pub struct DriverHeartbeat { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DriverHeartbeat { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x64)}); + + pub const DRIVER_HEARTBEAT_CMD_MIN: u8 = 0_u8; + pub const DRIVER_HEARTBEAT_CMD_MAX: u8 = 0_u8; + + /// Construct new DRIVER_HEARTBEAT from values + pub fn new(driver_heartbeat_cmd: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_driver_heartbeat_cmd(driver_heartbeat_cmd)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// DRIVER_HEARTBEAT_cmd + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: SENSOR, MOTOR + #[inline(always)] + pub fn driver_heartbeat_cmd(&self) -> DriverHeartbeatDriverHeartbeatCmd { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 2 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot, + 1 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync, + 0 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop, + _ => DriverHeartbeatDriverHeartbeatCmd::_Other(self.driver_heartbeat_cmd_raw()), + } + } + + /// Get raw value of DRIVER_HEARTBEAT_cmd + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn driver_heartbeat_cmd_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of DRIVER_HEARTBEAT_cmd + #[inline(always)] + pub fn set_driver_heartbeat_cmd(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for DriverHeartbeat { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DriverHeartbeat { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DRIVER_HEARTBEAT_cmd +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum DriverHeartbeatDriverHeartbeatCmd { + DriverHeartbeatCmdReboot, + DriverHeartbeatCmdSync, + DriverHeartbeatCmdNoop, + _Other(u8), +} + +impl From for u8 { + fn from(val: DriverHeartbeatDriverHeartbeatCmd) -> u8 { + match val { + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot => 2, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync => 1, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop => 0, + DriverHeartbeatDriverHeartbeatCmd::_Other(x) => x, + } + } +} + + +/// IO_DEBUG +/// +/// - Standard ID: 500 (0x1f4) +/// - Size: 4 bytes +/// - Transmitter: IO +#[derive(Clone, Copy)] +pub struct IoDebug { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl IoDebug { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f4)}); + + pub const IO_DEBUG_TEST_ENUM_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_ENUM_MAX: u8 = 0_u8; + pub const IO_DEBUG_TEST_FLOAT_MIN: f32 = 0_f32; + pub const IO_DEBUG_TEST_FLOAT_MAX: f32 = 0_f32; + pub const IO_DEBUG_TEST_SIGNED_MIN: i8 = 0_i8; + pub const IO_DEBUG_TEST_SIGNED_MAX: i8 = 0_i8; + pub const IO_DEBUG_TEST_UNSIGNED_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_UNSIGNED_MAX: u8 = 0_u8; + + /// Construct new IO_DEBUG from values + pub fn new(io_debug_test_enum: u8, io_debug_test_float: f32, io_debug_test_signed: i8, io_debug_test_unsigned: u8) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_io_debug_test_enum(io_debug_test_enum)?; + res.set_io_debug_test_float(io_debug_test_float)?; + res.set_io_debug_test_signed(io_debug_test_signed)?; + res.set_io_debug_test_unsigned(io_debug_test_unsigned)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// IO_DEBUG_test_enum + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_enum(&self) -> IoDebugIoDebugTestEnum { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 2 => IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo, + 1 => IoDebugIoDebugTestEnum::IoDebugTest2EnumOne, + _ => IoDebugIoDebugTestEnum::_Other(self.io_debug_test_enum_raw()), + } + } + + /// Get raw value of IO_DEBUG_test_enum + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_enum_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_enum + #[inline(always)] + pub fn set_io_debug_test_enum(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_float + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_float(&self) -> f32 { + self.io_debug_test_float_raw() + } + + /// Get raw value of IO_DEBUG_test_float + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 0.5 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_float_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 0.5_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IO_DEBUG_test_float + #[inline(always)] + pub fn set_io_debug_test_float(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 0.5_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_signed + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_signed(&self) -> i8 { + self.io_debug_test_signed_raw() + } + + /// Get raw value of IO_DEBUG_test_signed + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn io_debug_test_signed_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_signed + #[inline(always)] + pub fn set_io_debug_test_signed(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_unsigned + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_unsigned(&self) -> u8 { + self.io_debug_test_unsigned_raw() + } + + /// Get raw value of IO_DEBUG_test_unsigned + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_unsigned_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_unsigned + #[inline(always)] + pub fn set_io_debug_test_unsigned(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for IoDebug { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for IoDebug { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for IO_DEBUG_test_enum +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum IoDebugIoDebugTestEnum { + IoDebugTest2EnumTwo, + IoDebugTest2EnumOne, + _Other(u8), +} + +impl From for u8 { + fn from(val: IoDebugIoDebugTestEnum) -> u8 { + match val { + IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo => 2, + IoDebugIoDebugTestEnum::IoDebugTest2EnumOne => 1, + IoDebugIoDebugTestEnum::_Other(x) => x, + } + } +} + + +/// MOTOR_CMD +/// +/// - Standard ID: 101 (0x65) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +#[derive(Clone, Copy)] +pub struct MotorCmd { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorCmd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x65)}); + + pub const MOTOR_CMD_DRIVE_MIN: u8 = 0_u8; + pub const MOTOR_CMD_DRIVE_MAX: u8 = 9_u8; + pub const MOTOR_CMD_STEER_MIN: i8 = -5_i8; + pub const MOTOR_CMD_STEER_MAX: i8 = 5_i8; + + /// Construct new MOTOR_CMD from values + pub fn new(motor_cmd_drive: u8, motor_cmd_steer: i8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_motor_cmd_drive(motor_cmd_drive)?; + res.set_motor_cmd_steer(motor_cmd_steer)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// MOTOR_CMD_drive + /// + /// - Min: 0 + /// - Max: 9 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_drive(&self) -> u8 { + self.motor_cmd_drive_raw() + } + + /// Get raw value of MOTOR_CMD_drive + /// + /// - Start bit: 4 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_cmd_drive_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MOTOR_CMD_drive + #[inline(always)] + pub fn set_motor_cmd_drive(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 9_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) + } + + /// MOTOR_CMD_steer + /// + /// - Min: -5 + /// - Max: 5 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_steer(&self) -> i8 { + self.motor_cmd_steer_raw() + } + + /// Get raw value of MOTOR_CMD_steer + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: -5 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn motor_cmd_steer_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_sub(5) + } + + /// Set value of MOTOR_CMD_steer + #[inline(always)] + pub fn set_motor_cmd_steer(&mut self, value: i8) -> Result<(), CanError> { + if value < -5_i8 || 5_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(5) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorCmd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorCmd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MOTOR_STATUS +/// +/// - Standard ID: 400 (0x190) +/// - Size: 3 bytes +/// - Transmitter: MOTOR +#[derive(Clone, Copy)] +pub struct MotorStatus { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x190)}); + + pub const MOTOR_STATUS_SPEED_KPH_MIN: f32 = 0_f32; + pub const MOTOR_STATUS_SPEED_KPH_MAX: f32 = 0_f32; + + /// Construct new MOTOR_STATUS from values + pub fn new(motor_status_speed_kph: f32, motor_status_wheel_error: bool) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_motor_status_speed_kph(motor_status_speed_kph)?; + res.set_motor_status_wheel_error(motor_status_wheel_error)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// MOTOR_STATUS_speed_kph + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "kph" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_speed_kph(&self) -> f32 { + self.motor_status_speed_kph_raw() + } + + /// Get raw value of MOTOR_STATUS_speed_kph + /// + /// - Start bit: 8 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_speed_kph_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..24].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of MOTOR_STATUS_speed_kph + #[inline(always)] + pub fn set_motor_status_speed_kph(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorStatus::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[8..24].store_le(value); + Ok(()) + } + + /// MOTOR_STATUS_wheel_error + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_wheel_error(&self) -> bool { + self.motor_status_wheel_error_raw() + } + + /// Get raw value of MOTOR_STATUS_wheel_error + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_wheel_error_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of MOTOR_STATUS_wheel_error + #[inline(always)] + pub fn set_motor_status_wheel_error(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SENSOR_SONARS +/// +/// - Standard ID: 200 (0xc8) +/// - Size: 8 bytes +/// - Transmitter: SENSOR +#[derive(Clone, Copy)] +pub struct SensorSonars { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonars { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc8)}); + + pub const SENSOR_SONARS_ERR_COUNT_MIN: u16 = 0_u16; + pub const SENSOR_SONARS_ERR_COUNT_MAX: u16 = 0_u16; + pub const SENSOR_SONARS_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_MUX_MIN: u8 = 0_u8; + pub const SENSOR_SONARS_MUX_MAX: u8 = 0_u8; + pub const SENSOR_SONARS_NO_FILT_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MAX: f32 = 0_f32; + + /// Construct new SENSOR_SONARS from values + pub fn new(sensor_sonars_err_count: u16, sensor_sonars_mux: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sensor_sonars_err_count(sensor_sonars_err_count)?; + res.set_sensor_sonars_mux(sensor_sonars_mux)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SENSOR_SONARS_err_count + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn sensor_sonars_err_count(&self) -> u16 { + self.sensor_sonars_err_count_raw() + } + + /// Get raw value of SENSOR_SONARS_err_count + /// + /// - Start bit: 4 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_err_count_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[4..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SENSOR_SONARS_err_count + #[inline(always)] + pub fn set_sensor_sonars_err_count(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[4..16].store_le(value); + Ok(()) + } + + /// Get raw value of SENSOR_SONARS_mux + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_mux_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn sensor_sonars_mux(&mut self) -> Result { + match self.sensor_sonars_mux_raw() { + 0 => Ok(SensorSonarsSensorSonarsMuxIndex::M0(SensorSonarsSensorSonarsMuxM0{ raw: self.raw })), + 1 => Ok(SensorSonarsSensorSonarsMuxIndex::M1(SensorSonarsSensorSonarsMuxM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: SensorSonars::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + fn set_sensor_sonars_mux(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m0(&mut self, value: SensorSonarsSensorSonarsMuxM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(0)?; + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m1(&mut self, value: SensorSonarsSensorSonarsMuxM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(1)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SensorSonars { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SensorSonars { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal SENSOR_SONARS +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum SensorSonarsSensorSonarsMuxIndex { + M0(SensorSonarsSensorSonarsMuxM0), + M1(SensorSonarsSensorSonarsMuxM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_left(&self) -> f32 { + self.sensor_sonars_left_raw() +} + +/// Get raw value of SENSOR_SONARS_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_left +#[inline(always)] +pub fn set_sensor_sonars_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_middle(&self) -> f32 { + self.sensor_sonars_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_middle +#[inline(always)] +pub fn set_sensor_sonars_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_rear(&self) -> f32 { + self.sensor_sonars_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_rear +#[inline(always)] +pub fn set_sensor_sonars_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_right(&self) -> f32 { + self.sensor_sonars_right_raw() +} + +/// Get raw value of SENSOR_SONARS_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_right +#[inline(always)] +pub fn set_sensor_sonars_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_no_filt_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_left(&self) -> f32 { + self.sensor_sonars_no_filt_left_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_left +#[inline(always)] +pub fn set_sensor_sonars_no_filt_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_middle(&self) -> f32 { + self.sensor_sonars_no_filt_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_middle +#[inline(always)] +pub fn set_sensor_sonars_no_filt_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_rear(&self) -> f32 { + self.sensor_sonars_no_filt_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_rear +#[inline(always)] +pub fn set_sensor_sonars_no_filt_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_right(&self) -> f32 { + self.sensor_sonars_no_filt_right_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_right +#[inline(always)] +pub fn set_sensor_sonars_no_filt_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/socialledge-written-by-cantools.snap b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/socialledge-written-by-cantools.snap.rs b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools.snap.rs new file mode 100644 index 0000000..05ed912 --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge-written-by-cantools.snap.rs @@ -0,0 +1,1511 @@ +// Generated code! +// +// Message definitions from file `socialledge-written-by-cantools` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// DRIVER_HEARTBEAT + DriverHeartbeat(DriverHeartbeat), + /// IO_DEBUG + IoDebug(IoDebug), + /// MOTOR_CMD + MotorCmd(MotorCmd), + /// MOTOR_STATUS + MotorStatus(MotorStatus), + /// SENSOR_SONARS + SensorSonars(SensorSonars), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DriverHeartbeat::MESSAGE_ID => Messages::DriverHeartbeat(DriverHeartbeat::try_from(payload)?), + IoDebug::MESSAGE_ID => Messages::IoDebug(IoDebug::try_from(payload)?), + MotorCmd::MESSAGE_ID => Messages::MotorCmd(MotorCmd::try_from(payload)?), + MotorStatus::MESSAGE_ID => Messages::MotorStatus(MotorStatus::try_from(payload)?), + SensorSonars::MESSAGE_ID => Messages::SensorSonars(SensorSonars::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// DRIVER_HEARTBEAT +/// +/// - Standard ID: 100 (0x64) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +/// +/// Sync message used to synchronize the controllers +#[derive(Clone, Copy)] +pub struct DriverHeartbeat { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DriverHeartbeat { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x64)}); + + pub const DRIVER_HEARTBEAT_CMD_MIN: u8 = 0_u8; + pub const DRIVER_HEARTBEAT_CMD_MAX: u8 = 0_u8; + + /// Construct new DRIVER_HEARTBEAT from values + pub fn new(driver_heartbeat_cmd: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_driver_heartbeat_cmd(driver_heartbeat_cmd)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// DRIVER_HEARTBEAT_cmd + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: SENSOR, MOTOR + #[inline(always)] + pub fn driver_heartbeat_cmd(&self) -> DriverHeartbeatDriverHeartbeatCmd { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 2 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot, + 1 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync, + 0 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop, + _ => DriverHeartbeatDriverHeartbeatCmd::_Other(self.driver_heartbeat_cmd_raw()), + } + } + + /// Get raw value of DRIVER_HEARTBEAT_cmd + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn driver_heartbeat_cmd_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of DRIVER_HEARTBEAT_cmd + #[inline(always)] + pub fn set_driver_heartbeat_cmd(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for DriverHeartbeat { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DriverHeartbeat { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DRIVER_HEARTBEAT_cmd +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum DriverHeartbeatDriverHeartbeatCmd { + DriverHeartbeatCmdReboot, + DriverHeartbeatCmdSync, + DriverHeartbeatCmdNoop, + _Other(u8), +} + +impl From for u8 { + fn from(val: DriverHeartbeatDriverHeartbeatCmd) -> u8 { + match val { + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot => 2, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync => 1, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop => 0, + DriverHeartbeatDriverHeartbeatCmd::_Other(x) => x, + } + } +} + + +/// IO_DEBUG +/// +/// - Standard ID: 500 (0x1f4) +/// - Size: 4 bytes +/// - Transmitter: IO +#[derive(Clone, Copy)] +pub struct IoDebug { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl IoDebug { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f4)}); + + pub const IO_DEBUG_TEST_UNSIGNED_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_UNSIGNED_MAX: u8 = 0_u8; + pub const IO_DEBUG_TEST_ENUM_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_ENUM_MAX: u8 = 0_u8; + pub const IO_DEBUG_TEST_SIGNED_MIN: i8 = 0_i8; + pub const IO_DEBUG_TEST_SIGNED_MAX: i8 = 0_i8; + pub const IO_DEBUG_TEST_FLOAT_MIN: f32 = 0_f32; + pub const IO_DEBUG_TEST_FLOAT_MAX: f32 = 0_f32; + + /// Construct new IO_DEBUG from values + pub fn new(io_debug_test_unsigned: u8, io_debug_test_enum: u8, io_debug_test_signed: i8, io_debug_test_float: f32) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_io_debug_test_unsigned(io_debug_test_unsigned)?; + res.set_io_debug_test_enum(io_debug_test_enum)?; + res.set_io_debug_test_signed(io_debug_test_signed)?; + res.set_io_debug_test_float(io_debug_test_float)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// IO_DEBUG_test_unsigned + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_unsigned(&self) -> u8 { + self.io_debug_test_unsigned_raw() + } + + /// Get raw value of IO_DEBUG_test_unsigned + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_unsigned_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_unsigned + #[inline(always)] + pub fn set_io_debug_test_unsigned(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_enum + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_enum(&self) -> IoDebugIoDebugTestEnum { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 2 => IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo, + 1 => IoDebugIoDebugTestEnum::IoDebugTest2EnumOne, + _ => IoDebugIoDebugTestEnum::_Other(self.io_debug_test_enum_raw()), + } + } + + /// Get raw value of IO_DEBUG_test_enum + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_enum_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_enum + #[inline(always)] + pub fn set_io_debug_test_enum(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_signed + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_signed(&self) -> i8 { + self.io_debug_test_signed_raw() + } + + /// Get raw value of IO_DEBUG_test_signed + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn io_debug_test_signed_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_signed + #[inline(always)] + pub fn set_io_debug_test_signed(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_float + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_float(&self) -> f32 { + self.io_debug_test_float_raw() + } + + /// Get raw value of IO_DEBUG_test_float + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 0.5 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_float_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 0.5_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IO_DEBUG_test_float + #[inline(always)] + pub fn set_io_debug_test_float(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 0.5_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for IoDebug { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for IoDebug { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for IO_DEBUG_test_enum +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum IoDebugIoDebugTestEnum { + IoDebugTest2EnumTwo, + IoDebugTest2EnumOne, + _Other(u8), +} + +impl From for u8 { + fn from(val: IoDebugIoDebugTestEnum) -> u8 { + match val { + IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo => 2, + IoDebugIoDebugTestEnum::IoDebugTest2EnumOne => 1, + IoDebugIoDebugTestEnum::_Other(x) => x, + } + } +} + + +/// MOTOR_CMD +/// +/// - Standard ID: 101 (0x65) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +#[derive(Clone, Copy)] +pub struct MotorCmd { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorCmd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x65)}); + + pub const MOTOR_CMD_STEER_MIN: i8 = -5_i8; + pub const MOTOR_CMD_STEER_MAX: i8 = 5_i8; + pub const MOTOR_CMD_DRIVE_MIN: u8 = 0_u8; + pub const MOTOR_CMD_DRIVE_MAX: u8 = 9_u8; + + /// Construct new MOTOR_CMD from values + pub fn new(motor_cmd_steer: i8, motor_cmd_drive: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_motor_cmd_steer(motor_cmd_steer)?; + res.set_motor_cmd_drive(motor_cmd_drive)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// MOTOR_CMD_steer + /// + /// - Min: -5 + /// - Max: 5 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_steer(&self) -> i8 { + self.motor_cmd_steer_raw() + } + + /// Get raw value of MOTOR_CMD_steer + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: -5 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn motor_cmd_steer_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_sub(5) + } + + /// Set value of MOTOR_CMD_steer + #[inline(always)] + pub fn set_motor_cmd_steer(&mut self, value: i8) -> Result<(), CanError> { + if value < -5_i8 || 5_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(5) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// MOTOR_CMD_drive + /// + /// - Min: 0 + /// - Max: 9 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_drive(&self) -> u8 { + self.motor_cmd_drive_raw() + } + + /// Get raw value of MOTOR_CMD_drive + /// + /// - Start bit: 4 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_cmd_drive_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MOTOR_CMD_drive + #[inline(always)] + pub fn set_motor_cmd_drive(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 9_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorCmd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorCmd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MOTOR_STATUS +/// +/// - Standard ID: 400 (0x190) +/// - Size: 3 bytes +/// - Transmitter: MOTOR +#[derive(Clone, Copy)] +pub struct MotorStatus { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x190)}); + + pub const MOTOR_STATUS_SPEED_KPH_MIN: f32 = 0_f32; + pub const MOTOR_STATUS_SPEED_KPH_MAX: f32 = 0_f32; + + /// Construct new MOTOR_STATUS from values + pub fn new(motor_status_wheel_error: bool, motor_status_speed_kph: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_motor_status_wheel_error(motor_status_wheel_error)?; + res.set_motor_status_speed_kph(motor_status_speed_kph)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// MOTOR_STATUS_wheel_error + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_wheel_error(&self) -> bool { + self.motor_status_wheel_error_raw() + } + + /// Get raw value of MOTOR_STATUS_wheel_error + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_wheel_error_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of MOTOR_STATUS_wheel_error + #[inline(always)] + pub fn set_motor_status_wheel_error(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + + /// MOTOR_STATUS_speed_kph + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "kph" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_speed_kph(&self) -> f32 { + self.motor_status_speed_kph_raw() + } + + /// Get raw value of MOTOR_STATUS_speed_kph + /// + /// - Start bit: 8 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_speed_kph_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..24].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of MOTOR_STATUS_speed_kph + #[inline(always)] + pub fn set_motor_status_speed_kph(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorStatus::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[8..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SENSOR_SONARS +/// +/// - Standard ID: 200 (0xc8) +/// - Size: 8 bytes +/// - Transmitter: SENSOR +#[derive(Clone, Copy)] +pub struct SensorSonars { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonars { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc8)}); + + pub const SENSOR_SONARS_MUX_MIN: u8 = 0_u8; + pub const SENSOR_SONARS_MUX_MAX: u8 = 0_u8; + pub const SENSOR_SONARS_ERR_COUNT_MIN: u16 = 0_u16; + pub const SENSOR_SONARS_ERR_COUNT_MAX: u16 = 0_u16; + pub const SENSOR_SONARS_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MAX: f32 = 0_f32; + + /// Construct new SENSOR_SONARS from values + pub fn new(sensor_sonars_mux: u8, sensor_sonars_err_count: u16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sensor_sonars_mux(sensor_sonars_mux)?; + res.set_sensor_sonars_err_count(sensor_sonars_err_count)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of SENSOR_SONARS_mux + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_mux_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn sensor_sonars_mux(&mut self) -> Result { + match self.sensor_sonars_mux_raw() { + 0 => Ok(SensorSonarsSensorSonarsMuxIndex::M0(SensorSonarsSensorSonarsMuxM0{ raw: self.raw })), + 1 => Ok(SensorSonarsSensorSonarsMuxIndex::M1(SensorSonarsSensorSonarsMuxM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: SensorSonars::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + fn set_sensor_sonars_mux(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m0(&mut self, value: SensorSonarsSensorSonarsMuxM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(0)?; + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m1(&mut self, value: SensorSonarsSensorSonarsMuxM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(1)?; + Ok(()) + } + + /// SENSOR_SONARS_err_count + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn sensor_sonars_err_count(&self) -> u16 { + self.sensor_sonars_err_count_raw() + } + + /// Get raw value of SENSOR_SONARS_err_count + /// + /// - Start bit: 4 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_err_count_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[4..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SENSOR_SONARS_err_count + #[inline(always)] + pub fn set_sensor_sonars_err_count(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[4..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SensorSonars { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SensorSonars { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal SENSOR_SONARS +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum SensorSonarsSensorSonarsMuxIndex { + M0(SensorSonarsSensorSonarsMuxM0), + M1(SensorSonarsSensorSonarsMuxM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_left(&self) -> f32 { + self.sensor_sonars_left_raw() +} + +/// Get raw value of SENSOR_SONARS_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_left +#[inline(always)] +pub fn set_sensor_sonars_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_middle(&self) -> f32 { + self.sensor_sonars_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_middle +#[inline(always)] +pub fn set_sensor_sonars_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_right(&self) -> f32 { + self.sensor_sonars_right_raw() +} + +/// Get raw value of SENSOR_SONARS_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_right +#[inline(always)] +pub fn set_sensor_sonars_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_rear(&self) -> f32 { + self.sensor_sonars_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_rear +#[inline(always)] +pub fn set_sensor_sonars_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_no_filt_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_left(&self) -> f32 { + self.sensor_sonars_no_filt_left_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_left +#[inline(always)] +pub fn set_sensor_sonars_no_filt_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_middle(&self) -> f32 { + self.sensor_sonars_no_filt_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_middle +#[inline(always)] +pub fn set_sensor_sonars_no_filt_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_right(&self) -> f32 { + self.sensor_sonars_no_filt_right_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_right +#[inline(always)] +pub fn set_sensor_sonars_no_filt_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_rear(&self) -> f32 { + self.sensor_sonars_no_filt_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_rear +#[inline(always)] +pub fn set_sensor_sonars_no_filt_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/socialledge.snap b/tests-snapshots/dbc-cantools/socialledge.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/socialledge.snap.rs b/tests-snapshots/dbc-cantools/socialledge.snap.rs new file mode 100644 index 0000000..c28a5bf --- /dev/null +++ b/tests-snapshots/dbc-cantools/socialledge.snap.rs @@ -0,0 +1,1511 @@ +// Generated code! +// +// Message definitions from file `socialledge` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// DRIVER_HEARTBEAT + DriverHeartbeat(DriverHeartbeat), + /// IO_DEBUG + IoDebug(IoDebug), + /// MOTOR_CMD + MotorCmd(MotorCmd), + /// MOTOR_STATUS + MotorStatus(MotorStatus), + /// SENSOR_SONARS + SensorSonars(SensorSonars), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + DriverHeartbeat::MESSAGE_ID => Messages::DriverHeartbeat(DriverHeartbeat::try_from(payload)?), + IoDebug::MESSAGE_ID => Messages::IoDebug(IoDebug::try_from(payload)?), + MotorCmd::MESSAGE_ID => Messages::MotorCmd(MotorCmd::try_from(payload)?), + MotorStatus::MESSAGE_ID => Messages::MotorStatus(MotorStatus::try_from(payload)?), + SensorSonars::MESSAGE_ID => Messages::SensorSonars(SensorSonars::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// DRIVER_HEARTBEAT +/// +/// - Standard ID: 100 (0x64) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +/// +/// Sync message used to synchronize the controllers +#[derive(Clone, Copy)] +pub struct DriverHeartbeat { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl DriverHeartbeat { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x64)}); + + pub const DRIVER_HEARTBEAT_CMD_MIN: u8 = 0_u8; + pub const DRIVER_HEARTBEAT_CMD_MAX: u8 = 0_u8; + + /// Construct new DRIVER_HEARTBEAT from values + pub fn new(driver_heartbeat_cmd: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_driver_heartbeat_cmd(driver_heartbeat_cmd)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// DRIVER_HEARTBEAT_cmd + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: SENSOR, MOTOR + #[inline(always)] + pub fn driver_heartbeat_cmd(&self) -> DriverHeartbeatDriverHeartbeatCmd { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 2 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot, + 1 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync, + 0 => DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop, + _ => DriverHeartbeatDriverHeartbeatCmd::_Other(self.driver_heartbeat_cmd_raw()), + } + } + + /// Get raw value of DRIVER_HEARTBEAT_cmd + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn driver_heartbeat_cmd_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of DRIVER_HEARTBEAT_cmd + #[inline(always)] + pub fn set_driver_heartbeat_cmd(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: DriverHeartbeat::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for DriverHeartbeat { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for DriverHeartbeat { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for DRIVER_HEARTBEAT_cmd +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum DriverHeartbeatDriverHeartbeatCmd { + DriverHeartbeatCmdReboot, + DriverHeartbeatCmdSync, + DriverHeartbeatCmdNoop, + _Other(u8), +} + +impl From for u8 { + fn from(val: DriverHeartbeatDriverHeartbeatCmd) -> u8 { + match val { + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdReboot => 2, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdSync => 1, + DriverHeartbeatDriverHeartbeatCmd::DriverHeartbeatCmdNoop => 0, + DriverHeartbeatDriverHeartbeatCmd::_Other(x) => x, + } + } +} + + +/// IO_DEBUG +/// +/// - Standard ID: 500 (0x1f4) +/// - Size: 4 bytes +/// - Transmitter: IO +#[derive(Clone, Copy)] +pub struct IoDebug { + raw: [u8; 4], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl IoDebug { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1f4)}); + + pub const IO_DEBUG_TEST_UNSIGNED_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_UNSIGNED_MAX: u8 = 0_u8; + pub const IO_DEBUG_TEST_ENUM_MIN: u8 = 0_u8; + pub const IO_DEBUG_TEST_ENUM_MAX: u8 = 0_u8; + pub const IO_DEBUG_TEST_SIGNED_MIN: i8 = 0_i8; + pub const IO_DEBUG_TEST_SIGNED_MAX: i8 = 0_i8; + pub const IO_DEBUG_TEST_FLOAT_MIN: f32 = 0_f32; + pub const IO_DEBUG_TEST_FLOAT_MAX: f32 = 0_f32; + + /// Construct new IO_DEBUG from values + pub fn new(io_debug_test_unsigned: u8, io_debug_test_enum: u8, io_debug_test_signed: i8, io_debug_test_float: f32) -> Result { + let mut res = Self { raw: [0u8; 4] }; + res.set_io_debug_test_unsigned(io_debug_test_unsigned)?; + res.set_io_debug_test_enum(io_debug_test_enum)?; + res.set_io_debug_test_signed(io_debug_test_signed)?; + res.set_io_debug_test_float(io_debug_test_float)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 4] { + &self.raw + } + + /// IO_DEBUG_test_unsigned + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_unsigned(&self) -> u8 { + self.io_debug_test_unsigned_raw() + } + + /// Get raw value of IO_DEBUG_test_unsigned + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_unsigned_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_unsigned + #[inline(always)] + pub fn set_io_debug_test_unsigned(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_enum + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_enum(&self) -> IoDebugIoDebugTestEnum { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + match signal { + 2 => IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo, + 1 => IoDebugIoDebugTestEnum::IoDebugTest2EnumOne, + _ => IoDebugIoDebugTestEnum::_Other(self.io_debug_test_enum_raw()), + } + } + + /// Get raw value of IO_DEBUG_test_enum + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_enum_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_enum + #[inline(always)] + pub fn set_io_debug_test_enum(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_signed + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_signed(&self) -> i8 { + self.io_debug_test_signed_raw() + } + + /// Get raw value of IO_DEBUG_test_signed + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn io_debug_test_signed_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of IO_DEBUG_test_signed + #[inline(always)] + pub fn set_io_debug_test_signed(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// IO_DEBUG_test_float + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DBG + #[inline(always)] + pub fn io_debug_test_float(&self) -> f32 { + self.io_debug_test_float_raw() + } + + /// Get raw value of IO_DEBUG_test_float + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 0.5 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn io_debug_test_float_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 0.5_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IO_DEBUG_test_float + #[inline(always)] + pub fn set_io_debug_test_float(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: IoDebug::MESSAGE_ID }); + } + let factor = 0.5_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for IoDebug { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 4]; + raw.copy_from_slice(&payload[..4]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for IoDebug { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for IO_DEBUG_test_enum +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum IoDebugIoDebugTestEnum { + IoDebugTest2EnumTwo, + IoDebugTest2EnumOne, + _Other(u8), +} + +impl From for u8 { + fn from(val: IoDebugIoDebugTestEnum) -> u8 { + match val { + IoDebugIoDebugTestEnum::IoDebugTest2EnumTwo => 2, + IoDebugIoDebugTestEnum::IoDebugTest2EnumOne => 1, + IoDebugIoDebugTestEnum::_Other(x) => x, + } + } +} + + +/// MOTOR_CMD +/// +/// - Standard ID: 101 (0x65) +/// - Size: 1 bytes +/// - Transmitter: DRIVER +#[derive(Clone, Copy)] +pub struct MotorCmd { + raw: [u8; 1], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorCmd { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x65)}); + + pub const MOTOR_CMD_STEER_MIN: i8 = -5_i8; + pub const MOTOR_CMD_STEER_MAX: i8 = 5_i8; + pub const MOTOR_CMD_DRIVE_MIN: u8 = 0_u8; + pub const MOTOR_CMD_DRIVE_MAX: u8 = 9_u8; + + /// Construct new MOTOR_CMD from values + pub fn new(motor_cmd_steer: i8, motor_cmd_drive: u8) -> Result { + let mut res = Self { raw: [0u8; 1] }; + res.set_motor_cmd_steer(motor_cmd_steer)?; + res.set_motor_cmd_drive(motor_cmd_drive)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 1] { + &self.raw + } + + /// MOTOR_CMD_steer + /// + /// - Min: -5 + /// - Max: 5 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_steer(&self) -> i8 { + self.motor_cmd_steer_raw() + } + + /// Get raw value of MOTOR_CMD_steer + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: -5 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn motor_cmd_steer_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_sub(5) + } + + /// Set value of MOTOR_CMD_steer + #[inline(always)] + pub fn set_motor_cmd_steer(&mut self, value: i8) -> Result<(), CanError> { + if value < -5_i8 || 5_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_add(5) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// MOTOR_CMD_drive + /// + /// - Min: 0 + /// - Max: 9 + /// - Unit: "" + /// - Receivers: MOTOR + #[inline(always)] + pub fn motor_cmd_drive(&self) -> u8 { + self.motor_cmd_drive_raw() + } + + /// Get raw value of MOTOR_CMD_drive + /// + /// - Start bit: 4 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_cmd_drive_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[4..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MOTOR_CMD_drive + #[inline(always)] + pub fn set_motor_cmd_drive(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 9_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MotorCmd::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[4..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorCmd { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 1 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 1]; + raw.copy_from_slice(&payload[..1]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorCmd { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// MOTOR_STATUS +/// +/// - Standard ID: 400 (0x190) +/// - Size: 3 bytes +/// - Transmitter: MOTOR +#[derive(Clone, Copy)] +pub struct MotorStatus { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MotorStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x190)}); + + pub const MOTOR_STATUS_SPEED_KPH_MIN: f32 = 0_f32; + pub const MOTOR_STATUS_SPEED_KPH_MAX: f32 = 0_f32; + + /// Construct new MOTOR_STATUS from values + pub fn new(motor_status_wheel_error: bool, motor_status_speed_kph: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_motor_status_wheel_error(motor_status_wheel_error)?; + res.set_motor_status_speed_kph(motor_status_speed_kph)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// MOTOR_STATUS_wheel_error + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_wheel_error(&self) -> bool { + self.motor_status_wheel_error_raw() + } + + /// Get raw value of MOTOR_STATUS_wheel_error + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_wheel_error_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of MOTOR_STATUS_wheel_error + #[inline(always)] + pub fn set_motor_status_wheel_error(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + + /// MOTOR_STATUS_speed_kph + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "kph" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn motor_status_speed_kph(&self) -> f32 { + self.motor_status_speed_kph_raw() + } + + /// Get raw value of MOTOR_STATUS_speed_kph + /// + /// - Start bit: 8 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn motor_status_speed_kph_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..24].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of MOTOR_STATUS_speed_kph + #[inline(always)] + pub fn set_motor_status_speed_kph(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: MotorStatus::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[8..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MotorStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MotorStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SENSOR_SONARS +/// +/// - Standard ID: 200 (0xc8) +/// - Size: 8 bytes +/// - Transmitter: SENSOR +#[derive(Clone, Copy)] +pub struct SensorSonars { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonars { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0xc8)}); + + pub const SENSOR_SONARS_MUX_MIN: u8 = 0_u8; + pub const SENSOR_SONARS_MUX_MAX: u8 = 0_u8; + pub const SENSOR_SONARS_ERR_COUNT_MIN: u16 = 0_u16; + pub const SENSOR_SONARS_ERR_COUNT_MAX: u16 = 0_u16; + pub const SENSOR_SONARS_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_REAR_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_LEFT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_MIDDLE_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_RIGHT_MAX: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MIN: f32 = 0_f32; + pub const SENSOR_SONARS_NO_FILT_REAR_MAX: f32 = 0_f32; + + /// Construct new SENSOR_SONARS from values + pub fn new(sensor_sonars_mux: u8, sensor_sonars_err_count: u16) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_sensor_sonars_mux(sensor_sonars_mux)?; + res.set_sensor_sonars_err_count(sensor_sonars_err_count)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Get raw value of SENSOR_SONARS_mux + /// + /// - Start bit: 0 + /// - Signal size: 4 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_mux_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..4].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn sensor_sonars_mux(&mut self) -> Result { + match self.sensor_sonars_mux_raw() { + 0 => Ok(SensorSonarsSensorSonarsMuxIndex::M0(SensorSonarsSensorSonarsMuxM0{ raw: self.raw })), + 1 => Ok(SensorSonarsSensorSonarsMuxIndex::M1(SensorSonarsSensorSonarsMuxM1{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: SensorSonars::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + fn set_sensor_sonars_mux(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..4].store_le(value); + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m0(&mut self, value: SensorSonarsSensorSonarsMuxM0) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(0)?; + Ok(()) + } + + /// Set value of SENSOR_SONARS_mux + #[inline(always)] + pub fn set_m1(&mut self, value: SensorSonarsSensorSonarsMuxM1) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_sensor_sonars_mux(1)?; + Ok(()) + } + + /// SENSOR_SONARS_err_count + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: DRIVER, IO + #[inline(always)] + pub fn sensor_sonars_err_count(&self) -> u16 { + self.sensor_sonars_err_count_raw() + } + + /// Get raw value of SENSOR_SONARS_err_count + /// + /// - Start bit: 4 + /// - Signal size: 12 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn sensor_sonars_err_count_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[4..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SENSOR_SONARS_err_count + #[inline(always)] + pub fn set_sensor_sonars_err_count(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[4..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SensorSonars { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SensorSonars { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal SENSOR_SONARS +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum SensorSonarsSensorSonarsMuxIndex { + M0(SensorSonarsSensorSonarsMuxM0), + M1(SensorSonarsSensorSonarsMuxM1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM0 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM0 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_left(&self) -> f32 { + self.sensor_sonars_left_raw() +} + +/// Get raw value of SENSOR_SONARS_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_left +#[inline(always)] +pub fn set_sensor_sonars_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_middle(&self) -> f32 { + self.sensor_sonars_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_middle +#[inline(always)] +pub fn set_sensor_sonars_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_right(&self) -> f32 { + self.sensor_sonars_right_raw() +} + +/// Get raw value of SENSOR_SONARS_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_right +#[inline(always)] +pub fn set_sensor_sonars_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DRIVER, IO +#[inline(always)] +pub fn sensor_sonars_rear(&self) -> f32 { + self.sensor_sonars_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_rear +#[inline(always)] +pub fn set_sensor_sonars_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct SensorSonarsSensorSonarsMuxM1 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SensorSonarsSensorSonarsMuxM1 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// SENSOR_SONARS_no_filt_left +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_left(&self) -> f32 { + self.sensor_sonars_no_filt_left_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_left +/// +/// - Start bit: 16 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_left_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..28].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_left +#[inline(always)] +pub fn set_sensor_sonars_no_filt_left(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..28].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_middle +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_middle(&self) -> f32 { + self.sensor_sonars_no_filt_middle_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_middle +/// +/// - Start bit: 28 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_middle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[28..40].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_middle +#[inline(always)] +pub fn set_sensor_sonars_no_filt_middle(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[28..40].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_right +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_right(&self) -> f32 { + self.sensor_sonars_no_filt_right_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_right +/// +/// - Start bit: 40 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_right_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..52].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_right +#[inline(always)] +pub fn set_sensor_sonars_no_filt_right(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[40..52].store_le(value); + Ok(()) +} + +/// SENSOR_SONARS_no_filt_rear +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: DBG +#[inline(always)] +pub fn sensor_sonars_no_filt_rear(&self) -> f32 { + self.sensor_sonars_no_filt_rear_raw() +} + +/// Get raw value of SENSOR_SONARS_no_filt_rear +/// +/// - Start bit: 52 +/// - Signal size: 12 bits +/// - Factor: 0.1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Unsigned +#[inline(always)] +pub fn sensor_sonars_no_filt_rear_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[52..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset +} + +/// Set value of SENSOR_SONARS_no_filt_rear +#[inline(always)] +pub fn set_sensor_sonars_no_filt_rear(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: SensorSonars::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[52..64].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/test_extended_id_dump.snap b/tests-snapshots/dbc-cantools/test_extended_id_dump.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/test_extended_id_dump.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/test_extended_id_dump.snap.rs b/tests-snapshots/dbc-cantools/test_extended_id_dump.snap.rs new file mode 100644 index 0000000..20b2b6d --- /dev/null +++ b/tests-snapshots/dbc-cantools/test_extended_id_dump.snap.rs @@ -0,0 +1,346 @@ +// Generated code! +// +// Message definitions from file `test_extended_id_dump` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// SomeFrame + SomeFrame(SomeFrame), + /// SomeExtFrame + SomeExtFrame(SomeExtFrame), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + SomeFrame::MESSAGE_ID => Messages::SomeFrame(SomeFrame::try_from(payload)?), + SomeExtFrame::MESSAGE_ID => Messages::SomeExtFrame(SomeExtFrame::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// SomeFrame +/// +/// - Standard ID: 256 (0x100) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SomeFrame { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SomeFrame { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x100)}); + + pub const SOME_DIFFERENT_SIG_MIN: i8 = 0_i8; + pub const SOME_DIFFERENT_SIG_MAX: i8 = 0_i8; + + /// Construct new SomeFrame from values + pub fn new(some_different_sig: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_some_different_sig(some_different_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SomeDifferentSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn some_different_sig(&self) -> i8 { + self.some_different_sig_raw() + } + + /// Get raw value of SomeDifferentSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn some_different_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SomeDifferentSig + #[inline(always)] + pub fn set_some_different_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SomeFrame::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SomeFrame::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SomeFrame { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SomeFrame { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// SomeExtFrame +/// +/// - Extended ID: 472525354 (0x1c2a2a2a) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct SomeExtFrame { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl SomeExtFrame { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x1c2a2a2a)}); + + pub const SOME_SIG_MIN: i8 = 0_i8; + pub const SOME_SIG_MAX: i8 = 0_i8; + + /// Construct new SomeExtFrame from values + pub fn new(some_sig: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_some_sig(some_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// SomeSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn some_sig(&self) -> i8 { + self.some_sig_raw() + } + + /// Get raw value of SomeSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn some_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of SomeSig + #[inline(always)] + pub fn set_some_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: SomeExtFrame::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: SomeExtFrame::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for SomeExtFrame { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for SomeExtFrame { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/test_multiplex_dump.snap b/tests-snapshots/dbc-cantools/test_multiplex_dump.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/test_multiplex_dump.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/test_multiplex_dump.snap.rs b/tests-snapshots/dbc-cantools/test_multiplex_dump.snap.rs new file mode 100644 index 0000000..073cce4 --- /dev/null +++ b/tests-snapshots/dbc-cantools/test_multiplex_dump.snap.rs @@ -0,0 +1,347 @@ +// Generated code! +// +// Message definitions from file `test_multiplex_dump` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// MuxedFrame + MuxedFrame(MuxedFrame), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + MuxedFrame::MESSAGE_ID => Messages::MuxedFrame(MuxedFrame::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// MuxedFrame +/// +/// - Standard ID: 256 (0x100) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct MuxedFrame { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MuxedFrame { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x100)}); + + pub const UNMULTIPLEXED_SIG_MIN: i8 = 0_i8; + pub const UNMULTIPLEXED_SIG_MAX: i8 = 0_i8; + pub const MULTIPLEXED_SIG_MIN: i8 = 0_i8; + pub const MULTIPLEXED_SIG_MAX: i8 = 0_i8; + pub const MULTIPLEXOR_SIG_MIN: u8 = 0_u8; + pub const MULTIPLEXOR_SIG_MAX: u8 = 0_u8; + + /// Construct new MuxedFrame from values + pub fn new(unmultiplexed_sig: i8, multiplexor_sig: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_unmultiplexed_sig(unmultiplexed_sig)?; + res.set_multiplexor_sig(multiplexor_sig)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// UnmultiplexedSig + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn unmultiplexed_sig(&self) -> i8 { + self.unmultiplexed_sig_raw() + } + + /// Get raw value of UnmultiplexedSig + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn unmultiplexed_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of UnmultiplexedSig + #[inline(always)] + pub fn set_unmultiplexed_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MuxedFrame::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MuxedFrame::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Get raw value of MultiplexorSig + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn multiplexor_sig_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + pub fn multiplexor_sig(&mut self) -> Result { + match self.multiplexor_sig_raw() { + 42 => Ok(MuxedFrameMultiplexorSigIndex::M42(MuxedFrameMultiplexorSigM42{ raw: self.raw })), + multiplexor => Err(CanError::InvalidMultiplexor { message_id: MuxedFrame::MESSAGE_ID, multiplexor: multiplexor.into() }), + } + } + /// Set value of MultiplexorSig + #[inline(always)] + fn set_multiplexor_sig(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MuxedFrame::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MuxedFrame::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Set value of MultiplexorSig + #[inline(always)] + pub fn set_m42(&mut self, value: MuxedFrameMultiplexorSigM42) -> Result<(), CanError> { + let b0 = BitArray::<_, LocalBits>::new(self.raw); + let b1 = BitArray::<_, LocalBits>::new(value.raw); + self.raw = b0.bitor(b1).into_inner(); + self.set_multiplexor_sig(42)?; + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for MuxedFrame { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for MuxedFrame { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for multiplexed signal MuxedFrame +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +pub enum MuxedFrameMultiplexorSigIndex { + M42(MuxedFrameMultiplexorSigM42), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Default)] +pub struct MuxedFrameMultiplexorSigM42 { raw: [u8; 8] } + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl MuxedFrameMultiplexorSigM42 { +pub fn new() -> Self { Self { raw: [0u8; 8] } } +/// MultiplexedSig +/// +/// - Min: 0 +/// - Max: 0 +/// - Unit: "" +/// - Receivers: Vector__XXX +#[inline(always)] +pub fn multiplexed_sig(&self) -> i8 { + self.multiplexed_sig_raw() +} + +/// Get raw value of MultiplexedSig +/// +/// - Start bit: 8 +/// - Signal size: 8 bits +/// - Factor: 1 +/// - Offset: 0 +/// - Byte order: LittleEndian +/// - Value type: Signed +#[inline(always)] +pub fn multiplexed_sig_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) +} + +/// Set value of MultiplexedSig +#[inline(always)] +pub fn set_multiplexed_sig(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: MuxedFrame::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: MuxedFrame::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) +} + +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/timing.snap b/tests-snapshots/dbc-cantools/timing.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/timing.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/timing.snap.rs b/tests-snapshots/dbc-cantools/timing.snap.rs new file mode 100644 index 0000000..3676f52 --- /dev/null +++ b/tests-snapshots/dbc-cantools/timing.snap.rs @@ -0,0 +1,346 @@ +// Generated code! +// +// Message definitions from file `timing` +// Version: 3.0 + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Foo + Foo(Foo), + /// Bar + Bar(Bar), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Foo::MESSAGE_ID => Messages::Foo(Foo::try_from(payload)?), + Bar::MESSAGE_ID => Messages::Bar(Bar::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Foo +/// +/// - Standard ID: 1 (0x1) +/// - Size: 8 bytes +/// - Transmitter: Sender +#[derive(Clone, Copy)] +pub struct Foo { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Foo { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x1)}); + + pub const FOO_MIN: f32 = 229.53_f32; + pub const FOO_MAX: f32 = 270.47_f32; + + /// Construct new Foo from values + pub fn new(foo: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_foo(foo)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Foo + /// + /// - Min: 229.53 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: Receiver + #[inline(always)] + pub fn foo(&self) -> f32 { + self.foo_raw() + } + + /// Get raw value of Foo + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn foo_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Foo + #[inline(always)] + pub fn set_foo(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.53_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Foo::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Foo { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Foo { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// Bar +/// +/// - Standard ID: 2 (0x2) +/// - Size: 8 bytes +/// - Transmitter: Sender +#[derive(Clone, Copy)] +pub struct Bar { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Bar { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x2)}); + + pub const FOO_MIN: f32 = 229.53_f32; + pub const FOO_MAX: f32 = 270.47_f32; + + /// Construct new Bar from values + pub fn new(foo: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_foo(foo)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Foo + /// + /// - Min: 229.53 + /// - Max: 270.47 + /// - Unit: "degK" + /// - Receivers: Receiver + #[inline(always)] + pub fn foo(&self) -> f32 { + self.foo_raw() + } + + /// Get raw value of Foo + /// + /// - Start bit: 0 + /// - Signal size: 12 bits + /// - Factor: 0.01 + /// - Offset: 250 + /// - Byte order: BigEndian + /// - Value type: Signed + #[inline(always)] + pub fn foo_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[7..19].load_be::(); + + let factor = 0.01_f32; + let offset = 250_f32; + (signal as f32) * factor + offset + } + + /// Set value of Foo + #[inline(always)] + pub fn set_foo(&mut self, value: f32) -> Result<(), CanError> { + if value < 229.53_f32 || 270.47_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: Bar::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 250_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[7..19].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Bar { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Bar { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/val_table.snap b/tests-snapshots/dbc-cantools/val_table.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/val_table.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/val_table.snap.rs b/tests-snapshots/dbc-cantools/val_table.snap.rs new file mode 100644 index 0000000..74d1e38 --- /dev/null +++ b/tests-snapshots/dbc-cantools/val_table.snap.rs @@ -0,0 +1,245 @@ +// Generated code! +// +// Message definitions from file `val_table` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// Message1 + Message1(Message1), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + Message1::MESSAGE_ID => Messages::Message1(Message1::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// Message1 +/// +/// - Standard ID: 0 (0x0) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct Message1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Message1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Standard(unsafe { StandardId::new_unchecked(0x0)}); + + pub const SIGNAL1_MIN: i8 = 0_i8; + pub const SIGNAL1_MAX: i8 = 0_i8; + + /// Construct new Message1 from values + pub fn new(signal1: i8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_signal1(signal1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn signal1(&self) -> Message1Signal1 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 1 => Message1Signal1::One, + 0 => Message1Signal1::Zero, + _ => Message1Signal1::_Other(self.signal1_raw()), + } + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn signal1_raw(&self) -> i8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + let signal = signal as i8; + i8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: i8) -> Result<(), CanError> { + if value < 0_i8 || 0_i8 < value { + return Err(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: Message1::MESSAGE_ID })?; + let value = (value / factor) as i8; + + let value = u8::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for Message1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for Message1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Signal1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum Message1Signal1 { + One, + Zero, + _Other(i8), +} + +impl From for i8 { + fn from(val: Message1Signal1) -> i8 { + match val { + Message1Signal1::One => 1, + Message1Signal1::Zero => 0, + Message1Signal1::_Other(x) => x, + } + } +} + + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/variable_dlc.snap b/tests-snapshots/dbc-cantools/variable_dlc.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/variable_dlc.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/variable_dlc.snap.rs b/tests-snapshots/dbc-cantools/variable_dlc.snap.rs new file mode 100644 index 0000000..30c0a3f --- /dev/null +++ b/tests-snapshots/dbc-cantools/variable_dlc.snap.rs @@ -0,0 +1,614 @@ +// Generated code! +// +// Message definitions from file `variable_dlc` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// TestMessage1 + TestMessage1(TestMessage1), + /// TestMessage2 + TestMessage2(TestMessage2), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + TestMessage1::MESSAGE_ID => Messages::TestMessage1(TestMessage1::try_from(payload)?), + TestMessage2::MESSAGE_ID => Messages::TestMessage2(TestMessage2::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// TestMessage1 +/// +/// - Extended ID: 16711936 (0xff0100) +/// - Size: 3 bytes +/// - Transmitter: Test +#[derive(Clone, Copy)] +pub struct TestMessage1 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMessage1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xff0100)}); + + pub const SIGNAL1_MIN: u8 = 0_u8; + pub const SIGNAL1_MAX: u8 = 0_u8; + pub const SIGNAL2_MIN: u8 = 0_u8; + pub const SIGNAL2_MAX: u8 = 0_u8; + pub const SIGNAL3_MIN: u8 = 0_u8; + pub const SIGNAL3_MAX: u8 = 0_u8; + + /// Construct new TestMessage1 from values + pub fn new(signal1: u8, signal2: u8, signal3: u8) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_signal1(signal1)?; + res.set_signal2(signal2)?; + res.set_signal3(signal3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Signal1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal1(&self) -> u8 { + self.signal1_raw() + } + + /// Get raw value of Signal1 + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal1_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal1 + #[inline(always)] + pub fn set_signal1(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + + /// Signal2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal2(&self) -> u8 { + self.signal2_raw() + } + + /// Get raw value of Signal2 + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal2 + #[inline(always)] + pub fn set_signal2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Signal3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal3(&self) -> u8 { + self.signal3_raw() + } + + /// Get raw value of Signal3 + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal3_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal3 + #[inline(always)] + pub fn set_signal3(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMessage1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMessage1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// TestMessage2 +/// +/// - Extended ID: 16712192 (0xff0200) +/// - Size: 10 bytes +/// - Transmitter: Test +#[derive(Clone, Copy)] +pub struct TestMessage2 { + raw: [u8; 10], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl TestMessage2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0xff0200)}); + + pub const SIGNAL4_MIN: u16 = 0_u16; + pub const SIGNAL4_MAX: u16 = 0_u16; + pub const SIGNAL5_MIN: u16 = 0_u16; + pub const SIGNAL5_MAX: u16 = 0_u16; + pub const SIGNAL6_MIN: u16 = 0_u16; + pub const SIGNAL6_MAX: u16 = 0_u16; + pub const SIGNAL7_MIN: u16 = 0_u16; + pub const SIGNAL7_MAX: u16 = 0_u16; + pub const SIGNAL8_MIN: u16 = 0_u16; + pub const SIGNAL8_MAX: u16 = 0_u16; + + /// Construct new TestMessage2 from values + pub fn new(signal4: u16, signal5: u16, signal6: u16, signal7: u16, signal8: u16) -> Result { + let mut res = Self { raw: [0u8; 10] }; + res.set_signal4(signal4)?; + res.set_signal5(signal5)?; + res.set_signal6(signal6)?; + res.set_signal7(signal7)?; + res.set_signal8(signal8)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 10] { + &self.raw + } + + /// Signal4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal4(&self) -> u16 { + self.signal4_raw() + } + + /// Get raw value of Signal4 + /// + /// - Start bit: 0 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal4_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[0..15].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal4 + #[inline(always)] + pub fn set_signal4(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[0..15].store_le(value); + Ok(()) + } + + /// Signal5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal5(&self) -> u16 { + self.signal5_raw() + } + + /// Get raw value of Signal5 + /// + /// - Start bit: 15 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal5_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[15..30].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal5 + #[inline(always)] + pub fn set_signal5(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[15..30].store_le(value); + Ok(()) + } + + /// Signal6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal6(&self) -> u16 { + self.signal6_raw() + } + + /// Get raw value of Signal6 + /// + /// - Start bit: 30 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal6_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[30..45].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal6 + #[inline(always)] + pub fn set_signal6(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[30..45].store_le(value); + Ok(()) + } + + /// Signal7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal7(&self) -> u16 { + self.signal7_raw() + } + + /// Get raw value of Signal7 + /// + /// - Start bit: 45 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal7_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[45..60].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal7 + #[inline(always)] + pub fn set_signal7(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[45..60].store_le(value); + Ok(()) + } + + /// Signal8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Test + #[inline(always)] + pub fn signal8(&self) -> u16 { + self.signal8_raw() + } + + /// Get raw value of Signal8 + /// + /// - Start bit: 60 + /// - Signal size: 15 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn signal8_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[60..75].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Signal8 + #[inline(always)] + pub fn set_signal8(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: TestMessage2::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[60..75].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for TestMessage2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 10 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 10]; + raw.copy_from_slice(&payload[..10]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for TestMessage2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/vehicle.snap b/tests-snapshots/dbc-cantools/vehicle.snap new file mode 100644 index 0000000..83bc186 --- /dev/null +++ b/tests-snapshots/dbc-cantools/vehicle.snap @@ -0,0 +1,5 @@ +--- +source: tests/snapshots.rs +extension: rs +snapshot_kind: binary +--- diff --git a/tests-snapshots/dbc-cantools/vehicle.snap.rs b/tests-snapshots/dbc-cantools/vehicle.snap.rs new file mode 100644 index 0000000..045de25 --- /dev/null +++ b/tests-snapshots/dbc-cantools/vehicle.snap.rs @@ -0,0 +1,39996 @@ +// Generated code! +// +// Message definitions from file `vehicle` +// Version: + +#[allow(unused_imports)] +use core::ops::BitOr; +#[allow(unused_imports)] +use bitvec::prelude::*; +#[allow(unused_imports)] +use embedded_can::{Id, StandardId, ExtendedId}; + +/// All messages +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone)] +pub enum Messages { + /// RT_SB_INS_Vel_Body_Axes + RtSbInsVelBodyAxes(RtSbInsVelBodyAxes), + /// RT_DL1MK3_Speed + RtDl1mk3Speed(RtDl1mk3Speed), + /// RT_DL1MK3_GPS_Time + RtDl1mk3GpsTime(RtDl1mk3GpsTime), + /// RT_DL1MK3_GPS_Pos_LLH_2 + RtDl1mk3GpsPosLlh2(RtDl1mk3GpsPosLlh2), + /// RT_DL1MK3_GPS_Pos_LLH_1 + RtDl1mk3GpsPosLlh1(RtDl1mk3GpsPosLlh1), + /// RT_DL1MK3_GPS_Speed + RtDl1mk3GpsSpeed(RtDl1mk3GpsSpeed), + /// RT_IRTemp_Temp_7 + RtIrTempTemp7(RtIrTempTemp7), + /// RT_IRTemp_Temp_RR_2 + RtIrTempTempRr2(RtIrTempTempRr2), + /// RT_IRTemp_Temp_RL_2 + RtIrTempTempRl2(RtIrTempTempRl2), + /// RT_IRTemp_Temp_FR_2 + RtIrTempTempFr2(RtIrTempTempFr2), + /// RT_IRTemp_Temp_FL_2 + RtIrTempTempFl2(RtIrTempTempFl2), + /// RT_IRTemp_Temp_RR_1 + RtIrTempTempRr1(RtIrTempTempRr1), + /// RT_IRTemp_Temp_RL_1 + RtIrTempTempRl1(RtIrTempTempRl1), + /// RT_IRTemp_Temp_FR_1 + RtIrTempTempFr1(RtIrTempTempFr1), + /// RT_IRTemp_Temp_FL_1 + RtIrTempTempFl1(RtIrTempTempFl1), + /// RT_IRTemp_Temp_32 + RtIrTempTemp32(RtIrTempTemp32), + /// RT_IRTemp_Temp_31 + RtIrTempTemp31(RtIrTempTemp31), + /// RT_IRTemp_Temp_30 + RtIrTempTemp30(RtIrTempTemp30), + /// RT_IRTemp_Temp_29 + RtIrTempTemp29(RtIrTempTemp29), + /// RT_IRTemp_Temp_28 + RtIrTempTemp28(RtIrTempTemp28), + /// RT_IRTemp_Temp_27 + RtIrTempTemp27(RtIrTempTemp27), + /// RT_IRTemp_Temp_26 + RtIrTempTemp26(RtIrTempTemp26), + /// RT_IRTemp_Temp_25 + RtIrTempTemp25(RtIrTempTemp25), + /// RT_IRTemp_Temp_24 + RtIrTempTemp24(RtIrTempTemp24), + /// RT_IRTemp_Temp_22 + RtIrTempTemp22(RtIrTempTemp22), + /// RT_IRTemp_Temp_23 + RtIrTempTemp23(RtIrTempTemp23), + /// RT_IRTemp_Temp_21 + RtIrTempTemp21(RtIrTempTemp21), + /// RT_IRTemp_Temp_20 + RtIrTempTemp20(RtIrTempTemp20), + /// RT_IRTemp_Temp_19 + RtIrTempTemp19(RtIrTempTemp19), + /// RT_IRTemp_Temp_18 + RtIrTempTemp18(RtIrTempTemp18), + /// RT_IRTemp_Temp_16 + RtIrTempTemp16(RtIrTempTemp16), + /// RT_IRTemp_Temp_15 + RtIrTempTemp15(RtIrTempTemp15), + /// RT_IRTemp_Temp_14 + RtIrTempTemp14(RtIrTempTemp14), + /// RT_IRTemp_Temp_13 + RtIrTempTemp13(RtIrTempTemp13), + /// RT_IRTemp_Temp_12 + RtIrTempTemp12(RtIrTempTemp12), + /// RT_IRTemp_Temp_11 + RtIrTempTemp11(RtIrTempTemp11), + /// RT_IRTemp_Temp_10 + RtIrTempTemp10(RtIrTempTemp10), + /// RT_IRTemp_Temp_8 + RtIrTempTemp8(RtIrTempTemp8), + /// RT_IRTemp_Temp_9 + RtIrTempTemp9(RtIrTempTemp9), + /// RT_IRTemp_Temp_17 + RtIrTempTemp17(RtIrTempTemp17), + /// RT_IRTemp_Temp_6 + RtIrTempTemp6(RtIrTempTemp6), + /// RT_IRTemp_Temp_5 + RtIrTempTemp5(RtIrTempTemp5), + /// RT_IRTemp_Temp_4 + RtIrTempTemp4(RtIrTempTemp4), + /// RT_IRTemp_Temp_3 + RtIrTempTemp3(RtIrTempTemp3), + /// RT_IRTemp_Temp_2 + RtIrTempTemp2(RtIrTempTemp2), + /// RT_IRTemp_Temp_1 + RtIrTempTemp1(RtIrTempTemp1), + /// RT_SB_Trig_Final_Condition + RtSbTrigFinalCondition(RtSbTrigFinalCondition), + /// RT_SB_Trig_Initial_Condition + RtSbTrigInitialCondition(RtSbTrigInitialCondition), + /// RT_SB_Trig_Direct_Dist + RtSbTrigDirectDist(RtSbTrigDirectDist), + /// RT_SB_Trig_Forward_Dist + RtSbTrigForwardDist(RtSbTrigForwardDist), + /// RT_SB_Trig_Path_Dist + RtSbTrigPathDist(RtSbTrigPathDist), + /// RT_SB_Trig_Accel + RtSbTrigAccel(RtSbTrigAccel), + /// RT_DL1MK3_Measure_Time_12 + RtDl1mk3MeasureTime12(RtDl1mk3MeasureTime12), + /// RT_DL1MK3_Measure_Time_11 + RtDl1mk3MeasureTime11(RtDl1mk3MeasureTime11), + /// RT_DL1MK3_Measure_Time_10 + RtDl1mk3MeasureTime10(RtDl1mk3MeasureTime10), + /// RT_DL1MK3_Measure_Time_9 + RtDl1mk3MeasureTime9(RtDl1mk3MeasureTime9), + /// RT_DL1MK3_Measure_Time_8 + RtDl1mk3MeasureTime8(RtDl1mk3MeasureTime8), + /// RT_DL1MK3_Measure_Time_7 + RtDl1mk3MeasureTime7(RtDl1mk3MeasureTime7), + /// RT_DL1MK3_Measure_Time_6 + RtDl1mk3MeasureTime6(RtDl1mk3MeasureTime6), + /// RT_DL1MK3_Measure_Time_5 + RtDl1mk3MeasureTime5(RtDl1mk3MeasureTime5), + /// RT_DL1MK3_Measure_Time_4 + RtDl1mk3MeasureTime4(RtDl1mk3MeasureTime4), + /// RT_DL1MK3_Measure_Time_3 + RtDl1mk3MeasureTime3(RtDl1mk3MeasureTime3), + /// RT_DL1MK3_Measure_Time_2 + RtDl1mk3MeasureTime2(RtDl1mk3MeasureTime2), + /// RT_DL1MK3_Measure_Time_1 + RtDl1mk3MeasureTime1(RtDl1mk3MeasureTime1), + /// RT_DL1MK3_RPM + RtDl1mk3Rpm(RtDl1mk3Rpm), + /// RT_DL1MK3_Freq_4 + RtDl1mk3Freq4(RtDl1mk3Freq4), + /// RT_DL1MK3_Freq_3 + RtDl1mk3Freq3(RtDl1mk3Freq3), + /// RT_DL1MK3_Freq_2 + RtDl1mk3Freq2(RtDl1mk3Freq2), + /// RT_DL1MK3_Misc_3 + RtDl1mk3Misc3(RtDl1mk3Misc3), + /// RT_DL1MK3_Misc_2 + RtDl1mk3Misc2(RtDl1mk3Misc2), + /// RT_DL1MK3_Misc_1 + RtDl1mk3Misc1(RtDl1mk3Misc1), + /// RT_DL1MK3_Aux_31 + RtDl1mk3Aux31(RtDl1mk3Aux31), + /// RT_DL1MK3_Aux_30 + RtDl1mk3Aux30(RtDl1mk3Aux30), + /// RT_DL1MK3_Aux_29 + RtDl1mk3Aux29(RtDl1mk3Aux29), + /// RT_DL1MK3_Aux_28 + RtDl1mk3Aux28(RtDl1mk3Aux28), + /// RT_DL1MK3_Aux_27 + RtDl1mk3Aux27(RtDl1mk3Aux27), + /// RT_DL1MK3_Aux_26 + RtDl1mk3Aux26(RtDl1mk3Aux26), + /// RT_DL1MK3_Aux_25 + RtDl1mk3Aux25(RtDl1mk3Aux25), + /// RT_DL1MK3_Aux_24 + RtDl1mk3Aux24(RtDl1mk3Aux24), + /// RT_DL1MK3_Aux_23 + RtDl1mk3Aux23(RtDl1mk3Aux23), + /// RT_DL1MK3_Aux_22 + RtDl1mk3Aux22(RtDl1mk3Aux22), + /// RT_DL1MK3_Aux_21 + RtDl1mk3Aux21(RtDl1mk3Aux21), + /// RT_DL1MK3_Aux_20 + RtDl1mk3Aux20(RtDl1mk3Aux20), + /// RT_DL1MK3_Aux_19 + RtDl1mk3Aux19(RtDl1mk3Aux19), + /// RT_DL1MK3_Aux_18 + RtDl1mk3Aux18(RtDl1mk3Aux18), + /// RT_DL1MK3_Aux_17 + RtDl1mk3Aux17(RtDl1mk3Aux17), + /// RT_DL1MK3_Aux_16 + RtDl1mk3Aux16(RtDl1mk3Aux16), + /// RT_DL1MK3_Aux_15 + RtDl1mk3Aux15(RtDl1mk3Aux15), + /// RT_DL1MK3_Aux_14 + RtDl1mk3Aux14(RtDl1mk3Aux14), + /// RT_DL1MK3_Aux_13 + RtDl1mk3Aux13(RtDl1mk3Aux13), + /// RT_DL1MK3_Aux_12 + RtDl1mk3Aux12(RtDl1mk3Aux12), + /// RT_DL1MK3_Aux_11 + RtDl1mk3Aux11(RtDl1mk3Aux11), + /// RT_DL1MK3_Aux_9 + RtDl1mk3Aux9(RtDl1mk3Aux9), + /// RT_DL1MK3_Aux_10 + RtDl1mk3Aux10(RtDl1mk3Aux10), + /// RT_DL1MK3_Aux_8 + RtDl1mk3Aux8(RtDl1mk3Aux8), + /// RT_DL1MK3_Aux_7 + RtDl1mk3Aux7(RtDl1mk3Aux7), + /// RT_DL1MK3_Aux_6 + RtDl1mk3Aux6(RtDl1mk3Aux6), + /// RT_DL1MK3_Aux_5 + RtDl1mk3Aux5(RtDl1mk3Aux5), + /// RT_DL1MK3_Aux_4 + RtDl1mk3Aux4(RtDl1mk3Aux4), + /// RT_DL1MK3_Aux_3 + RtDl1mk3Aux3(RtDl1mk3Aux3), + /// RT_DL1MK3_Aux_2 + RtDl1mk3Aux2(RtDl1mk3Aux2), + /// RT_DL1MK3_Aux_1 + RtDl1mk3Aux1(RtDl1mk3Aux1), + /// RT_DL1MK3_Pressure_5 + RtDl1mk3Pressure5(RtDl1mk3Pressure5), + /// RT_DL1MK3_Pressure_4 + RtDl1mk3Pressure4(RtDl1mk3Pressure4), + /// RT_DL1MK3_Pressure_3 + RtDl1mk3Pressure3(RtDl1mk3Pressure3), + /// RT_DL1MK3_Pressure_2 + RtDl1mk3Pressure2(RtDl1mk3Pressure2), + /// RT_DL1MK3_Pressure_1 + RtDl1mk3Pressure1(RtDl1mk3Pressure1), + /// RT_DL1MK3_Angle_3 + RtDl1mk3Angle3(RtDl1mk3Angle3), + /// RT_DL1MK3_Angle_2 + RtDl1mk3Angle2(RtDl1mk3Angle2), + /// RT_DL1MK3_Angle_1 + RtDl1mk3Angle1(RtDl1mk3Angle1), + /// RT_DL1MK3_Temp_25 + RtDl1mk3Temp25(RtDl1mk3Temp25), + /// RT_DL1MK3_Temp_24 + RtDl1mk3Temp24(RtDl1mk3Temp24), + /// RT_DL1MK3_Temp_23 + RtDl1mk3Temp23(RtDl1mk3Temp23), + /// RT_DL1MK3_Temp_22 + RtDl1mk3Temp22(RtDl1mk3Temp22), + /// RT_DL1MK3_Temp_21 + RtDl1mk3Temp21(RtDl1mk3Temp21), + /// RT_DL1MK3_Temp_20 + RtDl1mk3Temp20(RtDl1mk3Temp20), + /// RT_DL1MK3_Temp_19 + RtDl1mk3Temp19(RtDl1mk3Temp19), + /// RT_DL1MK3_Temp_18 + RtDl1mk3Temp18(RtDl1mk3Temp18), + /// RT_DL1MK3_Temp_17 + RtDl1mk3Temp17(RtDl1mk3Temp17), + /// RT_DL1MK3_Temp_16 + RtDl1mk3Temp16(RtDl1mk3Temp16), + /// RT_DL1MK3_Temp_15 + RtDl1mk3Temp15(RtDl1mk3Temp15), + /// RT_DL1MK3_Temp_14 + RtDl1mk3Temp14(RtDl1mk3Temp14), + /// RT_DL1MK3_Temp_13 + RtDl1mk3Temp13(RtDl1mk3Temp13), + /// RT_DL1MK3_Temp_12 + RtDl1mk3Temp12(RtDl1mk3Temp12), + /// RT_DL1MK3_Temp_11 + RtDl1mk3Temp11(RtDl1mk3Temp11), + /// RT_DL1MK3_Temp_10 + RtDl1mk3Temp10(RtDl1mk3Temp10), + /// RT_DL1MK3_Temp_9 + RtDl1mk3Temp9(RtDl1mk3Temp9), + /// RT_DL1MK3_Temp_8 + RtDl1mk3Temp8(RtDl1mk3Temp8), + /// RT_DL1MK3_Temp_7 + RtDl1mk3Temp7(RtDl1mk3Temp7), + /// RT_DL1MK3_Temp_6 + RtDl1mk3Temp6(RtDl1mk3Temp6), + /// RT_DL1MK3_Temp_5 + RtDl1mk3Temp5(RtDl1mk3Temp5), + /// RT_DL1MK3_Temp_4 + RtDl1mk3Temp4(RtDl1mk3Temp4), + /// RT_DL1MK3_Temp_3 + RtDl1mk3Temp3(RtDl1mk3Temp3), + /// RT_DL1MK3_Temp_2 + RtDl1mk3Temp2(RtDl1mk3Temp2), + /// RT_DL1MK3_Temp_1 + RtDl1mk3Temp1(RtDl1mk3Temp1), + /// RT_DL1MK3_Analog_32 + RtDl1mk3Analog32(RtDl1mk3Analog32), + /// RT_DL1MK3_Analog_31 + RtDl1mk3Analog31(RtDl1mk3Analog31), + /// RT_DL1MK3_Analog_30 + RtDl1mk3Analog30(RtDl1mk3Analog30), + /// RT_DL1MK3_Analog_29 + RtDl1mk3Analog29(RtDl1mk3Analog29), + /// RT_DL1MK3_Analog_28 + RtDl1mk3Analog28(RtDl1mk3Analog28), + /// RT_DL1MK3_Analog_27 + RtDl1mk3Analog27(RtDl1mk3Analog27), + /// RT_DL1MK3_Analog_26 + RtDl1mk3Analog26(RtDl1mk3Analog26), + /// RT_DL1MK3_Analog_25 + RtDl1mk3Analog25(RtDl1mk3Analog25), + /// RT_DL1MK3_Analog_15 + RtDl1mk3Analog15(RtDl1mk3Analog15), + /// RT_DL1MK3_Analog_14 + RtDl1mk3Analog14(RtDl1mk3Analog14), + /// RT_DL1MK3_Analog_17 + RtDl1mk3Analog17(RtDl1mk3Analog17), + /// RT_DL1MK3_Analog_24 + RtDl1mk3Analog24(RtDl1mk3Analog24), + /// RT_DL1MK3_Analog_23 + RtDl1mk3Analog23(RtDl1mk3Analog23), + /// RT_DL1MK3_Analog_22 + RtDl1mk3Analog22(RtDl1mk3Analog22), + /// RT_DL1MK3_Analog_21 + RtDl1mk3Analog21(RtDl1mk3Analog21), + /// RT_DL1MK3_Analog_20 + RtDl1mk3Analog20(RtDl1mk3Analog20), + /// RT_DL1MK3_Analog_19 + RtDl1mk3Analog19(RtDl1mk3Analog19), + /// RT_DL1MK3_Analog_16 + RtDl1mk3Analog16(RtDl1mk3Analog16), + /// RT_DL1MK3_Analog_18 + RtDl1mk3Analog18(RtDl1mk3Analog18), + /// RT_DL1MK3_Analog_12 + RtDl1mk3Analog12(RtDl1mk3Analog12), + /// RT_DL1MK3_Analog_11 + RtDl1mk3Analog11(RtDl1mk3Analog11), + /// RT_DL1MK3_Analog_10 + RtDl1mk3Analog10(RtDl1mk3Analog10), + /// RT_DL1MK3_Analog_9 + RtDl1mk3Analog9(RtDl1mk3Analog9), + /// RT_DL1MK3_Analog_8 + RtDl1mk3Analog8(RtDl1mk3Analog8), + /// RT_DL1MK3_Analog_7 + RtDl1mk3Analog7(RtDl1mk3Analog7), + /// RT_DL1MK3_Analog_6 + RtDl1mk3Analog6(RtDl1mk3Analog6), + /// RT_DL1MK3_Analog_5 + RtDl1mk3Analog5(RtDl1mk3Analog5), + /// RT_DL1MK3_Analog_4 + RtDl1mk3Analog4(RtDl1mk3Analog4), + /// RT_DL1MK3_Analog_3 + RtDl1mk3Analog3(RtDl1mk3Analog3), + /// RT_DL1MK3_Analog_2 + RtDl1mk3Analog2(RtDl1mk3Analog2), + /// RT_DL1MK3_Analog_1 + RtDl1mk3Analog1(RtDl1mk3Analog1), + /// RT_DL1MK3_Accel + RtDl1mk3Accel(RtDl1mk3Accel), + /// RT_SB_INS_Vpt_4_Vel_NED_2 + RtSbInsVpt4VelNed2(RtSbInsVpt4VelNed2), + /// RT_SB_INS_Vpt_4_Vel_NED_1 + RtSbInsVpt4VelNed1(RtSbInsVpt4VelNed1), + /// RT_SB_INS_Vpt_4_Offset + RtSbInsVpt4Offset(RtSbInsVpt4Offset), + /// RT_SB_INS_Vpt_3_Vel_NED_2 + RtSbInsVpt3VelNed2(RtSbInsVpt3VelNed2), + /// RT_SB_INS_Vpt_3_Vel_NED_1 + RtSbInsVpt3VelNed1(RtSbInsVpt3VelNed1), + /// RT_SB_INS_Vpt_3_Offset + RtSbInsVpt3Offset(RtSbInsVpt3Offset), + /// RT_SB_INS_Vpt_2_Vel_NED_2 + RtSbInsVpt2VelNed2(RtSbInsVpt2VelNed2), + /// RT_SB_INS_Vpt_2_Vel_NED_1 + RtSbInsVpt2VelNed1(RtSbInsVpt2VelNed1), + /// RT_SB_INS_Vpt_2_Offset + RtSbInsVpt2Offset(RtSbInsVpt2Offset), + /// RT_SB_INS_Vpt_1_Vel_NED_2 + RtSbInsVpt1VelNed2(RtSbInsVpt1VelNed2), + /// RT_SB_INS_Vpt_1_Vel_NED_1 + RtSbInsVpt1VelNed1(RtSbInsVpt1VelNed1), + /// RT_SB_INS_Vpt_1_Offset + RtSbInsVpt1Offset(RtSbInsVpt1Offset), + /// RT_SB_INS_Slip + RtSbInsSlip(RtSbInsSlip), + /// RT_SB_INS_Vel_ECEF_2 + RtSbInsVelEcef2(RtSbInsVelEcef2), + /// RT_SB_INS_Vel_ECEF_1 + RtSbInsVelEcef1(RtSbInsVelEcef1), + /// RT_SB_INS_Vel_NED_2 + RtSbInsVelNed2(RtSbInsVelNed2), + /// RT_SB_INS_Vel_NED_1 + RtSbInsVelNed1(RtSbInsVelNed1), + /// RT_SB_INS_Pos_ECEF_2 + RtSbInsPosEcef2(RtSbInsPosEcef2), + /// RT_SB_INS_Pos_ECEF_1 + RtSbInsPosEcef1(RtSbInsPosEcef1), + /// RT_SB_INS_Pos_LLH_2 + RtSbInsPosLlh2(RtSbInsPosLlh2), + /// RT_SB_INS_Pos_LLH_1 + RtSbInsPosLlh1(RtSbInsPosLlh1), + /// RT_SB_INS_Heading_Gradient_2 + RtSbInsHeadingGradient2(RtSbInsHeadingGradient2), + /// RT_SB_INS_Heading_Gradient + RtSbInsHeadingGradient(RtSbInsHeadingGradient), + /// RT_SB_INS_Status + RtSbInsStatus(RtSbInsStatus), + /// RT_SB_INS_Attitude + RtSbInsAttitude(RtSbInsAttitude), + /// RT_SB_Output_Status + RtSbOutputStatus(RtSbOutputStatus), + /// RT_SB_GPS_Heading_Gradient_2 + RtSbGpsHeadingGradient2(RtSbGpsHeadingGradient2), + /// RT_SB_Cumulative_Distance_2 + RtSbCumulativeDistance2(RtSbCumulativeDistance2), + /// RT_SB_Cumulative_Distance_1 + RtSbCumulativeDistance1(RtSbCumulativeDistance1), + /// RT_SB_Trigger_Timestamp + RtSbTriggerTimestamp(RtSbTriggerTimestamp), + /// RT_IMU06_Gyro_Rates + RtImu06GyroRates(RtImu06GyroRates), + /// RT_IMU06_Accel + RtImu06Accel(RtImu06Accel), + /// RT_SB_Speed + RtSbSpeed(RtSbSpeed), + /// RT_SB_RTK_Slip + RtSbRtkSlip(RtSbRtkSlip), + /// RT_SB_RTK_Attitude + RtSbRtkAttitude(RtSbRtkAttitude), + /// RT_SB_GPS_Mcycle_Lean + RtSbGpsMcycleLean(RtSbGpsMcycleLean), + /// RT_SB_GPS_Status + RtSbGpsStatus(RtSbGpsStatus), + /// RT_SB_GPS_Pos_ECEF_2 + RtSbGpsPosEcef2(RtSbGpsPosEcef2), + /// RT_SB_GPS_Pos_ECEF_1 + RtSbGpsPosEcef1(RtSbGpsPosEcef1), + /// RT_SB_GPS_Pos_LLH_2 + RtSbGpsPosLlh2(RtSbGpsPosLlh2), + /// RT_SB_GPS_Pos_LLH_1 + RtSbGpsPosLlh1(RtSbGpsPosLlh1), + /// RT_SB_GPS_Heading_Gradient + RtSbGpsHeadingGradient(RtSbGpsHeadingGradient), + /// RT_SB_GPS_Vel_ECEF_2 + RtSbGpsVelEcef2(RtSbGpsVelEcef2), + /// RT_SB_GPS_Vel_ECEF_1 + RtSbGpsVelEcef1(RtSbGpsVelEcef1), + /// RT_SB_GPS_Vel_NED_2 + RtSbGpsVelNed2(RtSbGpsVelNed2), + /// RT_SB_GPS_Vel_NED_1 + RtSbGpsVelNed1(RtSbGpsVelNed1), + /// RT_SB_GPS_Speed + RtSbGpsSpeed(RtSbGpsSpeed), + /// RT_SB_GPS_Time + RtSbGpsTime(RtSbGpsTime), + /// RT_SB_Accel + RtSbAccel(RtSbAccel), + /// RT_SB_Gyro_Rates + RtSbGyroRates(RtSbGyroRates), +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl Messages { + /// Read message from CAN frame + #[inline(never)] + pub fn from_can_message(id: Id, payload: &[u8]) -> Result { + + let res = match id { + RtSbInsVelBodyAxes::MESSAGE_ID => Messages::RtSbInsVelBodyAxes(RtSbInsVelBodyAxes::try_from(payload)?), + RtDl1mk3Speed::MESSAGE_ID => Messages::RtDl1mk3Speed(RtDl1mk3Speed::try_from(payload)?), + RtDl1mk3GpsTime::MESSAGE_ID => Messages::RtDl1mk3GpsTime(RtDl1mk3GpsTime::try_from(payload)?), + RtDl1mk3GpsPosLlh2::MESSAGE_ID => Messages::RtDl1mk3GpsPosLlh2(RtDl1mk3GpsPosLlh2::try_from(payload)?), + RtDl1mk3GpsPosLlh1::MESSAGE_ID => Messages::RtDl1mk3GpsPosLlh1(RtDl1mk3GpsPosLlh1::try_from(payload)?), + RtDl1mk3GpsSpeed::MESSAGE_ID => Messages::RtDl1mk3GpsSpeed(RtDl1mk3GpsSpeed::try_from(payload)?), + RtIrTempTemp7::MESSAGE_ID => Messages::RtIrTempTemp7(RtIrTempTemp7::try_from(payload)?), + RtIrTempTempRr2::MESSAGE_ID => Messages::RtIrTempTempRr2(RtIrTempTempRr2::try_from(payload)?), + RtIrTempTempRl2::MESSAGE_ID => Messages::RtIrTempTempRl2(RtIrTempTempRl2::try_from(payload)?), + RtIrTempTempFr2::MESSAGE_ID => Messages::RtIrTempTempFr2(RtIrTempTempFr2::try_from(payload)?), + RtIrTempTempFl2::MESSAGE_ID => Messages::RtIrTempTempFl2(RtIrTempTempFl2::try_from(payload)?), + RtIrTempTempRr1::MESSAGE_ID => Messages::RtIrTempTempRr1(RtIrTempTempRr1::try_from(payload)?), + RtIrTempTempRl1::MESSAGE_ID => Messages::RtIrTempTempRl1(RtIrTempTempRl1::try_from(payload)?), + RtIrTempTempFr1::MESSAGE_ID => Messages::RtIrTempTempFr1(RtIrTempTempFr1::try_from(payload)?), + RtIrTempTempFl1::MESSAGE_ID => Messages::RtIrTempTempFl1(RtIrTempTempFl1::try_from(payload)?), + RtIrTempTemp32::MESSAGE_ID => Messages::RtIrTempTemp32(RtIrTempTemp32::try_from(payload)?), + RtIrTempTemp31::MESSAGE_ID => Messages::RtIrTempTemp31(RtIrTempTemp31::try_from(payload)?), + RtIrTempTemp30::MESSAGE_ID => Messages::RtIrTempTemp30(RtIrTempTemp30::try_from(payload)?), + RtIrTempTemp29::MESSAGE_ID => Messages::RtIrTempTemp29(RtIrTempTemp29::try_from(payload)?), + RtIrTempTemp28::MESSAGE_ID => Messages::RtIrTempTemp28(RtIrTempTemp28::try_from(payload)?), + RtIrTempTemp27::MESSAGE_ID => Messages::RtIrTempTemp27(RtIrTempTemp27::try_from(payload)?), + RtIrTempTemp26::MESSAGE_ID => Messages::RtIrTempTemp26(RtIrTempTemp26::try_from(payload)?), + RtIrTempTemp25::MESSAGE_ID => Messages::RtIrTempTemp25(RtIrTempTemp25::try_from(payload)?), + RtIrTempTemp24::MESSAGE_ID => Messages::RtIrTempTemp24(RtIrTempTemp24::try_from(payload)?), + RtIrTempTemp22::MESSAGE_ID => Messages::RtIrTempTemp22(RtIrTempTemp22::try_from(payload)?), + RtIrTempTemp23::MESSAGE_ID => Messages::RtIrTempTemp23(RtIrTempTemp23::try_from(payload)?), + RtIrTempTemp21::MESSAGE_ID => Messages::RtIrTempTemp21(RtIrTempTemp21::try_from(payload)?), + RtIrTempTemp20::MESSAGE_ID => Messages::RtIrTempTemp20(RtIrTempTemp20::try_from(payload)?), + RtIrTempTemp19::MESSAGE_ID => Messages::RtIrTempTemp19(RtIrTempTemp19::try_from(payload)?), + RtIrTempTemp18::MESSAGE_ID => Messages::RtIrTempTemp18(RtIrTempTemp18::try_from(payload)?), + RtIrTempTemp16::MESSAGE_ID => Messages::RtIrTempTemp16(RtIrTempTemp16::try_from(payload)?), + RtIrTempTemp15::MESSAGE_ID => Messages::RtIrTempTemp15(RtIrTempTemp15::try_from(payload)?), + RtIrTempTemp14::MESSAGE_ID => Messages::RtIrTempTemp14(RtIrTempTemp14::try_from(payload)?), + RtIrTempTemp13::MESSAGE_ID => Messages::RtIrTempTemp13(RtIrTempTemp13::try_from(payload)?), + RtIrTempTemp12::MESSAGE_ID => Messages::RtIrTempTemp12(RtIrTempTemp12::try_from(payload)?), + RtIrTempTemp11::MESSAGE_ID => Messages::RtIrTempTemp11(RtIrTempTemp11::try_from(payload)?), + RtIrTempTemp10::MESSAGE_ID => Messages::RtIrTempTemp10(RtIrTempTemp10::try_from(payload)?), + RtIrTempTemp8::MESSAGE_ID => Messages::RtIrTempTemp8(RtIrTempTemp8::try_from(payload)?), + RtIrTempTemp9::MESSAGE_ID => Messages::RtIrTempTemp9(RtIrTempTemp9::try_from(payload)?), + RtIrTempTemp17::MESSAGE_ID => Messages::RtIrTempTemp17(RtIrTempTemp17::try_from(payload)?), + RtIrTempTemp6::MESSAGE_ID => Messages::RtIrTempTemp6(RtIrTempTemp6::try_from(payload)?), + RtIrTempTemp5::MESSAGE_ID => Messages::RtIrTempTemp5(RtIrTempTemp5::try_from(payload)?), + RtIrTempTemp4::MESSAGE_ID => Messages::RtIrTempTemp4(RtIrTempTemp4::try_from(payload)?), + RtIrTempTemp3::MESSAGE_ID => Messages::RtIrTempTemp3(RtIrTempTemp3::try_from(payload)?), + RtIrTempTemp2::MESSAGE_ID => Messages::RtIrTempTemp2(RtIrTempTemp2::try_from(payload)?), + RtIrTempTemp1::MESSAGE_ID => Messages::RtIrTempTemp1(RtIrTempTemp1::try_from(payload)?), + RtSbTrigFinalCondition::MESSAGE_ID => Messages::RtSbTrigFinalCondition(RtSbTrigFinalCondition::try_from(payload)?), + RtSbTrigInitialCondition::MESSAGE_ID => Messages::RtSbTrigInitialCondition(RtSbTrigInitialCondition::try_from(payload)?), + RtSbTrigDirectDist::MESSAGE_ID => Messages::RtSbTrigDirectDist(RtSbTrigDirectDist::try_from(payload)?), + RtSbTrigForwardDist::MESSAGE_ID => Messages::RtSbTrigForwardDist(RtSbTrigForwardDist::try_from(payload)?), + RtSbTrigPathDist::MESSAGE_ID => Messages::RtSbTrigPathDist(RtSbTrigPathDist::try_from(payload)?), + RtSbTrigAccel::MESSAGE_ID => Messages::RtSbTrigAccel(RtSbTrigAccel::try_from(payload)?), + RtDl1mk3MeasureTime12::MESSAGE_ID => Messages::RtDl1mk3MeasureTime12(RtDl1mk3MeasureTime12::try_from(payload)?), + RtDl1mk3MeasureTime11::MESSAGE_ID => Messages::RtDl1mk3MeasureTime11(RtDl1mk3MeasureTime11::try_from(payload)?), + RtDl1mk3MeasureTime10::MESSAGE_ID => Messages::RtDl1mk3MeasureTime10(RtDl1mk3MeasureTime10::try_from(payload)?), + RtDl1mk3MeasureTime9::MESSAGE_ID => Messages::RtDl1mk3MeasureTime9(RtDl1mk3MeasureTime9::try_from(payload)?), + RtDl1mk3MeasureTime8::MESSAGE_ID => Messages::RtDl1mk3MeasureTime8(RtDl1mk3MeasureTime8::try_from(payload)?), + RtDl1mk3MeasureTime7::MESSAGE_ID => Messages::RtDl1mk3MeasureTime7(RtDl1mk3MeasureTime7::try_from(payload)?), + RtDl1mk3MeasureTime6::MESSAGE_ID => Messages::RtDl1mk3MeasureTime6(RtDl1mk3MeasureTime6::try_from(payload)?), + RtDl1mk3MeasureTime5::MESSAGE_ID => Messages::RtDl1mk3MeasureTime5(RtDl1mk3MeasureTime5::try_from(payload)?), + RtDl1mk3MeasureTime4::MESSAGE_ID => Messages::RtDl1mk3MeasureTime4(RtDl1mk3MeasureTime4::try_from(payload)?), + RtDl1mk3MeasureTime3::MESSAGE_ID => Messages::RtDl1mk3MeasureTime3(RtDl1mk3MeasureTime3::try_from(payload)?), + RtDl1mk3MeasureTime2::MESSAGE_ID => Messages::RtDl1mk3MeasureTime2(RtDl1mk3MeasureTime2::try_from(payload)?), + RtDl1mk3MeasureTime1::MESSAGE_ID => Messages::RtDl1mk3MeasureTime1(RtDl1mk3MeasureTime1::try_from(payload)?), + RtDl1mk3Rpm::MESSAGE_ID => Messages::RtDl1mk3Rpm(RtDl1mk3Rpm::try_from(payload)?), + RtDl1mk3Freq4::MESSAGE_ID => Messages::RtDl1mk3Freq4(RtDl1mk3Freq4::try_from(payload)?), + RtDl1mk3Freq3::MESSAGE_ID => Messages::RtDl1mk3Freq3(RtDl1mk3Freq3::try_from(payload)?), + RtDl1mk3Freq2::MESSAGE_ID => Messages::RtDl1mk3Freq2(RtDl1mk3Freq2::try_from(payload)?), + RtDl1mk3Misc3::MESSAGE_ID => Messages::RtDl1mk3Misc3(RtDl1mk3Misc3::try_from(payload)?), + RtDl1mk3Misc2::MESSAGE_ID => Messages::RtDl1mk3Misc2(RtDl1mk3Misc2::try_from(payload)?), + RtDl1mk3Misc1::MESSAGE_ID => Messages::RtDl1mk3Misc1(RtDl1mk3Misc1::try_from(payload)?), + RtDl1mk3Aux31::MESSAGE_ID => Messages::RtDl1mk3Aux31(RtDl1mk3Aux31::try_from(payload)?), + RtDl1mk3Aux30::MESSAGE_ID => Messages::RtDl1mk3Aux30(RtDl1mk3Aux30::try_from(payload)?), + RtDl1mk3Aux29::MESSAGE_ID => Messages::RtDl1mk3Aux29(RtDl1mk3Aux29::try_from(payload)?), + RtDl1mk3Aux28::MESSAGE_ID => Messages::RtDl1mk3Aux28(RtDl1mk3Aux28::try_from(payload)?), + RtDl1mk3Aux27::MESSAGE_ID => Messages::RtDl1mk3Aux27(RtDl1mk3Aux27::try_from(payload)?), + RtDl1mk3Aux26::MESSAGE_ID => Messages::RtDl1mk3Aux26(RtDl1mk3Aux26::try_from(payload)?), + RtDl1mk3Aux25::MESSAGE_ID => Messages::RtDl1mk3Aux25(RtDl1mk3Aux25::try_from(payload)?), + RtDl1mk3Aux24::MESSAGE_ID => Messages::RtDl1mk3Aux24(RtDl1mk3Aux24::try_from(payload)?), + RtDl1mk3Aux23::MESSAGE_ID => Messages::RtDl1mk3Aux23(RtDl1mk3Aux23::try_from(payload)?), + RtDl1mk3Aux22::MESSAGE_ID => Messages::RtDl1mk3Aux22(RtDl1mk3Aux22::try_from(payload)?), + RtDl1mk3Aux21::MESSAGE_ID => Messages::RtDl1mk3Aux21(RtDl1mk3Aux21::try_from(payload)?), + RtDl1mk3Aux20::MESSAGE_ID => Messages::RtDl1mk3Aux20(RtDl1mk3Aux20::try_from(payload)?), + RtDl1mk3Aux19::MESSAGE_ID => Messages::RtDl1mk3Aux19(RtDl1mk3Aux19::try_from(payload)?), + RtDl1mk3Aux18::MESSAGE_ID => Messages::RtDl1mk3Aux18(RtDl1mk3Aux18::try_from(payload)?), + RtDl1mk3Aux17::MESSAGE_ID => Messages::RtDl1mk3Aux17(RtDl1mk3Aux17::try_from(payload)?), + RtDl1mk3Aux16::MESSAGE_ID => Messages::RtDl1mk3Aux16(RtDl1mk3Aux16::try_from(payload)?), + RtDl1mk3Aux15::MESSAGE_ID => Messages::RtDl1mk3Aux15(RtDl1mk3Aux15::try_from(payload)?), + RtDl1mk3Aux14::MESSAGE_ID => Messages::RtDl1mk3Aux14(RtDl1mk3Aux14::try_from(payload)?), + RtDl1mk3Aux13::MESSAGE_ID => Messages::RtDl1mk3Aux13(RtDl1mk3Aux13::try_from(payload)?), + RtDl1mk3Aux12::MESSAGE_ID => Messages::RtDl1mk3Aux12(RtDl1mk3Aux12::try_from(payload)?), + RtDl1mk3Aux11::MESSAGE_ID => Messages::RtDl1mk3Aux11(RtDl1mk3Aux11::try_from(payload)?), + RtDl1mk3Aux9::MESSAGE_ID => Messages::RtDl1mk3Aux9(RtDl1mk3Aux9::try_from(payload)?), + RtDl1mk3Aux10::MESSAGE_ID => Messages::RtDl1mk3Aux10(RtDl1mk3Aux10::try_from(payload)?), + RtDl1mk3Aux8::MESSAGE_ID => Messages::RtDl1mk3Aux8(RtDl1mk3Aux8::try_from(payload)?), + RtDl1mk3Aux7::MESSAGE_ID => Messages::RtDl1mk3Aux7(RtDl1mk3Aux7::try_from(payload)?), + RtDl1mk3Aux6::MESSAGE_ID => Messages::RtDl1mk3Aux6(RtDl1mk3Aux6::try_from(payload)?), + RtDl1mk3Aux5::MESSAGE_ID => Messages::RtDl1mk3Aux5(RtDl1mk3Aux5::try_from(payload)?), + RtDl1mk3Aux4::MESSAGE_ID => Messages::RtDl1mk3Aux4(RtDl1mk3Aux4::try_from(payload)?), + RtDl1mk3Aux3::MESSAGE_ID => Messages::RtDl1mk3Aux3(RtDl1mk3Aux3::try_from(payload)?), + RtDl1mk3Aux2::MESSAGE_ID => Messages::RtDl1mk3Aux2(RtDl1mk3Aux2::try_from(payload)?), + RtDl1mk3Aux1::MESSAGE_ID => Messages::RtDl1mk3Aux1(RtDl1mk3Aux1::try_from(payload)?), + RtDl1mk3Pressure5::MESSAGE_ID => Messages::RtDl1mk3Pressure5(RtDl1mk3Pressure5::try_from(payload)?), + RtDl1mk3Pressure4::MESSAGE_ID => Messages::RtDl1mk3Pressure4(RtDl1mk3Pressure4::try_from(payload)?), + RtDl1mk3Pressure3::MESSAGE_ID => Messages::RtDl1mk3Pressure3(RtDl1mk3Pressure3::try_from(payload)?), + RtDl1mk3Pressure2::MESSAGE_ID => Messages::RtDl1mk3Pressure2(RtDl1mk3Pressure2::try_from(payload)?), + RtDl1mk3Pressure1::MESSAGE_ID => Messages::RtDl1mk3Pressure1(RtDl1mk3Pressure1::try_from(payload)?), + RtDl1mk3Angle3::MESSAGE_ID => Messages::RtDl1mk3Angle3(RtDl1mk3Angle3::try_from(payload)?), + RtDl1mk3Angle2::MESSAGE_ID => Messages::RtDl1mk3Angle2(RtDl1mk3Angle2::try_from(payload)?), + RtDl1mk3Angle1::MESSAGE_ID => Messages::RtDl1mk3Angle1(RtDl1mk3Angle1::try_from(payload)?), + RtDl1mk3Temp25::MESSAGE_ID => Messages::RtDl1mk3Temp25(RtDl1mk3Temp25::try_from(payload)?), + RtDl1mk3Temp24::MESSAGE_ID => Messages::RtDl1mk3Temp24(RtDl1mk3Temp24::try_from(payload)?), + RtDl1mk3Temp23::MESSAGE_ID => Messages::RtDl1mk3Temp23(RtDl1mk3Temp23::try_from(payload)?), + RtDl1mk3Temp22::MESSAGE_ID => Messages::RtDl1mk3Temp22(RtDl1mk3Temp22::try_from(payload)?), + RtDl1mk3Temp21::MESSAGE_ID => Messages::RtDl1mk3Temp21(RtDl1mk3Temp21::try_from(payload)?), + RtDl1mk3Temp20::MESSAGE_ID => Messages::RtDl1mk3Temp20(RtDl1mk3Temp20::try_from(payload)?), + RtDl1mk3Temp19::MESSAGE_ID => Messages::RtDl1mk3Temp19(RtDl1mk3Temp19::try_from(payload)?), + RtDl1mk3Temp18::MESSAGE_ID => Messages::RtDl1mk3Temp18(RtDl1mk3Temp18::try_from(payload)?), + RtDl1mk3Temp17::MESSAGE_ID => Messages::RtDl1mk3Temp17(RtDl1mk3Temp17::try_from(payload)?), + RtDl1mk3Temp16::MESSAGE_ID => Messages::RtDl1mk3Temp16(RtDl1mk3Temp16::try_from(payload)?), + RtDl1mk3Temp15::MESSAGE_ID => Messages::RtDl1mk3Temp15(RtDl1mk3Temp15::try_from(payload)?), + RtDl1mk3Temp14::MESSAGE_ID => Messages::RtDl1mk3Temp14(RtDl1mk3Temp14::try_from(payload)?), + RtDl1mk3Temp13::MESSAGE_ID => Messages::RtDl1mk3Temp13(RtDl1mk3Temp13::try_from(payload)?), + RtDl1mk3Temp12::MESSAGE_ID => Messages::RtDl1mk3Temp12(RtDl1mk3Temp12::try_from(payload)?), + RtDl1mk3Temp11::MESSAGE_ID => Messages::RtDl1mk3Temp11(RtDl1mk3Temp11::try_from(payload)?), + RtDl1mk3Temp10::MESSAGE_ID => Messages::RtDl1mk3Temp10(RtDl1mk3Temp10::try_from(payload)?), + RtDl1mk3Temp9::MESSAGE_ID => Messages::RtDl1mk3Temp9(RtDl1mk3Temp9::try_from(payload)?), + RtDl1mk3Temp8::MESSAGE_ID => Messages::RtDl1mk3Temp8(RtDl1mk3Temp8::try_from(payload)?), + RtDl1mk3Temp7::MESSAGE_ID => Messages::RtDl1mk3Temp7(RtDl1mk3Temp7::try_from(payload)?), + RtDl1mk3Temp6::MESSAGE_ID => Messages::RtDl1mk3Temp6(RtDl1mk3Temp6::try_from(payload)?), + RtDl1mk3Temp5::MESSAGE_ID => Messages::RtDl1mk3Temp5(RtDl1mk3Temp5::try_from(payload)?), + RtDl1mk3Temp4::MESSAGE_ID => Messages::RtDl1mk3Temp4(RtDl1mk3Temp4::try_from(payload)?), + RtDl1mk3Temp3::MESSAGE_ID => Messages::RtDl1mk3Temp3(RtDl1mk3Temp3::try_from(payload)?), + RtDl1mk3Temp2::MESSAGE_ID => Messages::RtDl1mk3Temp2(RtDl1mk3Temp2::try_from(payload)?), + RtDl1mk3Temp1::MESSAGE_ID => Messages::RtDl1mk3Temp1(RtDl1mk3Temp1::try_from(payload)?), + RtDl1mk3Analog32::MESSAGE_ID => Messages::RtDl1mk3Analog32(RtDl1mk3Analog32::try_from(payload)?), + RtDl1mk3Analog31::MESSAGE_ID => Messages::RtDl1mk3Analog31(RtDl1mk3Analog31::try_from(payload)?), + RtDl1mk3Analog30::MESSAGE_ID => Messages::RtDl1mk3Analog30(RtDl1mk3Analog30::try_from(payload)?), + RtDl1mk3Analog29::MESSAGE_ID => Messages::RtDl1mk3Analog29(RtDl1mk3Analog29::try_from(payload)?), + RtDl1mk3Analog28::MESSAGE_ID => Messages::RtDl1mk3Analog28(RtDl1mk3Analog28::try_from(payload)?), + RtDl1mk3Analog27::MESSAGE_ID => Messages::RtDl1mk3Analog27(RtDl1mk3Analog27::try_from(payload)?), + RtDl1mk3Analog26::MESSAGE_ID => Messages::RtDl1mk3Analog26(RtDl1mk3Analog26::try_from(payload)?), + RtDl1mk3Analog25::MESSAGE_ID => Messages::RtDl1mk3Analog25(RtDl1mk3Analog25::try_from(payload)?), + RtDl1mk3Analog15::MESSAGE_ID => Messages::RtDl1mk3Analog15(RtDl1mk3Analog15::try_from(payload)?), + RtDl1mk3Analog14::MESSAGE_ID => Messages::RtDl1mk3Analog14(RtDl1mk3Analog14::try_from(payload)?), + RtDl1mk3Analog17::MESSAGE_ID => Messages::RtDl1mk3Analog17(RtDl1mk3Analog17::try_from(payload)?), + RtDl1mk3Analog24::MESSAGE_ID => Messages::RtDl1mk3Analog24(RtDl1mk3Analog24::try_from(payload)?), + RtDl1mk3Analog23::MESSAGE_ID => Messages::RtDl1mk3Analog23(RtDl1mk3Analog23::try_from(payload)?), + RtDl1mk3Analog22::MESSAGE_ID => Messages::RtDl1mk3Analog22(RtDl1mk3Analog22::try_from(payload)?), + RtDl1mk3Analog21::MESSAGE_ID => Messages::RtDl1mk3Analog21(RtDl1mk3Analog21::try_from(payload)?), + RtDl1mk3Analog20::MESSAGE_ID => Messages::RtDl1mk3Analog20(RtDl1mk3Analog20::try_from(payload)?), + RtDl1mk3Analog19::MESSAGE_ID => Messages::RtDl1mk3Analog19(RtDl1mk3Analog19::try_from(payload)?), + RtDl1mk3Analog16::MESSAGE_ID => Messages::RtDl1mk3Analog16(RtDl1mk3Analog16::try_from(payload)?), + RtDl1mk3Analog18::MESSAGE_ID => Messages::RtDl1mk3Analog18(RtDl1mk3Analog18::try_from(payload)?), + RtDl1mk3Analog12::MESSAGE_ID => Messages::RtDl1mk3Analog12(RtDl1mk3Analog12::try_from(payload)?), + RtDl1mk3Analog11::MESSAGE_ID => Messages::RtDl1mk3Analog11(RtDl1mk3Analog11::try_from(payload)?), + RtDl1mk3Analog10::MESSAGE_ID => Messages::RtDl1mk3Analog10(RtDl1mk3Analog10::try_from(payload)?), + RtDl1mk3Analog9::MESSAGE_ID => Messages::RtDl1mk3Analog9(RtDl1mk3Analog9::try_from(payload)?), + RtDl1mk3Analog8::MESSAGE_ID => Messages::RtDl1mk3Analog8(RtDl1mk3Analog8::try_from(payload)?), + RtDl1mk3Analog7::MESSAGE_ID => Messages::RtDl1mk3Analog7(RtDl1mk3Analog7::try_from(payload)?), + RtDl1mk3Analog6::MESSAGE_ID => Messages::RtDl1mk3Analog6(RtDl1mk3Analog6::try_from(payload)?), + RtDl1mk3Analog5::MESSAGE_ID => Messages::RtDl1mk3Analog5(RtDl1mk3Analog5::try_from(payload)?), + RtDl1mk3Analog4::MESSAGE_ID => Messages::RtDl1mk3Analog4(RtDl1mk3Analog4::try_from(payload)?), + RtDl1mk3Analog3::MESSAGE_ID => Messages::RtDl1mk3Analog3(RtDl1mk3Analog3::try_from(payload)?), + RtDl1mk3Analog2::MESSAGE_ID => Messages::RtDl1mk3Analog2(RtDl1mk3Analog2::try_from(payload)?), + RtDl1mk3Analog1::MESSAGE_ID => Messages::RtDl1mk3Analog1(RtDl1mk3Analog1::try_from(payload)?), + RtDl1mk3Accel::MESSAGE_ID => Messages::RtDl1mk3Accel(RtDl1mk3Accel::try_from(payload)?), + RtSbInsVpt4VelNed2::MESSAGE_ID => Messages::RtSbInsVpt4VelNed2(RtSbInsVpt4VelNed2::try_from(payload)?), + RtSbInsVpt4VelNed1::MESSAGE_ID => Messages::RtSbInsVpt4VelNed1(RtSbInsVpt4VelNed1::try_from(payload)?), + RtSbInsVpt4Offset::MESSAGE_ID => Messages::RtSbInsVpt4Offset(RtSbInsVpt4Offset::try_from(payload)?), + RtSbInsVpt3VelNed2::MESSAGE_ID => Messages::RtSbInsVpt3VelNed2(RtSbInsVpt3VelNed2::try_from(payload)?), + RtSbInsVpt3VelNed1::MESSAGE_ID => Messages::RtSbInsVpt3VelNed1(RtSbInsVpt3VelNed1::try_from(payload)?), + RtSbInsVpt3Offset::MESSAGE_ID => Messages::RtSbInsVpt3Offset(RtSbInsVpt3Offset::try_from(payload)?), + RtSbInsVpt2VelNed2::MESSAGE_ID => Messages::RtSbInsVpt2VelNed2(RtSbInsVpt2VelNed2::try_from(payload)?), + RtSbInsVpt2VelNed1::MESSAGE_ID => Messages::RtSbInsVpt2VelNed1(RtSbInsVpt2VelNed1::try_from(payload)?), + RtSbInsVpt2Offset::MESSAGE_ID => Messages::RtSbInsVpt2Offset(RtSbInsVpt2Offset::try_from(payload)?), + RtSbInsVpt1VelNed2::MESSAGE_ID => Messages::RtSbInsVpt1VelNed2(RtSbInsVpt1VelNed2::try_from(payload)?), + RtSbInsVpt1VelNed1::MESSAGE_ID => Messages::RtSbInsVpt1VelNed1(RtSbInsVpt1VelNed1::try_from(payload)?), + RtSbInsVpt1Offset::MESSAGE_ID => Messages::RtSbInsVpt1Offset(RtSbInsVpt1Offset::try_from(payload)?), + RtSbInsSlip::MESSAGE_ID => Messages::RtSbInsSlip(RtSbInsSlip::try_from(payload)?), + RtSbInsVelEcef2::MESSAGE_ID => Messages::RtSbInsVelEcef2(RtSbInsVelEcef2::try_from(payload)?), + RtSbInsVelEcef1::MESSAGE_ID => Messages::RtSbInsVelEcef1(RtSbInsVelEcef1::try_from(payload)?), + RtSbInsVelNed2::MESSAGE_ID => Messages::RtSbInsVelNed2(RtSbInsVelNed2::try_from(payload)?), + RtSbInsVelNed1::MESSAGE_ID => Messages::RtSbInsVelNed1(RtSbInsVelNed1::try_from(payload)?), + RtSbInsPosEcef2::MESSAGE_ID => Messages::RtSbInsPosEcef2(RtSbInsPosEcef2::try_from(payload)?), + RtSbInsPosEcef1::MESSAGE_ID => Messages::RtSbInsPosEcef1(RtSbInsPosEcef1::try_from(payload)?), + RtSbInsPosLlh2::MESSAGE_ID => Messages::RtSbInsPosLlh2(RtSbInsPosLlh2::try_from(payload)?), + RtSbInsPosLlh1::MESSAGE_ID => Messages::RtSbInsPosLlh1(RtSbInsPosLlh1::try_from(payload)?), + RtSbInsHeadingGradient2::MESSAGE_ID => Messages::RtSbInsHeadingGradient2(RtSbInsHeadingGradient2::try_from(payload)?), + RtSbInsHeadingGradient::MESSAGE_ID => Messages::RtSbInsHeadingGradient(RtSbInsHeadingGradient::try_from(payload)?), + RtSbInsStatus::MESSAGE_ID => Messages::RtSbInsStatus(RtSbInsStatus::try_from(payload)?), + RtSbInsAttitude::MESSAGE_ID => Messages::RtSbInsAttitude(RtSbInsAttitude::try_from(payload)?), + RtSbOutputStatus::MESSAGE_ID => Messages::RtSbOutputStatus(RtSbOutputStatus::try_from(payload)?), + RtSbGpsHeadingGradient2::MESSAGE_ID => Messages::RtSbGpsHeadingGradient2(RtSbGpsHeadingGradient2::try_from(payload)?), + RtSbCumulativeDistance2::MESSAGE_ID => Messages::RtSbCumulativeDistance2(RtSbCumulativeDistance2::try_from(payload)?), + RtSbCumulativeDistance1::MESSAGE_ID => Messages::RtSbCumulativeDistance1(RtSbCumulativeDistance1::try_from(payload)?), + RtSbTriggerTimestamp::MESSAGE_ID => Messages::RtSbTriggerTimestamp(RtSbTriggerTimestamp::try_from(payload)?), + RtImu06GyroRates::MESSAGE_ID => Messages::RtImu06GyroRates(RtImu06GyroRates::try_from(payload)?), + RtImu06Accel::MESSAGE_ID => Messages::RtImu06Accel(RtImu06Accel::try_from(payload)?), + RtSbSpeed::MESSAGE_ID => Messages::RtSbSpeed(RtSbSpeed::try_from(payload)?), + RtSbRtkSlip::MESSAGE_ID => Messages::RtSbRtkSlip(RtSbRtkSlip::try_from(payload)?), + RtSbRtkAttitude::MESSAGE_ID => Messages::RtSbRtkAttitude(RtSbRtkAttitude::try_from(payload)?), + RtSbGpsMcycleLean::MESSAGE_ID => Messages::RtSbGpsMcycleLean(RtSbGpsMcycleLean::try_from(payload)?), + RtSbGpsStatus::MESSAGE_ID => Messages::RtSbGpsStatus(RtSbGpsStatus::try_from(payload)?), + RtSbGpsPosEcef2::MESSAGE_ID => Messages::RtSbGpsPosEcef2(RtSbGpsPosEcef2::try_from(payload)?), + RtSbGpsPosEcef1::MESSAGE_ID => Messages::RtSbGpsPosEcef1(RtSbGpsPosEcef1::try_from(payload)?), + RtSbGpsPosLlh2::MESSAGE_ID => Messages::RtSbGpsPosLlh2(RtSbGpsPosLlh2::try_from(payload)?), + RtSbGpsPosLlh1::MESSAGE_ID => Messages::RtSbGpsPosLlh1(RtSbGpsPosLlh1::try_from(payload)?), + RtSbGpsHeadingGradient::MESSAGE_ID => Messages::RtSbGpsHeadingGradient(RtSbGpsHeadingGradient::try_from(payload)?), + RtSbGpsVelEcef2::MESSAGE_ID => Messages::RtSbGpsVelEcef2(RtSbGpsVelEcef2::try_from(payload)?), + RtSbGpsVelEcef1::MESSAGE_ID => Messages::RtSbGpsVelEcef1(RtSbGpsVelEcef1::try_from(payload)?), + RtSbGpsVelNed2::MESSAGE_ID => Messages::RtSbGpsVelNed2(RtSbGpsVelNed2::try_from(payload)?), + RtSbGpsVelNed1::MESSAGE_ID => Messages::RtSbGpsVelNed1(RtSbGpsVelNed1::try_from(payload)?), + RtSbGpsSpeed::MESSAGE_ID => Messages::RtSbGpsSpeed(RtSbGpsSpeed::try_from(payload)?), + RtSbGpsTime::MESSAGE_ID => Messages::RtSbGpsTime(RtSbGpsTime::try_from(payload)?), + RtSbAccel::MESSAGE_ID => Messages::RtSbAccel(RtSbAccel::try_from(payload)?), + RtSbGyroRates::MESSAGE_ID => Messages::RtSbGyroRates(RtSbGyroRates::try_from(payload)?), + id => return Err(CanError::UnknownMessageId(id)), + }; + Ok(res) + } +} + +/// RT_SB_INS_Vel_Body_Axes +/// +/// - Extended ID: 156795682 (0x9588322) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVelBodyAxes { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVelBodyAxes { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9588322)}); + + pub const INS_VEL_SIDEWAYS_2D_MIN: f32 = -838_f32; + pub const INS_VEL_SIDEWAYS_2D_MAX: f32 = 838_f32; + pub const INS_VEL_FORWARDS_2D_MIN: f32 = -838_f32; + pub const INS_VEL_FORWARDS_2D_MAX: f32 = 838_f32; + pub const ACCURACY_INS_VEL_BODY_MIN: u8 = 0_u8; + pub const ACCURACY_INS_VEL_BODY_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Vel_Body_Axes from values + pub fn new(ins_vel_sideways_2d: f32, ins_vel_forwards_2d: f32, accuracy_ins_vel_body: u8, validity_ins_vel_sideways: bool, validity_ins_vel_forwards: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_vel_sideways_2d(ins_vel_sideways_2d)?; + res.set_ins_vel_forwards_2d(ins_vel_forwards_2d)?; + res.set_accuracy_ins_vel_body(accuracy_ins_vel_body)?; + res.set_validity_ins_vel_sideways(validity_ins_vel_sideways)?; + res.set_validity_ins_vel_forwards(validity_ins_vel_forwards)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Vel_Sideways_2D + /// + /// Sideways Velocity in the vehicle body axes, 2D (no vertical component) . +ve for motion to the vehicle RHS. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_sideways_2d(&self) -> f32 { + self.ins_vel_sideways_2d_raw() + } + + /// Get raw value of INS_Vel_Sideways_2D + /// + /// - Start bit: 40 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_sideways_2d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_Sideways_2D + #[inline(always)] + pub fn set_ins_vel_sideways_2d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelBodyAxes::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) + } + + /// INS_Vel_Forwards_2D + /// + /// Forwards Velocity in the vehicle body axes, 2D (no vertical component) . + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_forwards_2d(&self) -> f32 { + self.ins_vel_forwards_2d_raw() + } + + /// Get raw value of INS_Vel_Forwards_2D + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_forwards_2d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_Forwards_2D + #[inline(always)] + pub fn set_ins_vel_forwards_2d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelBodyAxes::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Vel_Body + /// + /// Accuracy of INS body axis velocities (forward velocity and sideways velocity) + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_vel_body(&self) -> u8 { + self.accuracy_ins_vel_body_raw() + } + + /// Get raw value of Accuracy_INS_Vel_Body + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_vel_body_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Vel_Body + #[inline(always)] + pub fn set_accuracy_ins_vel_body(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelBodyAxes::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsVelBodyAxes::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_Sideways + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_sideways(&self) -> bool { + self.validity_ins_vel_sideways_raw() + } + + /// Get raw value of Validity_INS_Vel_Sideways + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_sideways_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_Sideways + #[inline(always)] + pub fn set_validity_ins_vel_sideways(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_Forwards + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_forwards(&self) -> bool { + self.validity_ins_vel_forwards_raw() + } + + /// Get raw value of Validity_INS_Vel_Forwards + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_forwards_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_Forwards + #[inline(always)] + pub fn set_validity_ins_vel_forwards(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVelBodyAxes { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVelBodyAxes { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Speed +/// +/// - Extended ID: 155876388 (0x94a7c24) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Speed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Speed { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a7c24)}); + + pub const SPEED_MIN: f32 = -20000_f32; + pub const SPEED_MAX: f32 = 20000_f32; + pub const ACCURACY_SPEED_MIN: u8 = 0_u8; + pub const ACCURACY_SPEED_MAX: u8 = 255_u8; + + /// Construct new RT_DL1MK3_Speed from values + pub fn new(speed: f32, accuracy_speed: u8, validity_speed: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_speed(speed)?; + res.set_accuracy_speed(accuracy_speed)?; + res.set_validity_speed(validity_speed)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Speed + /// + /// - Min: -20000 + /// - Max: 20000 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn speed(&self) -> f32 { + self.speed_raw() + } + + /// Get raw value of Speed + /// + /// - Start bit: 16 + /// - Signal size: 32 bits + /// - Factor: 0.00001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn speed_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..48].load_le::(); + + let factor = 0.00001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Speed + #[inline(always)] + pub fn set_speed(&mut self, value: f32) -> Result<(), CanError> { + if value < -20000_f32 || 20000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Speed::MESSAGE_ID }); + } + let factor = 0.00001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..48].store_le(value); + Ok(()) + } + + /// Accuracy_Speed + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_speed(&self) -> u8 { + self.accuracy_speed_raw() + } + + /// Get raw value of Accuracy_Speed + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_speed_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Speed + #[inline(always)] + pub fn set_accuracy_speed(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Speed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3Speed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Speed + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_speed(&self) -> bool { + self.validity_speed_raw() + } + + /// Get raw value of Validity_Speed + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_speed_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Speed + #[inline(always)] + pub fn set_validity_speed(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Speed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Speed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_GPS_Time +/// +/// - Extended ID: 156658980 (0x9566d24) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3GpsTime { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3GpsTime { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566d24)}); + + pub const GPS_WEEK_MIN: u16 = 0_u16; + pub const GPS_WEEK_MAX: u16 = 65535_u16; + pub const GPS_TIME_MIN: f32 = 0_f32; + pub const GPS_TIME_MAX: f32 = 604800_f32; + pub const ACCURACY_GPS_TIME_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_TIME_MAX: u8 = 255_u8; + + /// Construct new RT_DL1MK3_GPS_Time from values + pub fn new(gps_week: u16, gps_time: f32, accuracy_gps_time: u8, validity_gps_week: bool, validity_gps_time: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_week(gps_week)?; + res.set_gps_time(gps_time)?; + res.set_accuracy_gps_time(accuracy_gps_time)?; + res.set_validity_gps_week(validity_gps_week)?; + res.set_validity_gps_time(validity_gps_time)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Week + /// + /// - Min: 0 + /// - Max: 65535 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_week(&self) -> u16 { + self.gps_week_raw() + } + + /// Get raw value of GPS_Week + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_week_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GPS_Week + #[inline(always)] + pub fn set_gps_week(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 65535_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsTime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsTime::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// GPS_Time + /// + /// GPS time is the time in seconds since midnight GMT on Saturday night. + /// + /// - Min: 0 + /// - Max: 604800 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_time(&self) -> f32 { + self.gps_time_raw() + } + + /// Get raw value of GPS_Time + /// + /// - Start bit: 16 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Time + #[inline(always)] + pub fn set_gps_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 604800_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsTime::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[16..48].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Time + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_time(&self) -> u8 { + self.accuracy_gps_time_raw() + } + + /// Get raw value of Accuracy_GPS_Time + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_time_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Time + #[inline(always)] + pub fn set_accuracy_gps_time(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsTime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsTime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Week + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_week(&self) -> bool { + self.validity_gps_week_raw() + } + + /// Get raw value of Validity_GPS_Week + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_week_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Week + #[inline(always)] + pub fn set_validity_gps_week(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Time + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_time(&self) -> bool { + self.validity_gps_time_raw() + } + + /// Get raw value of Validity_GPS_Time + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_time_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Time + #[inline(always)] + pub fn set_validity_gps_time(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3GpsTime { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3GpsTime { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_GPS_Pos_LLH_2 +/// +/// - Extended ID: 156659492 (0x9566f24) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3GpsPosLlh2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3GpsPosLlh2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566f24)}); + + pub const GPS_POS_LLH_ALTITUDE_MIN: f32 = -1000_f32; + pub const GPS_POS_LLH_ALTITUDE_MAX: f32 = 100000_f32; + pub const GPS_POS_LLH_LONGITUDE_MIN: f32 = -180_f32; + pub const GPS_POS_LLH_LONGITUDE_MAX: f32 = 180_f32; + + /// Construct new RT_DL1MK3_GPS_Pos_LLH_2 from values + pub fn new(gps_pos_llh_altitude: f32, gps_pos_llh_longitude: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_pos_llh_altitude(gps_pos_llh_altitude)?; + res.set_gps_pos_llh_longitude(gps_pos_llh_longitude)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Pos_LLH_Altitude + /// + /// - Min: -1000 + /// - Max: 100000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_llh_altitude(&self) -> f32 { + self.gps_pos_llh_altitude_raw() + } + + /// Get raw value of GPS_Pos_LLH_Altitude + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_llh_altitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_gps_pos_llh_altitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -1000_f32 || 100000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh2::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// GPS_Pos_LLH_Longitude + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_llh_longitude(&self) -> f32 { + self.gps_pos_llh_longitude_raw() + } + + /// Get raw value of GPS_Pos_LLH_Longitude + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.0000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_llh_longitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.0000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_gps_pos_llh_longitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh2::MESSAGE_ID }); + } + let factor = 0.0000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3GpsPosLlh2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3GpsPosLlh2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_GPS_Pos_LLH_1 +/// +/// - Extended ID: 156659236 (0x9566e24) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3GpsPosLlh1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3GpsPosLlh1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566e24)}); + + pub const GPS_POS_LLH_LATITUDE_MIN: f32 = -90_f32; + pub const GPS_POS_LLH_LATITUDE_MAX: f32 = 90_f32; + pub const ACCURACY_GPS_POS_LLH_ALTITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_LLH_ALTITUDE_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_POS_LLH_LONGITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_LLH_LONGITUDE_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_POS_LLH_LATITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_LLH_LATITUDE_MAX: u8 = 255_u8; + + /// Construct new RT_DL1MK3_GPS_Pos_LLH_1 from values + pub fn new(gps_pos_llh_latitude: f32, accuracy_gps_pos_llh_altitude: u8, accuracy_gps_pos_llh_longitude: u8, accuracy_gps_pos_llh_latitude: u8, validity_gps_pos_llh_altitude: bool, validity_gps_pos_llh_longitude: bool, validity_gps_pos_llh_latitude: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_pos_llh_latitude(gps_pos_llh_latitude)?; + res.set_accuracy_gps_pos_llh_altitude(accuracy_gps_pos_llh_altitude)?; + res.set_accuracy_gps_pos_llh_longitude(accuracy_gps_pos_llh_longitude)?; + res.set_accuracy_gps_pos_llh_latitude(accuracy_gps_pos_llh_latitude)?; + res.set_validity_gps_pos_llh_altitude(validity_gps_pos_llh_altitude)?; + res.set_validity_gps_pos_llh_longitude(validity_gps_pos_llh_longitude)?; + res.set_validity_gps_pos_llh_latitude(validity_gps_pos_llh_latitude)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Pos_LLH_Latitude + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_llh_latitude(&self) -> f32 { + self.gps_pos_llh_latitude_raw() + } + + /// Get raw value of GPS_Pos_LLH_Latitude + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.0000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_llh_latitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.0000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_gps_pos_llh_latitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID }); + } + let factor = 0.0000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_LLH_Altitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_llh_altitude(&self) -> u8 { + self.accuracy_gps_pos_llh_altitude_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_LLH_Altitude + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_llh_altitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_accuracy_gps_pos_llh_altitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_LLH_Longitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_llh_longitude(&self) -> u8 { + self.accuracy_gps_pos_llh_longitude_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_LLH_Longitude + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_llh_longitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_accuracy_gps_pos_llh_longitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_LLH_Latitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_llh_latitude(&self) -> u8 { + self.accuracy_gps_pos_llh_latitude_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_LLH_Latitude + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_llh_latitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_accuracy_gps_pos_llh_latitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_LLH_Altitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_llh_altitude(&self) -> bool { + self.validity_gps_pos_llh_altitude_raw() + } + + /// Get raw value of Validity_GPS_Pos_LLH_Altitude + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_llh_altitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_validity_gps_pos_llh_altitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_LLH_Longitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_llh_longitude(&self) -> bool { + self.validity_gps_pos_llh_longitude_raw() + } + + /// Get raw value of Validity_GPS_Pos_LLH_Longitude + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_llh_longitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_validity_gps_pos_llh_longitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_LLH_Latitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_llh_latitude(&self) -> bool { + self.validity_gps_pos_llh_latitude_raw() + } + + /// Get raw value of Validity_GPS_Pos_LLH_Latitude + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_llh_latitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_validity_gps_pos_llh_latitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3GpsPosLlh1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3GpsPosLlh1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_GPS_Speed +/// +/// - Extended ID: 156662820 (0x9567c24) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3GpsSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3GpsSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567c24)}); + + pub const GPS_SPEED_3D_MIN: f32 = 0_f32; + pub const GPS_SPEED_3D_MAX: f32 = 1675_f32; + pub const GPS_SPEED_2D_MIN: f32 = 0_f32; + pub const GPS_SPEED_2D_MAX: f32 = 1675_f32; + pub const ACCURACY_GPS_SPEED_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_SPEED_MAX: u8 = 255_u8; + + /// Construct new RT_DL1MK3_GPS_Speed from values + pub fn new(gps_speed_3d: f32, gps_speed_2d: f32, accuracy_gps_speed: u8, validity_gps_speed_3d: bool, validity_gps_speed_2d: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_speed_3d(gps_speed_3d)?; + res.set_gps_speed_2d(gps_speed_2d)?; + res.set_accuracy_gps_speed(accuracy_gps_speed)?; + res.set_validity_gps_speed_3d(validity_gps_speed_3d)?; + res.set_validity_gps_speed_2d(validity_gps_speed_2d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Speed_3D + /// + /// This is GPS scalar 3D speed - scalar speed with the local Z axis component included. + /// + /// - Min: 0 + /// - Max: 1675 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_speed_3d(&self) -> f32 { + self.gps_speed_3d_raw() + } + + /// Get raw value of GPS_Speed_3D + /// + /// - Start bit: 40 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_speed_3d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Speed_3D + #[inline(always)] + pub fn set_gps_speed_3d(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 1675_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsSpeed::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) + } + + /// GPS_Speed_2D + /// + /// This is GPS scalar 2D speed - scalar speed with no local Z axis component included. + /// + /// - Min: 0 + /// - Max: 1675 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_speed_2d(&self) -> f32 { + self.gps_speed_2d_raw() + } + + /// Get raw value of GPS_Speed_2D + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_speed_2d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Speed_2D + #[inline(always)] + pub fn set_gps_speed_2d(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 1675_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsSpeed::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Speed + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_speed(&self) -> u8 { + self.accuracy_gps_speed_raw() + } + + /// Get raw value of Accuracy_GPS_Speed + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_speed_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Speed + #[inline(always)] + pub fn set_accuracy_gps_speed(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsSpeed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3GpsSpeed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Speed_3D + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_speed_3d(&self) -> bool { + self.validity_gps_speed_3d_raw() + } + + /// Get raw value of Validity_GPS_Speed_3D + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_speed_3d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Speed_3D + #[inline(always)] + pub fn set_validity_gps_speed_3d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Speed_2D + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_speed_2d(&self) -> bool { + self.validity_gps_speed_2d_raw() + } + + /// Get raw value of Validity_GPS_Speed_2D + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_speed_2d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Speed_2D + #[inline(always)] + pub fn set_validity_gps_speed_2d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3GpsSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3GpsSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_7 +/// +/// - Extended ID: 156988197 (0x95b7325) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp7 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp7 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7325)}); + + pub const IR_TEMPERATURE_7_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_7_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_7 from values + pub fn new(ir_temperature_7: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_7(ir_temperature_7)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_7(&self) -> f32 { + self.ir_temperature_7_raw() + } + + /// Get raw value of IR_Temperature_7 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_7_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_7 + #[inline(always)] + pub fn set_ir_temperature_7(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp7::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp7 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp7 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_RR_2 +/// +/// - Extended ID: 157447205 (0x9627425) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempRr2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempRr2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9627425)}); + + pub const IR_TEMPERATURE_32_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_32_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_31_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_31_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_30_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_30_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_29_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_29_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_RR_2 from values + pub fn new(ir_temperature_32: f32, ir_temperature_31: f32, ir_temperature_30: f32, ir_temperature_29: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_32(ir_temperature_32)?; + res.set_ir_temperature_31(ir_temperature_31)?; + res.set_ir_temperature_30(ir_temperature_30)?; + res.set_ir_temperature_29(ir_temperature_29)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_32(&self) -> f32 { + self.ir_temperature_32_raw() + } + + /// Get raw value of IR_Temperature_32 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_32_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_32 + #[inline(always)] + pub fn set_ir_temperature_32(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_31 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_31(&self) -> f32 { + self.ir_temperature_31_raw() + } + + /// Get raw value of IR_Temperature_31 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_31_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_31 + #[inline(always)] + pub fn set_ir_temperature_31(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_30 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_30(&self) -> f32 { + self.ir_temperature_30_raw() + } + + /// Get raw value of IR_Temperature_30 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_30_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_30 + #[inline(always)] + pub fn set_ir_temperature_30(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_29 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_29(&self) -> f32 { + self.ir_temperature_29_raw() + } + + /// Get raw value of IR_Temperature_29 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_29_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_29 + #[inline(always)] + pub fn set_ir_temperature_29(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempRr2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempRr2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_RL_2 +/// +/// - Extended ID: 157446693 (0x9627225) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempRl2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempRl2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9627225)}); + + pub const IR_TEMPERATURE_24_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_24_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_23_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_23_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_22_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_22_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_21_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_21_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_RL_2 from values + pub fn new(ir_temperature_24: f32, ir_temperature_23: f32, ir_temperature_22: f32, ir_temperature_21: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_24(ir_temperature_24)?; + res.set_ir_temperature_23(ir_temperature_23)?; + res.set_ir_temperature_22(ir_temperature_22)?; + res.set_ir_temperature_21(ir_temperature_21)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_24 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_24(&self) -> f32 { + self.ir_temperature_24_raw() + } + + /// Get raw value of IR_Temperature_24 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_24_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_24 + #[inline(always)] + pub fn set_ir_temperature_24(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_23 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_23(&self) -> f32 { + self.ir_temperature_23_raw() + } + + /// Get raw value of IR_Temperature_23 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_23_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_23 + #[inline(always)] + pub fn set_ir_temperature_23(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_22 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_22(&self) -> f32 { + self.ir_temperature_22_raw() + } + + /// Get raw value of IR_Temperature_22 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_22_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_22 + #[inline(always)] + pub fn set_ir_temperature_22(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_21 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_21(&self) -> f32 { + self.ir_temperature_21_raw() + } + + /// Get raw value of IR_Temperature_21 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_21_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_21 + #[inline(always)] + pub fn set_ir_temperature_21(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempRl2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempRl2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_FR_2 +/// +/// - Extended ID: 157446181 (0x9627025) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempFr2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempFr2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9627025)}); + + pub const IR_TEMPERATURE_16_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_16_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_15_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_15_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_14_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_14_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_13_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_13_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_FR_2 from values + pub fn new(ir_temperature_16: f32, ir_temperature_15: f32, ir_temperature_14: f32, ir_temperature_13: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_16(ir_temperature_16)?; + res.set_ir_temperature_15(ir_temperature_15)?; + res.set_ir_temperature_14(ir_temperature_14)?; + res.set_ir_temperature_13(ir_temperature_13)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_16 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_16(&self) -> f32 { + self.ir_temperature_16_raw() + } + + /// Get raw value of IR_Temperature_16 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_16_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_16 + #[inline(always)] + pub fn set_ir_temperature_16(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_15 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_15(&self) -> f32 { + self.ir_temperature_15_raw() + } + + /// Get raw value of IR_Temperature_15 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_15_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_15 + #[inline(always)] + pub fn set_ir_temperature_15(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_14 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_14(&self) -> f32 { + self.ir_temperature_14_raw() + } + + /// Get raw value of IR_Temperature_14 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_14_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_14 + #[inline(always)] + pub fn set_ir_temperature_14(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_13 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_13(&self) -> f32 { + self.ir_temperature_13_raw() + } + + /// Get raw value of IR_Temperature_13 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_13_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_13 + #[inline(always)] + pub fn set_ir_temperature_13(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempFr2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempFr2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_FL_2 +/// +/// - Extended ID: 157445669 (0x9626e25) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempFl2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempFl2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9626e25)}); + + pub const IR_TEMPERATURE_8_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_8_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_7_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_7_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_6_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_6_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_5_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_5_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_FL_2 from values + pub fn new(ir_temperature_8: f32, ir_temperature_7: f32, ir_temperature_6: f32, ir_temperature_5: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_8(ir_temperature_8)?; + res.set_ir_temperature_7(ir_temperature_7)?; + res.set_ir_temperature_6(ir_temperature_6)?; + res.set_ir_temperature_5(ir_temperature_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_8(&self) -> f32 { + self.ir_temperature_8_raw() + } + + /// Get raw value of IR_Temperature_8 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_8_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_8 + #[inline(always)] + pub fn set_ir_temperature_8(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_7(&self) -> f32 { + self.ir_temperature_7_raw() + } + + /// Get raw value of IR_Temperature_7 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_7_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_7 + #[inline(always)] + pub fn set_ir_temperature_7(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_6(&self) -> f32 { + self.ir_temperature_6_raw() + } + + /// Get raw value of IR_Temperature_6 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_6_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_6 + #[inline(always)] + pub fn set_ir_temperature_6(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_5(&self) -> f32 { + self.ir_temperature_5_raw() + } + + /// Get raw value of IR_Temperature_5 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_5_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_5 + #[inline(always)] + pub fn set_ir_temperature_5(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempFl2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempFl2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_RR_1 +/// +/// - Extended ID: 157446949 (0x9627325) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempRr1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempRr1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9627325)}); + + pub const IR_TEMPERATURE_28_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_28_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_27_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_27_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_26_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_26_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_25_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_25_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_RR_1 from values + pub fn new(ir_temperature_28: f32, ir_temperature_27: f32, ir_temperature_26: f32, ir_temperature_25: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_28(ir_temperature_28)?; + res.set_ir_temperature_27(ir_temperature_27)?; + res.set_ir_temperature_26(ir_temperature_26)?; + res.set_ir_temperature_25(ir_temperature_25)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_28 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_28(&self) -> f32 { + self.ir_temperature_28_raw() + } + + /// Get raw value of IR_Temperature_28 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_28_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_28 + #[inline(always)] + pub fn set_ir_temperature_28(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_27 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_27(&self) -> f32 { + self.ir_temperature_27_raw() + } + + /// Get raw value of IR_Temperature_27 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_27_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_27 + #[inline(always)] + pub fn set_ir_temperature_27(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_26 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_26(&self) -> f32 { + self.ir_temperature_26_raw() + } + + /// Get raw value of IR_Temperature_26 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_26_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_26 + #[inline(always)] + pub fn set_ir_temperature_26(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_25 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_25(&self) -> f32 { + self.ir_temperature_25_raw() + } + + /// Get raw value of IR_Temperature_25 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_25_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_25 + #[inline(always)] + pub fn set_ir_temperature_25(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempRr1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempRr1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_RL_1 +/// +/// - Extended ID: 157446437 (0x9627125) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempRl1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempRl1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9627125)}); + + pub const IR_TEMPERATURE_20_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_20_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_19_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_19_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_18_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_18_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_17_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_17_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_RL_1 from values + pub fn new(ir_temperature_20: f32, ir_temperature_19: f32, ir_temperature_18: f32, ir_temperature_17: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_20(ir_temperature_20)?; + res.set_ir_temperature_19(ir_temperature_19)?; + res.set_ir_temperature_18(ir_temperature_18)?; + res.set_ir_temperature_17(ir_temperature_17)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_20 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_20(&self) -> f32 { + self.ir_temperature_20_raw() + } + + /// Get raw value of IR_Temperature_20 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_20_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_20 + #[inline(always)] + pub fn set_ir_temperature_20(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_19 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_19(&self) -> f32 { + self.ir_temperature_19_raw() + } + + /// Get raw value of IR_Temperature_19 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_19_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_19 + #[inline(always)] + pub fn set_ir_temperature_19(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_18 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_18(&self) -> f32 { + self.ir_temperature_18_raw() + } + + /// Get raw value of IR_Temperature_18 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_18_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_18 + #[inline(always)] + pub fn set_ir_temperature_18(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_17 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_17(&self) -> f32 { + self.ir_temperature_17_raw() + } + + /// Get raw value of IR_Temperature_17 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_17_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_17 + #[inline(always)] + pub fn set_ir_temperature_17(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempRl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempRl1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempRl1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_FR_1 +/// +/// - Extended ID: 157445925 (0x9626f25) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempFr1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempFr1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9626f25)}); + + pub const IR_TEMPERATURE_12_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_12_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_11_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_11_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_10_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_10_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_9_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_9_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_FR_1 from values + pub fn new(ir_temperature_12: f32, ir_temperature_11: f32, ir_temperature_10: f32, ir_temperature_9: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_12(ir_temperature_12)?; + res.set_ir_temperature_11(ir_temperature_11)?; + res.set_ir_temperature_10(ir_temperature_10)?; + res.set_ir_temperature_9(ir_temperature_9)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_12(&self) -> f32 { + self.ir_temperature_12_raw() + } + + /// Get raw value of IR_Temperature_12 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_12_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_12 + #[inline(always)] + pub fn set_ir_temperature_12(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_11 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_11(&self) -> f32 { + self.ir_temperature_11_raw() + } + + /// Get raw value of IR_Temperature_11 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_11_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_11 + #[inline(always)] + pub fn set_ir_temperature_11(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_10 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_10(&self) -> f32 { + self.ir_temperature_10_raw() + } + + /// Get raw value of IR_Temperature_10 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_10_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_10 + #[inline(always)] + pub fn set_ir_temperature_10(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_9(&self) -> f32 { + self.ir_temperature_9_raw() + } + + /// Get raw value of IR_Temperature_9 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_9_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_9 + #[inline(always)] + pub fn set_ir_temperature_9(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFr1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempFr1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempFr1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_FL_1 +/// +/// - Extended ID: 157445413 (0x9626d25) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTempFl1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTempFl1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9626d25)}); + + pub const IR_TEMPERATURE_4_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_4_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_3_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_3_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_2_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_2_MAX: f32 = 0_f32; + pub const IR_TEMPERATURE_1_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_1_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_FL_1 from values + pub fn new(ir_temperature_4: f32, ir_temperature_3: f32, ir_temperature_2: f32, ir_temperature_1: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ir_temperature_4(ir_temperature_4)?; + res.set_ir_temperature_3(ir_temperature_3)?; + res.set_ir_temperature_2(ir_temperature_2)?; + res.set_ir_temperature_1(ir_temperature_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// IR_Temperature_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_4(&self) -> f32 { + self.ir_temperature_4_raw() + } + + /// Get raw value of IR_Temperature_4 + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_4 + #[inline(always)] + pub fn set_ir_temperature_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// IR_Temperature_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_3(&self) -> f32 { + self.ir_temperature_3_raw() + } + + /// Get raw value of IR_Temperature_3 + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_3 + #[inline(always)] + pub fn set_ir_temperature_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// IR_Temperature_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_2(&self) -> f32 { + self.ir_temperature_2_raw() + } + + /// Get raw value of IR_Temperature_2 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_2 + #[inline(always)] + pub fn set_ir_temperature_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// IR_Temperature_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_1(&self) -> f32 { + self.ir_temperature_1_raw() + } + + /// Get raw value of IR_Temperature_1 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_1 + #[inline(always)] + pub fn set_ir_temperature_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTempFl1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTempFl1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTempFl1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_32 +/// +/// - Extended ID: 156994597 (0x95b8c25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp32 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp32 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8c25)}); + + pub const IR_TEMPERATURE_32_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_32_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_32 from values + pub fn new(ir_temperature_32: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_32(ir_temperature_32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_32(&self) -> f32 { + self.ir_temperature_32_raw() + } + + /// Get raw value of IR_Temperature_32 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_32_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_32 + #[inline(always)] + pub fn set_ir_temperature_32(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp32::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp32 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp32 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_31 +/// +/// - Extended ID: 156994341 (0x95b8b25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp31 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp31 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8b25)}); + + pub const IR_TEMPERATURE_31_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_31_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_31 from values + pub fn new(ir_temperature_31: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_31(ir_temperature_31)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_31 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_31(&self) -> f32 { + self.ir_temperature_31_raw() + } + + /// Get raw value of IR_Temperature_31 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_31_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_31 + #[inline(always)] + pub fn set_ir_temperature_31(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp31::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp31 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp31 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_30 +/// +/// - Extended ID: 156994085 (0x95b8a25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp30 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp30 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8a25)}); + + pub const IR_TEMPERATURE_30_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_30_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_30 from values + pub fn new(ir_temperature_30: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_30(ir_temperature_30)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_30 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_30(&self) -> f32 { + self.ir_temperature_30_raw() + } + + /// Get raw value of IR_Temperature_30 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_30_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_30 + #[inline(always)] + pub fn set_ir_temperature_30(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp30::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp30 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp30 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_29 +/// +/// - Extended ID: 156993829 (0x95b8925) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp29 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp29 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8925)}); + + pub const IR_TEMPERATURE_29_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_29_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_29 from values + pub fn new(ir_temperature_29: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_29(ir_temperature_29)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_29 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_29(&self) -> f32 { + self.ir_temperature_29_raw() + } + + /// Get raw value of IR_Temperature_29 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_29_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_29 + #[inline(always)] + pub fn set_ir_temperature_29(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp29::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp29 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp29 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_28 +/// +/// - Extended ID: 156993573 (0x95b8825) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp28 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp28 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8825)}); + + pub const IR_TEMPERATURE_28_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_28_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_28 from values + pub fn new(ir_temperature_28: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_28(ir_temperature_28)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_28 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_28(&self) -> f32 { + self.ir_temperature_28_raw() + } + + /// Get raw value of IR_Temperature_28 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_28_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_28 + #[inline(always)] + pub fn set_ir_temperature_28(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp28::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp28 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp28 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_27 +/// +/// - Extended ID: 156993317 (0x95b8725) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp27 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp27 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8725)}); + + pub const IR_TEMPERATURE_27_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_27_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_27 from values + pub fn new(ir_temperature_27: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_27(ir_temperature_27)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_27 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_27(&self) -> f32 { + self.ir_temperature_27_raw() + } + + /// Get raw value of IR_Temperature_27 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_27_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_27 + #[inline(always)] + pub fn set_ir_temperature_27(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp27::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp27 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp27 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_26 +/// +/// - Extended ID: 156993061 (0x95b8625) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp26 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp26 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8625)}); + + pub const IR_TEMPERATURE_26_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_26_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_26 from values + pub fn new(ir_temperature_26: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_26(ir_temperature_26)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_26 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_26(&self) -> f32 { + self.ir_temperature_26_raw() + } + + /// Get raw value of IR_Temperature_26 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_26_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_26 + #[inline(always)] + pub fn set_ir_temperature_26(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp26::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp26 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp26 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_25 +/// +/// - Extended ID: 156992805 (0x95b8525) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp25 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp25 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8525)}); + + pub const IR_TEMPERATURE_25_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_25_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_25 from values + pub fn new(ir_temperature_25: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_25(ir_temperature_25)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_25 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_25(&self) -> f32 { + self.ir_temperature_25_raw() + } + + /// Get raw value of IR_Temperature_25 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_25_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_25 + #[inline(always)] + pub fn set_ir_temperature_25(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp25::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp25 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp25 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_24 +/// +/// - Extended ID: 156992549 (0x95b8425) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp24 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp24 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8425)}); + + pub const IR_TEMPERATURE_24_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_24_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_24 from values + pub fn new(ir_temperature_24: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_24(ir_temperature_24)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_24 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_24(&self) -> f32 { + self.ir_temperature_24_raw() + } + + /// Get raw value of IR_Temperature_24 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_24_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_24 + #[inline(always)] + pub fn set_ir_temperature_24(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp24::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp24 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp24 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_22 +/// +/// - Extended ID: 156992037 (0x95b8225) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp22 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp22 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8225)}); + + pub const IR_TEMPERATURE_22_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_22_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_22 from values + pub fn new(ir_temperature_22: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_22(ir_temperature_22)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_22 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_22(&self) -> f32 { + self.ir_temperature_22_raw() + } + + /// Get raw value of IR_Temperature_22 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_22_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_22 + #[inline(always)] + pub fn set_ir_temperature_22(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp22::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp22 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp22 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_23 +/// +/// - Extended ID: 156992293 (0x95b8325) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp23 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp23 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8325)}); + + pub const IR_TEMPERATURE_23_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_23_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_23 from values + pub fn new(ir_temperature_23: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_23(ir_temperature_23)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_23 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_23(&self) -> f32 { + self.ir_temperature_23_raw() + } + + /// Get raw value of IR_Temperature_23 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_23_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_23 + #[inline(always)] + pub fn set_ir_temperature_23(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp23::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp23 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp23 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_21 +/// +/// - Extended ID: 156991781 (0x95b8125) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp21 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp21 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8125)}); + + pub const IR_TEMPERATURE_21_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_21_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_21 from values + pub fn new(ir_temperature_21: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_21(ir_temperature_21)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_21 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_21(&self) -> f32 { + self.ir_temperature_21_raw() + } + + /// Get raw value of IR_Temperature_21 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_21_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_21 + #[inline(always)] + pub fn set_ir_temperature_21(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp21::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp21 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp21 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_20 +/// +/// - Extended ID: 156991525 (0x95b8025) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp20 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp20 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8025)}); + + pub const IR_TEMPERATURE_20_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_20_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_20 from values + pub fn new(ir_temperature_20: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_20(ir_temperature_20)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_20 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_20(&self) -> f32 { + self.ir_temperature_20_raw() + } + + /// Get raw value of IR_Temperature_20 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_20_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_20 + #[inline(always)] + pub fn set_ir_temperature_20(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp20::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp20 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp20 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_19 +/// +/// - Extended ID: 156991269 (0x95b7f25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp19 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp19 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7f25)}); + + pub const IR_TEMPERATURE_19_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_19_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_19 from values + pub fn new(ir_temperature_19: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_19(ir_temperature_19)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_19 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_19(&self) -> f32 { + self.ir_temperature_19_raw() + } + + /// Get raw value of IR_Temperature_19 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_19_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_19 + #[inline(always)] + pub fn set_ir_temperature_19(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp19::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp19 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp19 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_18 +/// +/// - Extended ID: 156991013 (0x95b7e25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp18 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp18 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7e25)}); + + pub const IR_TEMPERATURE_18_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_18_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_18 from values + pub fn new(ir_temperature_18: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_18(ir_temperature_18)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_18 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_18(&self) -> f32 { + self.ir_temperature_18_raw() + } + + /// Get raw value of IR_Temperature_18 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_18_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_18 + #[inline(always)] + pub fn set_ir_temperature_18(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp18::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp18 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp18 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_16 +/// +/// - Extended ID: 156990501 (0x95b7c25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp16 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp16 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7c25)}); + + pub const IR_TEMPERATURE_16_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_16_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_16 from values + pub fn new(ir_temperature_16: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_16(ir_temperature_16)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_16 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_16(&self) -> f32 { + self.ir_temperature_16_raw() + } + + /// Get raw value of IR_Temperature_16 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_16_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_16 + #[inline(always)] + pub fn set_ir_temperature_16(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp16::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp16 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp16 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_15 +/// +/// - Extended ID: 156990245 (0x95b7b25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp15 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp15 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7b25)}); + + pub const IR_TEMPERATURE_15_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_15_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_15 from values + pub fn new(ir_temperature_15: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_15(ir_temperature_15)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_15 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_15(&self) -> f32 { + self.ir_temperature_15_raw() + } + + /// Get raw value of IR_Temperature_15 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_15_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_15 + #[inline(always)] + pub fn set_ir_temperature_15(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp15::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp15 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp15 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_14 +/// +/// - Extended ID: 156989989 (0x95b7a25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp14 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp14 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7a25)}); + + pub const IR_TEMPERATURE_14_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_14_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_14 from values + pub fn new(ir_temperature_14: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_14(ir_temperature_14)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_14 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_14(&self) -> f32 { + self.ir_temperature_14_raw() + } + + /// Get raw value of IR_Temperature_14 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_14_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_14 + #[inline(always)] + pub fn set_ir_temperature_14(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp14::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp14 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp14 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_13 +/// +/// - Extended ID: 156989733 (0x95b7925) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp13 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp13 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7925)}); + + pub const IR_TEMPERATURE_13_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_13_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_13 from values + pub fn new(ir_temperature_13: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_13(ir_temperature_13)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_13 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_13(&self) -> f32 { + self.ir_temperature_13_raw() + } + + /// Get raw value of IR_Temperature_13 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_13_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_13 + #[inline(always)] + pub fn set_ir_temperature_13(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp13::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp13 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp13 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_12 +/// +/// - Extended ID: 156989477 (0x95b7825) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp12 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp12 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7825)}); + + pub const IR_TEMPERATURE_12_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_12_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_12 from values + pub fn new(ir_temperature_12: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_12(ir_temperature_12)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_12(&self) -> f32 { + self.ir_temperature_12_raw() + } + + /// Get raw value of IR_Temperature_12 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_12_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_12 + #[inline(always)] + pub fn set_ir_temperature_12(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp12::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp12 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp12 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_11 +/// +/// - Extended ID: 156989221 (0x95b7725) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp11 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp11 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7725)}); + + pub const IR_TEMPERATURE_11_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_11_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_11 from values + pub fn new(ir_temperature_11: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_11(ir_temperature_11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_11 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_11(&self) -> f32 { + self.ir_temperature_11_raw() + } + + /// Get raw value of IR_Temperature_11 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_11_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_11 + #[inline(always)] + pub fn set_ir_temperature_11(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp11::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp11 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp11 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_10 +/// +/// - Extended ID: 156988965 (0x95b7625) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp10 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp10 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7625)}); + + pub const IR_TEMPERATURE_10_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_10_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_10 from values + pub fn new(ir_temperature_10: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_10(ir_temperature_10)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_10 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_10(&self) -> f32 { + self.ir_temperature_10_raw() + } + + /// Get raw value of IR_Temperature_10 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_10_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_10 + #[inline(always)] + pub fn set_ir_temperature_10(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp10::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp10 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp10 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_8 +/// +/// - Extended ID: 156988453 (0x95b7425) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp8 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp8 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7425)}); + + pub const IR_TEMPERATURE_8_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_8_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_8 from values + pub fn new(ir_temperature_8: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_8(ir_temperature_8)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_8(&self) -> f32 { + self.ir_temperature_8_raw() + } + + /// Get raw value of IR_Temperature_8 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_8_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_8 + #[inline(always)] + pub fn set_ir_temperature_8(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp8::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp8 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp8 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_9 +/// +/// - Extended ID: 156988709 (0x95b7525) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp9 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp9 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7525)}); + + pub const IR_TEMPERATURE_9_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_9_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_9 from values + pub fn new(ir_temperature_9: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_9(ir_temperature_9)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_9(&self) -> f32 { + self.ir_temperature_9_raw() + } + + /// Get raw value of IR_Temperature_9 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_9_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_9 + #[inline(always)] + pub fn set_ir_temperature_9(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp9::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp9 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp9 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_17 +/// +/// - Extended ID: 156990757 (0x95b7d25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp17 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp17 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7d25)}); + + pub const IR_TEMPERATURE_17_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_17_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_17 from values + pub fn new(ir_temperature_17: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_17(ir_temperature_17)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_17 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_17(&self) -> f32 { + self.ir_temperature_17_raw() + } + + /// Get raw value of IR_Temperature_17 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_17_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_17 + #[inline(always)] + pub fn set_ir_temperature_17(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp17::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp17 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp17 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_6 +/// +/// - Extended ID: 156987941 (0x95b7225) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp6 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp6 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7225)}); + + pub const IR_TEMPERATURE_6_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_6_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_6 from values + pub fn new(ir_temperature_6: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_6(ir_temperature_6)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_6(&self) -> f32 { + self.ir_temperature_6_raw() + } + + /// Get raw value of IR_Temperature_6 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_6_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_6 + #[inline(always)] + pub fn set_ir_temperature_6(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp6::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp6 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp6 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_5 +/// +/// - Extended ID: 156987685 (0x95b7125) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp5 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp5 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7125)}); + + pub const IR_TEMPERATURE_5_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_5_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_5 from values + pub fn new(ir_temperature_5: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_5(ir_temperature_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_5(&self) -> f32 { + self.ir_temperature_5_raw() + } + + /// Get raw value of IR_Temperature_5 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_5_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_5 + #[inline(always)] + pub fn set_ir_temperature_5(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp5::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp5 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp5 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_4 +/// +/// - Extended ID: 156987429 (0x95b7025) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp4 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7025)}); + + pub const IR_TEMPERATURE_4_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_4_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_4 from values + pub fn new(ir_temperature_4: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_4(ir_temperature_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_4(&self) -> f32 { + self.ir_temperature_4_raw() + } + + /// Get raw value of IR_Temperature_4 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_4 + #[inline(always)] + pub fn set_ir_temperature_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp4::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_3 +/// +/// - Extended ID: 156987173 (0x95b6f25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b6f25)}); + + pub const IR_TEMPERATURE_3_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_3_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_3 from values + pub fn new(ir_temperature_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_3(ir_temperature_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_3(&self) -> f32 { + self.ir_temperature_3_raw() + } + + /// Get raw value of IR_Temperature_3 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_3 + #[inline(always)] + pub fn set_ir_temperature_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp3::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_2 +/// +/// - Extended ID: 156986917 (0x95b6e25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b6e25)}); + + pub const IR_TEMPERATURE_2_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_2_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_2 from values + pub fn new(ir_temperature_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_2(ir_temperature_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_2(&self) -> f32 { + self.ir_temperature_2_raw() + } + + /// Get raw value of IR_Temperature_2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_2 + #[inline(always)] + pub fn set_ir_temperature_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IRTemp_Temp_1 +/// +/// - Extended ID: 156986661 (0x95b6d25) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtIrTempTemp1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtIrTempTemp1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b6d25)}); + + pub const IR_TEMPERATURE_1_MIN: f32 = 0_f32; + pub const IR_TEMPERATURE_1_MAX: f32 = 0_f32; + + /// Construct new RT_IRTemp_Temp_1 from values + pub fn new(ir_temperature_1: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_ir_temperature_1(ir_temperature_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// IR_Temperature_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ir_temperature_1(&self) -> f32 { + self.ir_temperature_1_raw() + } + + /// Get raw value of IR_Temperature_1 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ir_temperature_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of IR_Temperature_1 + #[inline(always)] + pub fn set_ir_temperature_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtIrTempTemp1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtIrTempTemp1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtIrTempTemp1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trig_Final_Condition +/// +/// - Extended ID: 156726050 (0x9577322) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTrigFinalCondition { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTrigFinalCondition { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9577322)}); + + pub const FINAL_SPEED_MIN: f32 = 0_f32; + pub const FINAL_SPEED_MAX: f32 = 1675_f32; + + /// Construct new RT_SB_Trig_Final_Condition from values + pub fn new(final_speed: f32, validity_final_speed: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_final_speed(final_speed)?; + res.set_validity_final_speed(validity_final_speed)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Final_Speed + /// + /// Speed at end of triggered test + /// + /// - Min: 0 + /// - Max: 1675 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn final_speed(&self) -> f32 { + self.final_speed_raw() + } + + /// Get raw value of Final_Speed + /// + /// - Start bit: 8 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn final_speed_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Final_Speed + #[inline(always)] + pub fn set_final_speed(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 1675_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigFinalCondition::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) + } + + /// Validity_Final_Speed + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_final_speed(&self) -> bool { + self.validity_final_speed_raw() + } + + /// Get raw value of Validity_Final_Speed + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_final_speed_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Final_Speed + #[inline(always)] + pub fn set_validity_final_speed(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTrigFinalCondition { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTrigFinalCondition { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trig_Initial_Condition +/// +/// - Extended ID: 156725794 (0x9577222) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTrigInitialCondition { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTrigInitialCondition { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9577222)}); + + pub const MFDD_END_THRESHOLD_MIN: u8 = 0_u8; + pub const MFDD_END_THRESHOLD_MAX: u8 = 100_u8; + pub const MFDD_START_THRESHOLD_MIN: u8 = 0_u8; + pub const MFDD_START_THRESHOLD_MAX: u8 = 100_u8; + pub const INITIAL_HEADING_MIN: f32 = -180_f32; + pub const INITIAL_HEADING_MAX: f32 = 180_f32; + pub const INITIAL_SPEED_MIN: f32 = 0_f32; + pub const INITIAL_SPEED_MAX: f32 = 1675_f32; + + /// Construct new RT_SB_Trig_Initial_Condition from values + pub fn new(mfdd_end_threshold: u8, mfdd_start_threshold: u8, initial_heading: f32, initial_speed: f32, validity_initial_heading: bool, validity_initial_speed: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_mfdd_end_threshold(mfdd_end_threshold)?; + res.set_mfdd_start_threshold(mfdd_start_threshold)?; + res.set_initial_heading(initial_heading)?; + res.set_initial_speed(initial_speed)?; + res.set_validity_initial_heading(validity_initial_heading)?; + res.set_validity_initial_speed(validity_initial_speed)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// MFDD_End_Threshold + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "%" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn mfdd_end_threshold(&self) -> u8 { + self.mfdd_end_threshold_raw() + } + + /// Get raw value of MFDD_End_Threshold + /// + /// - Start bit: 56 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn mfdd_end_threshold_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MFDD_End_Threshold + #[inline(always)] + pub fn set_mfdd_end_threshold(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 100_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigInitialCondition::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbTrigInitialCondition::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) + } + + /// MFDD_Start_Threshold + /// + /// - Min: 0 + /// - Max: 100 + /// - Unit: "%" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn mfdd_start_threshold(&self) -> u8 { + self.mfdd_start_threshold_raw() + } + + /// Get raw value of MFDD_Start_Threshold + /// + /// - Start bit: 48 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn mfdd_start_threshold_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of MFDD_Start_Threshold + #[inline(always)] + pub fn set_mfdd_start_threshold(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 100_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigInitialCondition::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbTrigInitialCondition::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) + } + + /// Initial_Heading + /// + /// Heading (track) at start of triggered test + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn initial_heading(&self) -> f32 { + self.initial_heading_raw() + } + + /// Get raw value of Initial_Heading + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn initial_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Initial_Heading + #[inline(always)] + pub fn set_initial_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigInitialCondition::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Initial_Speed + /// + /// Speed at start of triggered test + /// + /// - Min: 0 + /// - Max: 1675 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn initial_speed(&self) -> f32 { + self.initial_speed_raw() + } + + /// Get raw value of Initial_Speed + /// + /// - Start bit: 8 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn initial_speed_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Initial_Speed + #[inline(always)] + pub fn set_initial_speed(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 1675_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigInitialCondition::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) + } + + /// Validity_Initial_Heading + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_initial_heading(&self) -> bool { + self.validity_initial_heading_raw() + } + + /// Get raw value of Validity_Initial_Heading + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_initial_heading_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Initial_Heading + #[inline(always)] + pub fn set_validity_initial_heading(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Initial_Speed + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_initial_speed(&self) -> bool { + self.validity_initial_speed_raw() + } + + /// Get raw value of Validity_Initial_Speed + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_initial_speed_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Initial_Speed + #[inline(always)] + pub fn set_validity_initial_speed(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTrigInitialCondition { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTrigInitialCondition { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trig_Direct_Dist +/// +/// - Extended ID: 156725538 (0x9577122) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTrigDirectDist { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTrigDirectDist { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9577122)}); + + pub const PATH_DISTANCE_2D_MIN: f32 = 0_f32; + pub const PATH_DISTANCE_2D_MAX: f32 = 4294967_f32; + pub const DIRECT_DISTANCE_MIN: f32 = 0_f32; + pub const DIRECT_DISTANCE_MAX: f32 = 4294967_f32; + + /// Construct new RT_SB_Trig_Direct_Dist from values + pub fn new(path_distance_2d: f32, direct_distance: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_path_distance_2d(path_distance_2d)?; + res.set_direct_distance(direct_distance)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Path_Distance_2D + /// + /// 2D path distance (horizontal components only) + /// + /// - Min: 0 + /// - Max: 4294967 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn path_distance_2d(&self) -> f32 { + self.path_distance_2d_raw() + } + + /// Get raw value of Path_Distance_2D + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn path_distance_2d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Path_Distance_2D + #[inline(always)] + pub fn set_path_distance_2d(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 4294967_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigDirectDist::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Direct_Distance + /// + /// Direct distance from start of test to current position + /// + /// - Min: 0 + /// - Max: 4294967 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn direct_distance(&self) -> f32 { + self.direct_distance_raw() + } + + /// Get raw value of Direct_Distance + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn direct_distance_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Direct_Distance + #[inline(always)] + pub fn set_direct_distance(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 4294967_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigDirectDist::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTrigDirectDist { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTrigDirectDist { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trig_Forward_Dist +/// +/// - Extended ID: 156725282 (0x9577022) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTrigForwardDist { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTrigForwardDist { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9577022)}); + + pub const DEVIATION_DISTANCE_MIN: f32 = -2147483.648_f32; + pub const DEVIATION_DISTANCE_MAX: f32 = 2147483.647_f32; + pub const FORWARD_DISTANCE_MIN: f32 = -2147483.648_f32; + pub const FORWARD_DISTANCE_MAX: f32 = 2147483.647_f32; + + /// Construct new RT_SB_Trig_Forward_Dist from values + pub fn new(deviation_distance: f32, forward_distance: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_deviation_distance(deviation_distance)?; + res.set_forward_distance(forward_distance)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Deviation_Distance + /// + /// Current deviation distance from a line projected along the initial heading at start of test, +ve for deviation to the right. + /// + /// - Min: -2147483.648 + /// - Max: 2147483.647 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn deviation_distance(&self) -> f32 { + self.deviation_distance_raw() + } + + /// Get raw value of Deviation_Distance + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn deviation_distance_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Deviation_Distance + #[inline(always)] + pub fn set_deviation_distance(&mut self, value: f32) -> Result<(), CanError> { + if value < -2147483.648_f32 || 2147483.647_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigForwardDist::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Forward_Distance + /// + /// Current forward distance from start of test in direction of initial heading at start of test + /// + /// - Min: -2147483.648 + /// - Max: 2147483.647 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn forward_distance(&self) -> f32 { + self.forward_distance_raw() + } + + /// Get raw value of Forward_Distance + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn forward_distance_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Forward_Distance + #[inline(always)] + pub fn set_forward_distance(&mut self, value: f32) -> Result<(), CanError> { + if value < -2147483.648_f32 || 2147483.647_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigForwardDist::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTrigForwardDist { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTrigForwardDist { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trig_Path_Dist +/// +/// - Extended ID: 156725026 (0x9576f22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTrigPathDist { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTrigPathDist { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9576f22)}); + + pub const PATH_DISTANCE_3D_MIN: f32 = 0_f32; + pub const PATH_DISTANCE_3D_MAX: f32 = 4294967_f32; + + /// Construct new RT_SB_Trig_Path_Dist from values + pub fn new(path_distance_3d: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_path_distance_3d(path_distance_3d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Path_Distance_3D + /// + /// 3D path distance + /// + /// - Min: 0 + /// - Max: 4294967 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn path_distance_3d(&self) -> f32 { + self.path_distance_3d_raw() + } + + /// Get raw value of Path_Distance_3D + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn path_distance_3d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Path_Distance_3D + #[inline(always)] + pub fn set_path_distance_3d(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 4294967_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigPathDist::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTrigPathDist { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTrigPathDist { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trig_Accel +/// +/// - Extended ID: 156724770 (0x9576e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTrigAccel { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTrigAccel { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9576e22)}); + + pub const TRIGGERED_TIME_MIN: f32 = 0_f32; + pub const TRIGGERED_TIME_MAX: f32 = 167772_f32; + pub const AVERAGE_ACCEL_MIN: f32 = -65_f32; + pub const AVERAGE_ACCEL_MAX: f32 = 65_f32; + pub const MFDD_MIN: f32 = -65_f32; + pub const MFDD_MAX: f32 = 65_f32; + + /// Construct new RT_SB_Trig_Accel from values + pub fn new(triggered_time: f32, average_accel: f32, mfdd: f32, validity_triggered_time: bool, validity_average_accel: bool, validity_mfdd: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_triggered_time(triggered_time)?; + res.set_average_accel(average_accel)?; + res.set_mfdd(mfdd)?; + res.set_validity_triggered_time(validity_triggered_time)?; + res.set_validity_average_accel(validity_average_accel)?; + res.set_validity_mfdd(validity_mfdd)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Triggered_Time + /// + /// Cumulative time from start of triggered test to current time. + /// + /// - Min: 0 + /// - Max: 167772 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn triggered_time(&self) -> f32 { + self.triggered_time_raw() + } + + /// Get raw value of Triggered_Time + /// + /// - Start bit: 40 + /// - Signal size: 24 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn triggered_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Triggered_Time + #[inline(always)] + pub fn set_triggered_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 167772_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigAccel::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) + } + + /// Average_Accel + /// + /// Average acceleration from start of triggered test to current time. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn average_accel(&self) -> f32 { + self.average_accel_raw() + } + + /// Get raw value of Average_Accel + /// + /// - Start bit: 24 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn average_accel_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[24..40].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Average_Accel + #[inline(always)] + pub fn set_average_accel(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigAccel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[24..40].store_le(value); + Ok(()) + } + + /// MFDD + /// + /// Mean fully-developed decelleration of triggered test. Thresholds used are as set in the logger configuration. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn mfdd(&self) -> f32 { + self.mfdd_raw() + } + + /// Get raw value of MFDD + /// + /// - Start bit: 8 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn mfdd_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..24].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of MFDD + #[inline(always)] + pub fn set_mfdd(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTrigAccel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..24].store_le(value); + Ok(()) + } + + /// Validity_Triggered_Time + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_triggered_time(&self) -> bool { + self.validity_triggered_time_raw() + } + + /// Get raw value of Validity_Triggered_Time + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_triggered_time_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Triggered_Time + #[inline(always)] + pub fn set_validity_triggered_time(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Average_Accel + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_average_accel(&self) -> bool { + self.validity_average_accel_raw() + } + + /// Get raw value of Validity_Average_Accel + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_average_accel_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Average_Accel + #[inline(always)] + pub fn set_validity_average_accel(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_MFDD + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_mfdd(&self) -> bool { + self.validity_mfdd_raw() + } + + /// Get raw value of Validity_MFDD + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_mfdd_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_MFDD + #[inline(always)] + pub fn set_validity_mfdd(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTrigAccel { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTrigAccel { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_12 +/// +/// - Extended ID: 157317156 (0x9607824) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime12 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime12 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607824)}); + + pub const MEASURED_TIME_12_MIN: u32 = 0_u32; + pub const MEASURED_TIME_12_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_12 from values + pub fn new(measured_time_12: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_12(measured_time_12)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_12(&self) -> u32 { + self.measured_time_12_raw() + } + + /// Get raw value of Measured_Time_12 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_12_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_12 + #[inline(always)] + pub fn set_measured_time_12(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime12::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime12::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime12 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime12 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_11 +/// +/// - Extended ID: 157316900 (0x9607724) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime11 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime11 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607724)}); + + pub const MEASURED_TIME_11_MIN: u32 = 0_u32; + pub const MEASURED_TIME_11_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_11 from values + pub fn new(measured_time_11: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_11(measured_time_11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_11 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_11(&self) -> u32 { + self.measured_time_11_raw() + } + + /// Get raw value of Measured_Time_11 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_11_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_11 + #[inline(always)] + pub fn set_measured_time_11(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime11::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime11::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime11 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime11 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_10 +/// +/// - Extended ID: 157316644 (0x9607624) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime10 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime10 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607624)}); + + pub const MEASURED_TIME_10_MIN: u32 = 0_u32; + pub const MEASURED_TIME_10_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_10 from values + pub fn new(measured_time_10: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_10(measured_time_10)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_10 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_10(&self) -> u32 { + self.measured_time_10_raw() + } + + /// Get raw value of Measured_Time_10 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_10_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_10 + #[inline(always)] + pub fn set_measured_time_10(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime10::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime10::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime10 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime10 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_9 +/// +/// - Extended ID: 157316388 (0x9607524) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime9 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime9 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607524)}); + + pub const MEASURED_TIME_9_MIN: u32 = 0_u32; + pub const MEASURED_TIME_9_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_9 from values + pub fn new(measured_time_9: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_9(measured_time_9)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_9(&self) -> u32 { + self.measured_time_9_raw() + } + + /// Get raw value of Measured_Time_9 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_9_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_9 + #[inline(always)] + pub fn set_measured_time_9(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime9::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime9::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime9 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime9 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_8 +/// +/// - Extended ID: 157316132 (0x9607424) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime8 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime8 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607424)}); + + pub const MEASURED_TIME_8_MIN: u32 = 0_u32; + pub const MEASURED_TIME_8_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_8 from values + pub fn new(measured_time_8: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_8(measured_time_8)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_8(&self) -> u32 { + self.measured_time_8_raw() + } + + /// Get raw value of Measured_Time_8 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_8_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_8 + #[inline(always)] + pub fn set_measured_time_8(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime8::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime8::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime8 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime8 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_7 +/// +/// - Extended ID: 157315876 (0x9607324) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime7 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime7 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607324)}); + + pub const MEASURED_TIME_7_MIN: u32 = 0_u32; + pub const MEASURED_TIME_7_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_7 from values + pub fn new(measured_time_7: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_7(measured_time_7)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_7(&self) -> u32 { + self.measured_time_7_raw() + } + + /// Get raw value of Measured_Time_7 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_7_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_7 + #[inline(always)] + pub fn set_measured_time_7(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime7::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime7::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime7 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime7 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_6 +/// +/// - Extended ID: 157315620 (0x9607224) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime6 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime6 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607224)}); + + pub const MEASURED_TIME_6_MIN: u32 = 0_u32; + pub const MEASURED_TIME_6_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_6 from values + pub fn new(measured_time_6: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_6(measured_time_6)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_6(&self) -> u32 { + self.measured_time_6_raw() + } + + /// Get raw value of Measured_Time_6 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_6_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_6 + #[inline(always)] + pub fn set_measured_time_6(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime6::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime6::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime6 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime6 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_5 +/// +/// - Extended ID: 157315364 (0x9607124) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime5 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime5 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607124)}); + + pub const MEASURED_TIME_5_MIN: u32 = 0_u32; + pub const MEASURED_TIME_5_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_5 from values + pub fn new(measured_time_5: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_5(measured_time_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_5(&self) -> u32 { + self.measured_time_5_raw() + } + + /// Get raw value of Measured_Time_5 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_5_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_5 + #[inline(always)] + pub fn set_measured_time_5(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime5::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime5::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime5 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime5 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_4 +/// +/// - Extended ID: 157315108 (0x9607024) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime4 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9607024)}); + + pub const MEASURED_TIME_4_MIN: u32 = 0_u32; + pub const MEASURED_TIME_4_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_4 from values + pub fn new(measured_time_4: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_4(measured_time_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_4(&self) -> u32 { + self.measured_time_4_raw() + } + + /// Get raw value of Measured_Time_4 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_4_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_4 + #[inline(always)] + pub fn set_measured_time_4(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime4::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime4::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_3 +/// +/// - Extended ID: 157314852 (0x9606f24) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime3 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9606f24)}); + + pub const MEASURED_TIME_3_MIN: u32 = 0_u32; + pub const MEASURED_TIME_3_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_3 from values + pub fn new(measured_time_3: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_3(measured_time_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_3(&self) -> u32 { + self.measured_time_3_raw() + } + + /// Get raw value of Measured_Time_3 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_3_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_3 + #[inline(always)] + pub fn set_measured_time_3(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime3::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime3::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_2 +/// +/// - Extended ID: 157314596 (0x9606e24) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime2 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9606e24)}); + + pub const MEASURED_TIME_2_MIN: u32 = 0_u32; + pub const MEASURED_TIME_2_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_2 from values + pub fn new(measured_time_2: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_2(measured_time_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_2(&self) -> u32 { + self.measured_time_2_raw() + } + + /// Get raw value of Measured_Time_2 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_2_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_2 + #[inline(always)] + pub fn set_measured_time_2(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime2::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Measure_Time_1 +/// +/// - Extended ID: 157314340 (0x9606d24) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3MeasureTime1 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3MeasureTime1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9606d24)}); + + pub const MEASURED_TIME_1_MIN: u32 = 0_u32; + pub const MEASURED_TIME_1_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Measure_Time_1 from values + pub fn new(measured_time_1: u32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_measured_time_1(measured_time_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Measured_Time_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn measured_time_1(&self) -> u32 { + self.measured_time_1_raw() + } + + /// Get raw value of Measured_Time_1 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn measured_time_1_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 1; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Measured_Time_1 + #[inline(always)] + pub fn set_measured_time_1(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3MeasureTime1::MESSAGE_ID })?; + let value = (value / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3MeasureTime1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3MeasureTime1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_RPM +/// +/// - Extended ID: 157251620 (0x95f7824) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Rpm { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Rpm { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95f7824)}); + + pub const RPM_MIN: u16 = 0_u16; + pub const RPM_MAX: u16 = 0_u16; + + /// Construct new RT_DL1MK3_RPM from values + pub fn new(rpm: u16) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_rpm(rpm)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// RPM + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rpm(&self) -> u16 { + self.rpm_raw() + } + + /// Get raw value of RPM + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn rpm_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of RPM + #[inline(always)] + pub fn set_rpm(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 0_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Rpm::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3Rpm::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Rpm { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Rpm { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Freq_4 +/// +/// - Extended ID: 157251364 (0x95f7724) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Freq4 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Freq4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95f7724)}); + + pub const FREQUENCY_4_MIN: f32 = 0_f32; + pub const FREQUENCY_4_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Freq_4 from values + pub fn new(frequency_4: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_frequency_4(frequency_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Frequency_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn frequency_4(&self) -> f32 { + self.frequency_4_raw() + } + + /// Get raw value of Frequency_4 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn frequency_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Frequency_4 + #[inline(always)] + pub fn set_frequency_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Freq4::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Freq4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Freq4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Freq_3 +/// +/// - Extended ID: 157251108 (0x95f7624) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Freq3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Freq3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95f7624)}); + + pub const FREQUENCY_3_MIN: f32 = 0_f32; + pub const FREQUENCY_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Freq_3 from values + pub fn new(frequency_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_frequency_3(frequency_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Frequency_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn frequency_3(&self) -> f32 { + self.frequency_3_raw() + } + + /// Get raw value of Frequency_3 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn frequency_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Frequency_3 + #[inline(always)] + pub fn set_frequency_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Freq3::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Freq3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Freq3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Freq_2 +/// +/// - Extended ID: 157250852 (0x95f7524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Freq2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Freq2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95f7524)}); + + pub const FREQUENCY_2_MIN: f32 = 0_f32; + pub const FREQUENCY_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Freq_2 from values + pub fn new(frequency_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_frequency_2(frequency_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Frequency_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn frequency_2(&self) -> f32 { + self.frequency_2_raw() + } + + /// Get raw value of Frequency_2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn frequency_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Frequency_2 + #[inline(always)] + pub fn set_frequency_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Freq2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Freq2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Freq2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Misc_3 +/// +/// - Extended ID: 157380388 (0x9616f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Misc3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Misc3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9616f24)}); + + pub const MISC_3_MIN: f32 = 0_f32; + pub const MISC_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Misc_3 from values + pub fn new(misc_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_misc_3(misc_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Misc_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn misc_3(&self) -> f32 { + self.misc_3_raw() + } + + /// Get raw value of Misc_3 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn misc_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Misc_3 + #[inline(always)] + pub fn set_misc_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Misc3::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Misc3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Misc3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Misc_2 +/// +/// - Extended ID: 157380132 (0x9616e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Misc2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Misc2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9616e24)}); + + pub const MISC_2_MIN: f32 = 0_f32; + pub const MISC_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Misc_2 from values + pub fn new(misc_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_misc_2(misc_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Misc_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn misc_2(&self) -> f32 { + self.misc_2_raw() + } + + /// Get raw value of Misc_2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn misc_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Misc_2 + #[inline(always)] + pub fn set_misc_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Misc2::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Misc2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Misc2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Misc_1 +/// +/// - Extended ID: 157379876 (0x9616d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Misc1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Misc1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9616d24)}); + + pub const MISC_1_MIN: f32 = 0_f32; + pub const MISC_1_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Misc_1 from values + pub fn new(misc_1: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_misc_1(misc_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Misc_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn misc_1(&self) -> f32 { + self.misc_1_raw() + } + + /// Get raw value of Misc_1 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn misc_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Misc_1 + #[inline(always)] + pub fn set_misc_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Misc1::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Misc1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Misc1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_31 +/// +/// - Extended ID: 157190948 (0x95e8b24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux31 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux31 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8b24)}); + + pub const AUX_31_MIN: f32 = 0_f32; + pub const AUX_31_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_31 from values + pub fn new(aux_31: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_31(aux_31)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_31 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_31(&self) -> f32 { + self.aux_31_raw() + } + + /// Get raw value of AUX_31 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_31_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_31 + #[inline(always)] + pub fn set_aux_31(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux31::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux31 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux31 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_30 +/// +/// - Extended ID: 157190692 (0x95e8a24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux30 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux30 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8a24)}); + + pub const AUX_30_MIN: f32 = 0_f32; + pub const AUX_30_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_30 from values + pub fn new(aux_30: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_30(aux_30)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_30 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_30(&self) -> f32 { + self.aux_30_raw() + } + + /// Get raw value of AUX_30 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_30_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_30 + #[inline(always)] + pub fn set_aux_30(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux30::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux30 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux30 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_29 +/// +/// - Extended ID: 157190436 (0x95e8924) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux29 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux29 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8924)}); + + pub const AUX_29_MIN: f32 = 0_f32; + pub const AUX_29_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_29 from values + pub fn new(aux_29: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_29(aux_29)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_29 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_29(&self) -> f32 { + self.aux_29_raw() + } + + /// Get raw value of AUX_29 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_29_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_29 + #[inline(always)] + pub fn set_aux_29(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux29::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux29 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux29 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_28 +/// +/// - Extended ID: 157190180 (0x95e8824) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux28 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux28 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8824)}); + + pub const AUX_28_MIN: f32 = 0_f32; + pub const AUX_28_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_28 from values + pub fn new(aux_28: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_28(aux_28)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_28 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_28(&self) -> f32 { + self.aux_28_raw() + } + + /// Get raw value of AUX_28 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_28_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_28 + #[inline(always)] + pub fn set_aux_28(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux28::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux28 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux28 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_27 +/// +/// - Extended ID: 157189924 (0x95e8724) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux27 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux27 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8724)}); + + pub const AUX_27_MIN: f32 = 0_f32; + pub const AUX_27_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_27 from values + pub fn new(aux_27: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_27(aux_27)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_27 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_27(&self) -> f32 { + self.aux_27_raw() + } + + /// Get raw value of AUX_27 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_27_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_27 + #[inline(always)] + pub fn set_aux_27(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux27::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux27 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux27 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_26 +/// +/// - Extended ID: 157189668 (0x95e8624) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux26 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux26 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8624)}); + + pub const AUX_26_MIN: f32 = 0_f32; + pub const AUX_26_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_26 from values + pub fn new(aux_26: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_26(aux_26)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_26 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_26(&self) -> f32 { + self.aux_26_raw() + } + + /// Get raw value of AUX_26 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_26_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_26 + #[inline(always)] + pub fn set_aux_26(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux26::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux26 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux26 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_25 +/// +/// - Extended ID: 157189412 (0x95e8524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux25 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux25 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8524)}); + + pub const AUX_25_MIN: f32 = 0_f32; + pub const AUX_25_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_25 from values + pub fn new(aux_25: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_25(aux_25)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_25 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_25(&self) -> f32 { + self.aux_25_raw() + } + + /// Get raw value of AUX_25 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_25_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_25 + #[inline(always)] + pub fn set_aux_25(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux25::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux25 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux25 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_24 +/// +/// - Extended ID: 157189156 (0x95e8424) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux24 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux24 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8424)}); + + pub const AUX_24_MIN: f32 = 0_f32; + pub const AUX_24_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_24 from values + pub fn new(aux_24: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_24(aux_24)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_24 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_24(&self) -> f32 { + self.aux_24_raw() + } + + /// Get raw value of AUX_24 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_24_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_24 + #[inline(always)] + pub fn set_aux_24(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux24::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux24 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux24 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_23 +/// +/// - Extended ID: 157188900 (0x95e8324) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux23 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux23 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8324)}); + + pub const AUX_23_MIN: f32 = 0_f32; + pub const AUX_23_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_23 from values + pub fn new(aux_23: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_23(aux_23)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_23 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_23(&self) -> f32 { + self.aux_23_raw() + } + + /// Get raw value of AUX_23 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_23_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_23 + #[inline(always)] + pub fn set_aux_23(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux23::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux23 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux23 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_22 +/// +/// - Extended ID: 157188644 (0x95e8224) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux22 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux22 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8224)}); + + pub const AUX_22_MIN: u32 = 0_u32; + pub const AUX_22_MAX: u32 = 0_u32; + + /// Construct new RT_DL1MK3_Aux_22 from values + pub fn new(aux_22: u32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_22(aux_22)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_22 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_22(&self) -> u32 { + self.aux_22_raw() + } + + /// Get raw value of AUX_22 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 10 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_22_raw(&self) -> u32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 10; + u32::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of AUX_22 + #[inline(always)] + pub fn set_aux_22(&mut self, value: u32) -> Result<(), CanError> { + if value < 0_u32 || 0_u32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux22::MESSAGE_ID }); + } + let factor = 10; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux22::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux22 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux22 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_21 +/// +/// - Extended ID: 157188388 (0x95e8124) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux21 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux21 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8124)}); + + pub const AUX_21_MIN: f32 = 0_f32; + pub const AUX_21_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_21 from values + pub fn new(aux_21: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_21(aux_21)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_21 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_21(&self) -> f32 { + self.aux_21_raw() + } + + /// Get raw value of AUX_21 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_21_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_21 + #[inline(always)] + pub fn set_aux_21(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux21::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux21 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux21 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_20 +/// +/// - Extended ID: 157188132 (0x95e8024) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux20 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux20 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e8024)}); + + pub const AUX_20_MIN: f32 = 0_f32; + pub const AUX_20_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_20 from values + pub fn new(aux_20: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_20(aux_20)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_20 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_20(&self) -> f32 { + self.aux_20_raw() + } + + /// Get raw value of AUX_20 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_20_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_20 + #[inline(always)] + pub fn set_aux_20(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux20::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux20 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux20 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_19 +/// +/// - Extended ID: 157187876 (0x95e7f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux19 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux19 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7f24)}); + + pub const AUX_19_MIN: f32 = 0_f32; + pub const AUX_19_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_19 from values + pub fn new(aux_19: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_19(aux_19)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_19 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_19(&self) -> f32 { + self.aux_19_raw() + } + + /// Get raw value of AUX_19 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_19_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_19 + #[inline(always)] + pub fn set_aux_19(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux19::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux19 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux19 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_18 +/// +/// - Extended ID: 157187620 (0x95e7e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux18 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux18 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7e24)}); + + pub const AUX_18_MIN: f32 = 0_f32; + pub const AUX_18_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_18 from values + pub fn new(aux_18: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_18(aux_18)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_18 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_18(&self) -> f32 { + self.aux_18_raw() + } + + /// Get raw value of AUX_18 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_18_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_18 + #[inline(always)] + pub fn set_aux_18(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux18::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux18 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux18 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_17 +/// +/// - Extended ID: 157187364 (0x95e7d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux17 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux17 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7d24)}); + + pub const AUX_17_MIN: f32 = 0_f32; + pub const AUX_17_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_17 from values + pub fn new(aux_17: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_17(aux_17)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_17 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_17(&self) -> f32 { + self.aux_17_raw() + } + + /// Get raw value of AUX_17 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_17_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_17 + #[inline(always)] + pub fn set_aux_17(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux17::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux17 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux17 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_16 +/// +/// - Extended ID: 157187108 (0x95e7c24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux16 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux16 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7c24)}); + + pub const AUX_16_MIN: f32 = 0_f32; + pub const AUX_16_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_16 from values + pub fn new(aux_16: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_16(aux_16)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_16 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_16(&self) -> f32 { + self.aux_16_raw() + } + + /// Get raw value of AUX_16 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_16_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_16 + #[inline(always)] + pub fn set_aux_16(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux16::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux16 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux16 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_15 +/// +/// - Extended ID: 157186852 (0x95e7b24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux15 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux15 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7b24)}); + + pub const AUX_15_MIN: f32 = 0_f32; + pub const AUX_15_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_15 from values + pub fn new(aux_15: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_15(aux_15)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_15 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_15(&self) -> f32 { + self.aux_15_raw() + } + + /// Get raw value of AUX_15 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_15_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_15 + #[inline(always)] + pub fn set_aux_15(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux15::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux15 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux15 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_14 +/// +/// - Extended ID: 157186596 (0x95e7a24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux14 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux14 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7a24)}); + + pub const AUX_14_MIN: f32 = 0_f32; + pub const AUX_14_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_14 from values + pub fn new(aux_14: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_14(aux_14)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_14 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_14(&self) -> f32 { + self.aux_14_raw() + } + + /// Get raw value of AUX_14 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_14_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_14 + #[inline(always)] + pub fn set_aux_14(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux14::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux14 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux14 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_13 +/// +/// - Extended ID: 157186340 (0x95e7924) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux13 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux13 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7924)}); + + pub const AUX_13_MIN: f32 = 0_f32; + pub const AUX_13_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_13 from values + pub fn new(aux_13: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_13(aux_13)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_13 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_13(&self) -> f32 { + self.aux_13_raw() + } + + /// Get raw value of AUX_13 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_13_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_13 + #[inline(always)] + pub fn set_aux_13(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux13::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux13 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux13 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_12 +/// +/// - Extended ID: 157186084 (0x95e7824) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux12 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux12 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7824)}); + + pub const AUX_12_MIN: f32 = 0_f32; + pub const AUX_12_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_12 from values + pub fn new(aux_12: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_12(aux_12)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_12(&self) -> f32 { + self.aux_12_raw() + } + + /// Get raw value of AUX_12 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_12_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_12 + #[inline(always)] + pub fn set_aux_12(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux12::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux12 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux12 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_11 +/// +/// - Extended ID: 157185828 (0x95e7724) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux11 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux11 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7724)}); + + pub const AUX_11_MIN: f32 = 0_f32; + pub const AUX_11_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_11 from values + pub fn new(aux_11: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_11(aux_11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_11 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_11(&self) -> f32 { + self.aux_11_raw() + } + + /// Get raw value of AUX_11 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_11_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_11 + #[inline(always)] + pub fn set_aux_11(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux11::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux11 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux11 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_9 +/// +/// - Extended ID: 157185316 (0x95e7524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux9 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux9 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7524)}); + + pub const AUX_9_MIN: f32 = 0_f32; + pub const AUX_9_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_9 from values + pub fn new(aux_9: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_9(aux_9)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_9(&self) -> f32 { + self.aux_9_raw() + } + + /// Get raw value of AUX_9 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_9_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_9 + #[inline(always)] + pub fn set_aux_9(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux9::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux9 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux9 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_10 +/// +/// - Extended ID: 157185572 (0x95e7624) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux10 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux10 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7624)}); + + pub const AUX_10_MIN: f32 = 0_f32; + pub const AUX_10_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_10 from values + pub fn new(aux_10: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_10(aux_10)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_10 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_10(&self) -> f32 { + self.aux_10_raw() + } + + /// Get raw value of AUX_10 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_10_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_10 + #[inline(always)] + pub fn set_aux_10(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux10::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux10 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux10 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_8 +/// +/// - Extended ID: 157185060 (0x95e7424) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux8 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux8 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7424)}); + + pub const AUX_8_MIN: f32 = 0_f32; + pub const AUX_8_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_8 from values + pub fn new(aux_8: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_8(aux_8)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_8(&self) -> f32 { + self.aux_8_raw() + } + + /// Get raw value of AUX_8 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_8_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_8 + #[inline(always)] + pub fn set_aux_8(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux8::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux8 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux8 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_7 +/// +/// - Extended ID: 157184804 (0x95e7324) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux7 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux7 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7324)}); + + pub const AUX_7_MIN: f32 = 0_f32; + pub const AUX_7_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_7 from values + pub fn new(aux_7: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_7(aux_7)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_7(&self) -> f32 { + self.aux_7_raw() + } + + /// Get raw value of AUX_7 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_7_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_7 + #[inline(always)] + pub fn set_aux_7(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux7::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux7 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux7 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_6 +/// +/// - Extended ID: 157184548 (0x95e7224) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux6 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux6 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7224)}); + + pub const AUX_6_MIN: f32 = 0_f32; + pub const AUX_6_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_6 from values + pub fn new(aux_6: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_6(aux_6)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_6(&self) -> f32 { + self.aux_6_raw() + } + + /// Get raw value of AUX_6 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_6_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_6 + #[inline(always)] + pub fn set_aux_6(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux6::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux6 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux6 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_5 +/// +/// - Extended ID: 157184292 (0x95e7124) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux5 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux5 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7124)}); + + pub const AUX_5_MIN: f32 = 0_f32; + pub const AUX_5_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_5 from values + pub fn new(aux_5: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_5(aux_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_5(&self) -> f32 { + self.aux_5_raw() + } + + /// Get raw value of AUX_5 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_5_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_5 + #[inline(always)] + pub fn set_aux_5(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux5::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux5 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux5 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_4 +/// +/// - Extended ID: 157184036 (0x95e7024) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux4 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e7024)}); + + pub const AUX_4_MIN: f32 = 0_f32; + pub const AUX_4_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_4 from values + pub fn new(aux_4: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_4(aux_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_4(&self) -> f32 { + self.aux_4_raw() + } + + /// Get raw value of AUX_4 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_4 + #[inline(always)] + pub fn set_aux_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux4::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_3 +/// +/// - Extended ID: 157183780 (0x95e6f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e6f24)}); + + pub const AUX_3_MIN: f32 = 0_f32; + pub const AUX_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_3 from values + pub fn new(aux_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_3(aux_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_3(&self) -> f32 { + self.aux_3_raw() + } + + /// Get raw value of AUX_3 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_3 + #[inline(always)] + pub fn set_aux_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux3::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_2 +/// +/// - Extended ID: 157183524 (0x95e6e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e6e24)}); + + pub const AUX_2_MIN: f32 = 0_f32; + pub const AUX_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_2 from values + pub fn new(aux_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_2(aux_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_2(&self) -> f32 { + self.aux_2_raw() + } + + /// Get raw value of AUX_2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_2 + #[inline(always)] + pub fn set_aux_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Aux_1 +/// +/// - Extended ID: 157183268 (0x95e6d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Aux1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Aux1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95e6d24)}); + + pub const AUX_1_MIN: f32 = 0_f32; + pub const AUX_1_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Aux_1 from values + pub fn new(aux_1: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_aux_1(aux_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// AUX_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn aux_1(&self) -> f32 { + self.aux_1_raw() + } + + /// Get raw value of AUX_1 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn aux_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of AUX_1 + #[inline(always)] + pub fn set_aux_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Aux1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Aux1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Aux1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Pressure_5 +/// +/// - Extended ID: 156922148 (0x95a7124) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Pressure5 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Pressure5 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95a7124)}); + + pub const PRESSURE_5_MIN: f32 = 0_f32; + pub const PRESSURE_5_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Pressure_5 from values + pub fn new(pressure_5: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_pressure_5(pressure_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Pressure_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn pressure_5(&self) -> f32 { + self.pressure_5_raw() + } + + /// Get raw value of Pressure_5 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn pressure_5_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Pressure_5 + #[inline(always)] + pub fn set_pressure_5(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Pressure5::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Pressure5 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Pressure5 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Pressure_4 +/// +/// - Extended ID: 156921892 (0x95a7024) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Pressure4 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Pressure4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95a7024)}); + + pub const PRESSURE_4_MIN: f32 = 0_f32; + pub const PRESSURE_4_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Pressure_4 from values + pub fn new(pressure_4: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_pressure_4(pressure_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Pressure_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn pressure_4(&self) -> f32 { + self.pressure_4_raw() + } + + /// Get raw value of Pressure_4 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn pressure_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Pressure_4 + #[inline(always)] + pub fn set_pressure_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Pressure4::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Pressure4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Pressure4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Pressure_3 +/// +/// - Extended ID: 156921636 (0x95a6f24) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Pressure3 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Pressure3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95a6f24)}); + + pub const PRESSURE_3_MIN: f32 = 0_f32; + pub const PRESSURE_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Pressure_3 from values + pub fn new(pressure_3: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_pressure_3(pressure_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Pressure_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn pressure_3(&self) -> f32 { + self.pressure_3_raw() + } + + /// Get raw value of Pressure_3 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn pressure_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Pressure_3 + #[inline(always)] + pub fn set_pressure_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Pressure3::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Pressure3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Pressure3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Pressure_2 +/// +/// - Extended ID: 156921380 (0x95a6e24) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Pressure2 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Pressure2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95a6e24)}); + + pub const PRESSURE_2_MIN: f32 = 0_f32; + pub const PRESSURE_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Pressure_2 from values + pub fn new(pressure_2: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_pressure_2(pressure_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Pressure_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn pressure_2(&self) -> f32 { + self.pressure_2_raw() + } + + /// Get raw value of Pressure_2 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn pressure_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Pressure_2 + #[inline(always)] + pub fn set_pressure_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Pressure2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Pressure2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Pressure2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Pressure_1 +/// +/// - Extended ID: 156921124 (0x95a6d24) +/// - Size: 3 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Pressure1 { + raw: [u8; 3], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Pressure1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95a6d24)}); + + pub const PRESSURE_1_MIN: f32 = 0_f32; + pub const PRESSURE_1_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Pressure_1 from values + pub fn new(pressure_1: f32) -> Result { + let mut res = Self { raw: [0u8; 3] }; + res.set_pressure_1(pressure_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 3] { + &self.raw + } + + /// Pressure_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn pressure_1(&self) -> f32 { + self.pressure_1_raw() + } + + /// Get raw value of Pressure_1 + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn pressure_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Pressure_1 + #[inline(always)] + pub fn set_pressure_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Pressure1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Pressure1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 3 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 3]; + raw.copy_from_slice(&payload[..3]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Pressure1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Angle_3 +/// +/// - Extended ID: 157052708 (0x95c6f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Angle3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Angle3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95c6f24)}); + + pub const ANGLE_3_MIN: f32 = 0_f32; + pub const ANGLE_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Angle_3 from values + pub fn new(angle_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_angle_3(angle_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Angle_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn angle_3(&self) -> f32 { + self.angle_3_raw() + } + + /// Get raw value of Angle_3 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn angle_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Angle_3 + #[inline(always)] + pub fn set_angle_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Angle3::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Angle3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Angle3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Angle_2 +/// +/// - Extended ID: 157052452 (0x95c6e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Angle2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Angle2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95c6e24)}); + + pub const ANGLE_2_MIN: f32 = 0_f32; + pub const ANGLE_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Angle_2 from values + pub fn new(angle_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_angle_2(angle_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Angle_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn angle_2(&self) -> f32 { + self.angle_2_raw() + } + + /// Get raw value of Angle_2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn angle_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Angle_2 + #[inline(always)] + pub fn set_angle_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Angle2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Angle2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Angle2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Angle_1 +/// +/// - Extended ID: 157052196 (0x95c6d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Angle1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Angle1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95c6d24)}); + + pub const ANGLE_1_MIN: f32 = 0_f32; + pub const ANGLE_1_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Angle_1 from values + pub fn new(angle_1: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_angle_1(angle_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Angle_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn angle_1(&self) -> f32 { + self.angle_1_raw() + } + + /// Get raw value of Angle_1 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn angle_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Angle_1 + #[inline(always)] + pub fn set_angle_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Angle1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Angle1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Angle1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_25 +/// +/// - Extended ID: 156992804 (0x95b8524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp25 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp25 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8524)}); + + pub const TEMPERATURE_25_MIN: f32 = 0_f32; + pub const TEMPERATURE_25_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_25 from values + pub fn new(temperature_25: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_25(temperature_25)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_25 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_25(&self) -> f32 { + self.temperature_25_raw() + } + + /// Get raw value of Temperature_25 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_25_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_25 + #[inline(always)] + pub fn set_temperature_25(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp25::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp25 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp25 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_24 +/// +/// - Extended ID: 156992548 (0x95b8424) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp24 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp24 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8424)}); + + pub const TEMPERATURE_24_MIN: f32 = 0_f32; + pub const TEMPERATURE_24_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_24 from values + pub fn new(temperature_24: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_24(temperature_24)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_24 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_24(&self) -> f32 { + self.temperature_24_raw() + } + + /// Get raw value of Temperature_24 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_24_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_24 + #[inline(always)] + pub fn set_temperature_24(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp24::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp24 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp24 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_23 +/// +/// - Extended ID: 156992292 (0x95b8324) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp23 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp23 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8324)}); + + pub const TEMPERATURE_23_MIN: f32 = 0_f32; + pub const TEMPERATURE_23_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_23 from values + pub fn new(temperature_23: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_23(temperature_23)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_23 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_23(&self) -> f32 { + self.temperature_23_raw() + } + + /// Get raw value of Temperature_23 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_23_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_23 + #[inline(always)] + pub fn set_temperature_23(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp23::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp23 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp23 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_22 +/// +/// - Extended ID: 156992036 (0x95b8224) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp22 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp22 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8224)}); + + pub const TEMPERATURE_22_MIN: f32 = 0_f32; + pub const TEMPERATURE_22_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_22 from values + pub fn new(temperature_22: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_22(temperature_22)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_22 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_22(&self) -> f32 { + self.temperature_22_raw() + } + + /// Get raw value of Temperature_22 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_22_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_22 + #[inline(always)] + pub fn set_temperature_22(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp22::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp22 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp22 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_21 +/// +/// - Extended ID: 156991780 (0x95b8124) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp21 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp21 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8124)}); + + pub const TEMPERATURE_21_MIN: f32 = 0_f32; + pub const TEMPERATURE_21_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_21 from values + pub fn new(temperature_21: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_21(temperature_21)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_21 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_21(&self) -> f32 { + self.temperature_21_raw() + } + + /// Get raw value of Temperature_21 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_21_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_21 + #[inline(always)] + pub fn set_temperature_21(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp21::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp21 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp21 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_20 +/// +/// - Extended ID: 156991524 (0x95b8024) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp20 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp20 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b8024)}); + + pub const TEMPERATURE_20_MIN: f32 = 0_f32; + pub const TEMPERATURE_20_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_20 from values + pub fn new(temperature_20: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_20(temperature_20)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_20 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_20(&self) -> f32 { + self.temperature_20_raw() + } + + /// Get raw value of Temperature_20 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_20_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_20 + #[inline(always)] + pub fn set_temperature_20(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp20::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp20 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp20 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_19 +/// +/// - Extended ID: 156991268 (0x95b7f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp19 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp19 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7f24)}); + + pub const TEMPERATURE_19_MIN: f32 = 0_f32; + pub const TEMPERATURE_19_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_19 from values + pub fn new(temperature_19: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_19(temperature_19)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_19 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_19(&self) -> f32 { + self.temperature_19_raw() + } + + /// Get raw value of Temperature_19 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_19_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_19 + #[inline(always)] + pub fn set_temperature_19(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp19::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp19 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp19 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_18 +/// +/// - Extended ID: 156991012 (0x95b7e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp18 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp18 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7e24)}); + + pub const TEMPERATURE_18_MIN: f32 = 0_f32; + pub const TEMPERATURE_18_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_18 from values + pub fn new(temperature_18: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_18(temperature_18)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_18 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_18(&self) -> f32 { + self.temperature_18_raw() + } + + /// Get raw value of Temperature_18 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_18_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_18 + #[inline(always)] + pub fn set_temperature_18(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp18::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp18 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp18 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_17 +/// +/// - Extended ID: 156990756 (0x95b7d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp17 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp17 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7d24)}); + + pub const TEMPERATURE_17_MIN: f32 = 0_f32; + pub const TEMPERATURE_17_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_17 from values + pub fn new(temperature_17: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_17(temperature_17)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_17 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_17(&self) -> f32 { + self.temperature_17_raw() + } + + /// Get raw value of Temperature_17 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_17_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_17 + #[inline(always)] + pub fn set_temperature_17(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp17::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp17 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp17 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_16 +/// +/// - Extended ID: 156990500 (0x95b7c24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp16 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp16 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7c24)}); + + pub const TEMPERATURE_16_MIN: f32 = 0_f32; + pub const TEMPERATURE_16_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_16 from values + pub fn new(temperature_16: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_16(temperature_16)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_16 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_16(&self) -> f32 { + self.temperature_16_raw() + } + + /// Get raw value of Temperature_16 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_16_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_16 + #[inline(always)] + pub fn set_temperature_16(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp16::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp16 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp16 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_15 +/// +/// - Extended ID: 156990244 (0x95b7b24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp15 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp15 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7b24)}); + + pub const TEMPERATURE_15_MIN: f32 = 0_f32; + pub const TEMPERATURE_15_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_15 from values + pub fn new(temperature_15: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_15(temperature_15)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_15 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_15(&self) -> f32 { + self.temperature_15_raw() + } + + /// Get raw value of Temperature_15 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_15_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_15 + #[inline(always)] + pub fn set_temperature_15(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp15::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp15 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp15 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_14 +/// +/// - Extended ID: 156989988 (0x95b7a24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp14 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp14 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7a24)}); + + pub const TEMPERATURE_14_MIN: f32 = 0_f32; + pub const TEMPERATURE_14_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_14 from values + pub fn new(temperature_14: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_14(temperature_14)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_14 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_14(&self) -> f32 { + self.temperature_14_raw() + } + + /// Get raw value of Temperature_14 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_14_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_14 + #[inline(always)] + pub fn set_temperature_14(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp14::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp14 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp14 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_13 +/// +/// - Extended ID: 156989732 (0x95b7924) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp13 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp13 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7924)}); + + pub const TEMPERATURE_13_MIN: f32 = 0_f32; + pub const TEMPERATURE_13_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_13 from values + pub fn new(temperature_13: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_13(temperature_13)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_13 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_13(&self) -> f32 { + self.temperature_13_raw() + } + + /// Get raw value of Temperature_13 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_13_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_13 + #[inline(always)] + pub fn set_temperature_13(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp13::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp13 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp13 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_12 +/// +/// - Extended ID: 156989476 (0x95b7824) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp12 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp12 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7824)}); + + pub const TEMPERATURE_12_MIN: f32 = 0_f32; + pub const TEMPERATURE_12_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_12 from values + pub fn new(temperature_12: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_12(temperature_12)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_12(&self) -> f32 { + self.temperature_12_raw() + } + + /// Get raw value of Temperature_12 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_12_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_12 + #[inline(always)] + pub fn set_temperature_12(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp12::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp12 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp12 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_11 +/// +/// - Extended ID: 156989220 (0x95b7724) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp11 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp11 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7724)}); + + pub const TEMPERATURE_11_MIN: f32 = 0_f32; + pub const TEMPERATURE_11_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_11 from values + pub fn new(temperature_11: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_11(temperature_11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_11 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_11(&self) -> f32 { + self.temperature_11_raw() + } + + /// Get raw value of Temperature_11 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_11_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_11 + #[inline(always)] + pub fn set_temperature_11(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp11::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp11 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp11 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_10 +/// +/// - Extended ID: 156988964 (0x95b7624) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp10 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp10 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7624)}); + + pub const TEMPERATURE_10_MIN: f32 = 0_f32; + pub const TEMPERATURE_10_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_10 from values + pub fn new(temperature_10: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_10(temperature_10)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_10 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_10(&self) -> f32 { + self.temperature_10_raw() + } + + /// Get raw value of Temperature_10 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_10_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_10 + #[inline(always)] + pub fn set_temperature_10(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp10::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp10 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp10 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_9 +/// +/// - Extended ID: 156988708 (0x95b7524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp9 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp9 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7524)}); + + pub const TEMPERATURE_9_MIN: f32 = 0_f32; + pub const TEMPERATURE_9_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_9 from values + pub fn new(temperature_9: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_9(temperature_9)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_9(&self) -> f32 { + self.temperature_9_raw() + } + + /// Get raw value of Temperature_9 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_9_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_9 + #[inline(always)] + pub fn set_temperature_9(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp9::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp9 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp9 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_8 +/// +/// - Extended ID: 156988452 (0x95b7424) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp8 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp8 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7424)}); + + pub const TEMPERATURE_8_MIN: f32 = 0_f32; + pub const TEMPERATURE_8_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_8 from values + pub fn new(temperature_8: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_8(temperature_8)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_8(&self) -> f32 { + self.temperature_8_raw() + } + + /// Get raw value of Temperature_8 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_8_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_8 + #[inline(always)] + pub fn set_temperature_8(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp8::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp8 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp8 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_7 +/// +/// - Extended ID: 156988196 (0x95b7324) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp7 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp7 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7324)}); + + pub const TEMPERATURE_7_MIN: f32 = 0_f32; + pub const TEMPERATURE_7_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_7 from values + pub fn new(temperature_7: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_7(temperature_7)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_7(&self) -> f32 { + self.temperature_7_raw() + } + + /// Get raw value of Temperature_7 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_7_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_7 + #[inline(always)] + pub fn set_temperature_7(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp7::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp7 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp7 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_6 +/// +/// - Extended ID: 156987940 (0x95b7224) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp6 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp6 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7224)}); + + pub const TEMPERATURE_6_MIN: f32 = 0_f32; + pub const TEMPERATURE_6_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_6 from values + pub fn new(temperature_6: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_6(temperature_6)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_6(&self) -> f32 { + self.temperature_6_raw() + } + + /// Get raw value of Temperature_6 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_6_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_6 + #[inline(always)] + pub fn set_temperature_6(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp6::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp6 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp6 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_5 +/// +/// - Extended ID: 156987684 (0x95b7124) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp5 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp5 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7124)}); + + pub const TEMPERATURE_5_MIN: f32 = 0_f32; + pub const TEMPERATURE_5_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_5 from values + pub fn new(temperature_5: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_5(temperature_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_5(&self) -> f32 { + self.temperature_5_raw() + } + + /// Get raw value of Temperature_5 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_5_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_5 + #[inline(always)] + pub fn set_temperature_5(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp5::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp5 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp5 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_4 +/// +/// - Extended ID: 156987428 (0x95b7024) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp4 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b7024)}); + + pub const TEMPERATURE_4_MIN: f32 = 0_f32; + pub const TEMPERATURE_4_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_4 from values + pub fn new(temperature_4: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_4(temperature_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_4(&self) -> f32 { + self.temperature_4_raw() + } + + /// Get raw value of Temperature_4 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_4 + #[inline(always)] + pub fn set_temperature_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp4::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_3 +/// +/// - Extended ID: 156987172 (0x95b6f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b6f24)}); + + pub const TEMPERATURE_3_MIN: f32 = 0_f32; + pub const TEMPERATURE_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_3 from values + pub fn new(temperature_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_3(temperature_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_3(&self) -> f32 { + self.temperature_3_raw() + } + + /// Get raw value of Temperature_3 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_3 + #[inline(always)] + pub fn set_temperature_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp3::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_2 +/// +/// - Extended ID: 156986916 (0x95b6e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b6e24)}); + + pub const TEMPERATURE_2_MIN: f32 = 0_f32; + pub const TEMPERATURE_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_2 from values + pub fn new(temperature_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_2(temperature_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_2(&self) -> f32 { + self.temperature_2_raw() + } + + /// Get raw value of Temperature_2 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_2 + #[inline(always)] + pub fn set_temperature_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp2::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Temp_1 +/// +/// - Extended ID: 156986660 (0x95b6d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Temp1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Temp1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x95b6d24)}); + + pub const TEMPERATURE_1_MIN: f32 = 0_f32; + pub const TEMPERATURE_1_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Temp_1 from values + pub fn new(temperature_1: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_temperature_1(temperature_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Temperature_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn temperature_1(&self) -> f32 { + self.temperature_1_raw() + } + + /// Get raw value of Temperature_1 + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn temperature_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.1_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Temperature_1 + #[inline(always)] + pub fn set_temperature_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Temp1::MESSAGE_ID }); + } + let factor = 0.1_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Temp1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Temp1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_32 +/// +/// - Extended ID: 156011300 (0x94c8b24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog32 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog32 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8b24)}); + + pub const ANALOG_32_MIN: f32 = 0_f32; + pub const ANALOG_32_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_32 from values + pub fn new(analog_32: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_32(analog_32)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_32 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_32(&self) -> f32 { + self.analog_32_raw() + } + + /// Get raw value of Analog_32 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_32_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_32 + #[inline(always)] + pub fn set_analog_32(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog32::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog32 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog32 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_31 +/// +/// - Extended ID: 156011044 (0x94c8a24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog31 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog31 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8a24)}); + + pub const ANALOG_31_MIN: f32 = 0_f32; + pub const ANALOG_31_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_31 from values + pub fn new(analog_31: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_31(analog_31)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_31 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_31(&self) -> f32 { + self.analog_31_raw() + } + + /// Get raw value of Analog_31 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_31_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_31 + #[inline(always)] + pub fn set_analog_31(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog31::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog31 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog31 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_30 +/// +/// - Extended ID: 156010788 (0x94c8924) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog30 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog30 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8924)}); + + pub const ANALOG_30_MIN: f32 = 0_f32; + pub const ANALOG_30_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_30 from values + pub fn new(analog_30: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_30(analog_30)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_30 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_30(&self) -> f32 { + self.analog_30_raw() + } + + /// Get raw value of Analog_30 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_30_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_30 + #[inline(always)] + pub fn set_analog_30(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog30::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog30 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog30 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_29 +/// +/// - Extended ID: 156010532 (0x94c8824) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog29 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog29 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8824)}); + + pub const ANALOG_29_MIN: f32 = 0_f32; + pub const ANALOG_29_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_29 from values + pub fn new(analog_29: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_29(analog_29)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_29 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_29(&self) -> f32 { + self.analog_29_raw() + } + + /// Get raw value of Analog_29 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_29_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_29 + #[inline(always)] + pub fn set_analog_29(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog29::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog29 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog29 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_28 +/// +/// - Extended ID: 156010276 (0x94c8724) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog28 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog28 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8724)}); + + pub const ANALOG_28_MIN: f32 = 0_f32; + pub const ANALOG_28_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_28 from values + pub fn new(analog_28: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_28(analog_28)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_28 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_28(&self) -> f32 { + self.analog_28_raw() + } + + /// Get raw value of Analog_28 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_28_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_28 + #[inline(always)] + pub fn set_analog_28(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog28::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog28 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog28 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_27 +/// +/// - Extended ID: 156010020 (0x94c8624) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog27 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog27 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8624)}); + + pub const ANALOG_27_MIN: f32 = 0_f32; + pub const ANALOG_27_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_27 from values + pub fn new(analog_27: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_27(analog_27)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_27 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_27(&self) -> f32 { + self.analog_27_raw() + } + + /// Get raw value of Analog_27 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_27_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_27 + #[inline(always)] + pub fn set_analog_27(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog27::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog27 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog27 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_26 +/// +/// - Extended ID: 156009764 (0x94c8524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog26 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog26 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8524)}); + + pub const ANALOG_26_MIN: f32 = 0_f32; + pub const ANALOG_26_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_26 from values + pub fn new(analog_26: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_26(analog_26)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_26 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_26(&self) -> f32 { + self.analog_26_raw() + } + + /// Get raw value of Analog_26 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_26_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_26 + #[inline(always)] + pub fn set_analog_26(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog26::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog26 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog26 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_25 +/// +/// - Extended ID: 156009508 (0x94c8424) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog25 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog25 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8424)}); + + pub const ANALOG_25_MIN: f32 = 0_f32; + pub const ANALOG_25_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_25 from values + pub fn new(analog_25: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_25(analog_25)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_25 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_25(&self) -> f32 { + self.analog_25_raw() + } + + /// Get raw value of Analog_25 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_25_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_25 + #[inline(always)] + pub fn set_analog_25(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog25::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog25 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog25 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_15 +/// +/// - Extended ID: 156006948 (0x94c7a24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog15 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog15 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7a24)}); + + pub const ANALOG_15_MIN: f32 = 0_f32; + pub const ANALOG_15_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_15 from values + pub fn new(analog_15: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_15(analog_15)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_15 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_15(&self) -> f32 { + self.analog_15_raw() + } + + /// Get raw value of Analog_15 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_15_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_15 + #[inline(always)] + pub fn set_analog_15(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog15::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog15 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog15 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_14 +/// +/// - Extended ID: 156006692 (0x94c7924) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog14 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog14 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7924)}); + + pub const ANALOG_14_MIN: f32 = 0_f32; + pub const ANALOG_14_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_14 from values + pub fn new(analog_14: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_14(analog_14)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_14 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_14(&self) -> f32 { + self.analog_14_raw() + } + + /// Get raw value of Analog_14 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_14_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_14 + #[inline(always)] + pub fn set_analog_14(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog14::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog14 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog14 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_17 +/// +/// - Extended ID: 156007460 (0x94c7c24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog17 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog17 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7c24)}); + + pub const ANALOG_17_MIN: f32 = 0_f32; + pub const ANALOG_17_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_17 from values + pub fn new(analog_17: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_17(analog_17)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_17 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_17(&self) -> f32 { + self.analog_17_raw() + } + + /// Get raw value of Analog_17 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_17_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_17 + #[inline(always)] + pub fn set_analog_17(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog17::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog17 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog17 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_24 +/// +/// - Extended ID: 156009252 (0x94c8324) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog24 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog24 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8324)}); + + pub const ANALOG_24_MIN: f32 = 0_f32; + pub const ANALOG_24_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_24 from values + pub fn new(analog_24: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_24(analog_24)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_24 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_24(&self) -> f32 { + self.analog_24_raw() + } + + /// Get raw value of Analog_24 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_24_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_24 + #[inline(always)] + pub fn set_analog_24(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog24::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog24 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog24 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_23 +/// +/// - Extended ID: 156008996 (0x94c8224) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog23 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog23 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8224)}); + + pub const ANALOG_23_MIN: f32 = 0_f32; + pub const ANALOG_23_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_23 from values + pub fn new(analog_23: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_23(analog_23)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_23 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_23(&self) -> f32 { + self.analog_23_raw() + } + + /// Get raw value of Analog_23 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_23_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_23 + #[inline(always)] + pub fn set_analog_23(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog23::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog23 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog23 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_22 +/// +/// - Extended ID: 156008740 (0x94c8124) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog22 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog22 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8124)}); + + pub const ANALOG_22_MIN: f32 = 0_f32; + pub const ANALOG_22_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_22 from values + pub fn new(analog_22: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_22(analog_22)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_22 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_22(&self) -> f32 { + self.analog_22_raw() + } + + /// Get raw value of Analog_22 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_22_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_22 + #[inline(always)] + pub fn set_analog_22(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog22::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog22 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog22 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_21 +/// +/// - Extended ID: 156008484 (0x94c8024) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog21 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog21 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c8024)}); + + pub const ANALOG_21_MIN: f32 = 0_f32; + pub const ANALOG_21_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_21 from values + pub fn new(analog_21: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_21(analog_21)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_21 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_21(&self) -> f32 { + self.analog_21_raw() + } + + /// Get raw value of Analog_21 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_21_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_21 + #[inline(always)] + pub fn set_analog_21(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog21::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog21 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog21 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_20 +/// +/// - Extended ID: 156008228 (0x94c7f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog20 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog20 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7f24)}); + + pub const ANALOG_20_MIN: f32 = 0_f32; + pub const ANALOG_20_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_20 from values + pub fn new(analog_20: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_20(analog_20)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_20 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_20(&self) -> f32 { + self.analog_20_raw() + } + + /// Get raw value of Analog_20 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_20_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_20 + #[inline(always)] + pub fn set_analog_20(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog20::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog20 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog20 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_19 +/// +/// - Extended ID: 156007972 (0x94c7e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog19 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog19 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7e24)}); + + pub const ANALOG_19_MIN: f32 = 0_f32; + pub const ANALOG_19_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_19 from values + pub fn new(analog_19: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_19(analog_19)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_19 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_19(&self) -> f32 { + self.analog_19_raw() + } + + /// Get raw value of Analog_19 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_19_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_19 + #[inline(always)] + pub fn set_analog_19(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog19::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog19 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog19 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_16 +/// +/// - Extended ID: 156007204 (0x94c7b24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog16 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog16 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7b24)}); + + pub const ANALOG_16_MIN: f32 = 0_f32; + pub const ANALOG_16_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_16 from values + pub fn new(analog_16: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_16(analog_16)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_16 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_16(&self) -> f32 { + self.analog_16_raw() + } + + /// Get raw value of Analog_16 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_16_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_16 + #[inline(always)] + pub fn set_analog_16(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog16::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog16 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog16 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_18 +/// +/// - Extended ID: 156007716 (0x94c7d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog18 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog18 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7d24)}); + + pub const ANALOG_18_MIN: f32 = 0_f32; + pub const ANALOG_18_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_18 from values + pub fn new(analog_18: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_18(analog_18)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_18 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_18(&self) -> f32 { + self.analog_18_raw() + } + + /// Get raw value of Analog_18 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_18_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_18 + #[inline(always)] + pub fn set_analog_18(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog18::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog18 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog18 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_12 +/// +/// - Extended ID: 156006180 (0x94c7724) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog12 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog12 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7724)}); + + pub const ANALOG_12_MIN: f32 = 0_f32; + pub const ANALOG_12_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_12 from values + pub fn new(analog_12: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_12(analog_12)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_12 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_12(&self) -> f32 { + self.analog_12_raw() + } + + /// Get raw value of Analog_12 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_12_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_12 + #[inline(always)] + pub fn set_analog_12(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog12::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog12 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog12 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_11 +/// +/// - Extended ID: 156005924 (0x94c7624) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog11 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog11 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7624)}); + + pub const ANALOG_11_MIN: f32 = 0_f32; + pub const ANALOG_11_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_11 from values + pub fn new(analog_11: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_11(analog_11)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_11 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_11(&self) -> f32 { + self.analog_11_raw() + } + + /// Get raw value of Analog_11 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_11_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_11 + #[inline(always)] + pub fn set_analog_11(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog11::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog11 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog11 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_10 +/// +/// - Extended ID: 156005668 (0x94c7524) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog10 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog10 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7524)}); + + pub const ANALOG_10_MIN: f32 = 0_f32; + pub const ANALOG_10_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_10 from values + pub fn new(analog_10: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_10(analog_10)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_10 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_10(&self) -> f32 { + self.analog_10_raw() + } + + /// Get raw value of Analog_10 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_10_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_10 + #[inline(always)] + pub fn set_analog_10(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog10::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog10 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog10 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_9 +/// +/// - Extended ID: 156005412 (0x94c7424) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog9 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog9 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7424)}); + + pub const ANALOG_9_MIN: f32 = 0_f32; + pub const ANALOG_9_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_9 from values + pub fn new(analog_9: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_9(analog_9)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_9 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_9(&self) -> f32 { + self.analog_9_raw() + } + + /// Get raw value of Analog_9 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_9_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_9 + #[inline(always)] + pub fn set_analog_9(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog9::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog9 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog9 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_8 +/// +/// - Extended ID: 156005156 (0x94c7324) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog8 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog8 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7324)}); + + pub const ANALOG_8_MIN: f32 = 0_f32; + pub const ANALOG_8_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_8 from values + pub fn new(analog_8: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_8(analog_8)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_8 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_8(&self) -> f32 { + self.analog_8_raw() + } + + /// Get raw value of Analog_8 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_8_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_8 + #[inline(always)] + pub fn set_analog_8(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog8::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog8 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog8 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_7 +/// +/// - Extended ID: 156004900 (0x94c7224) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog7 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog7 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7224)}); + + pub const ANALOG_7_MIN: f32 = 0_f32; + pub const ANALOG_7_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_7 from values + pub fn new(analog_7: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_7(analog_7)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_7 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_7(&self) -> f32 { + self.analog_7_raw() + } + + /// Get raw value of Analog_7 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_7_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_7 + #[inline(always)] + pub fn set_analog_7(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog7::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog7 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog7 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_6 +/// +/// - Extended ID: 156004644 (0x94c7124) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog6 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog6 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7124)}); + + pub const ANALOG_6_MIN: f32 = 0_f32; + pub const ANALOG_6_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_6 from values + pub fn new(analog_6: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_6(analog_6)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_6 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_6(&self) -> f32 { + self.analog_6_raw() + } + + /// Get raw value of Analog_6 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_6_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_6 + #[inline(always)] + pub fn set_analog_6(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog6::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog6 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog6 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_5 +/// +/// - Extended ID: 156004388 (0x94c7024) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog5 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog5 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c7024)}); + + pub const ANALOG_5_MIN: f32 = 0_f32; + pub const ANALOG_5_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_5 from values + pub fn new(analog_5: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_5(analog_5)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_5 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_5(&self) -> f32 { + self.analog_5_raw() + } + + /// Get raw value of Analog_5 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_5_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_5 + #[inline(always)] + pub fn set_analog_5(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog5::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog5 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog5 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_4 +/// +/// - Extended ID: 156004132 (0x94c6f24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog4 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog4 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c6f24)}); + + pub const ANALOG_4_MIN: f32 = 0_f32; + pub const ANALOG_4_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_4 from values + pub fn new(analog_4: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_4(analog_4)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_4 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_4(&self) -> f32 { + self.analog_4_raw() + } + + /// Get raw value of Analog_4 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_4_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_4 + #[inline(always)] + pub fn set_analog_4(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog4::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog4 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog4 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_3 +/// +/// - Extended ID: 156003876 (0x94c6e24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog3 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog3 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c6e24)}); + + pub const ANALOG_3_MIN: f32 = 0_f32; + pub const ANALOG_3_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_3 from values + pub fn new(analog_3: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_3(analog_3)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_3 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_3(&self) -> f32 { + self.analog_3_raw() + } + + /// Get raw value of Analog_3 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_3_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_3 + #[inline(always)] + pub fn set_analog_3(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog3::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog3 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog3 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_2 +/// +/// - Extended ID: 156003620 (0x94c6d24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog2 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c6d24)}); + + pub const ANALOG_2_MIN: f32 = 0_f32; + pub const ANALOG_2_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_2 from values + pub fn new(analog_2: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_2(analog_2)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_2 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_2(&self) -> f32 { + self.analog_2_raw() + } + + /// Get raw value of Analog_2 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_2 + #[inline(always)] + pub fn set_analog_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog2::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Analog_1 +/// +/// - Extended ID: 156003364 (0x94c6c24) +/// - Size: 2 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Analog1 { + raw: [u8; 2], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Analog1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94c6c24)}); + + pub const ANALOG_1_MIN: f32 = 0_f32; + pub const ANALOG_1_MAX: f32 = 0_f32; + + /// Construct new RT_DL1MK3_Analog_1 from values + pub fn new(analog_1: f32) -> Result { + let mut res = Self { raw: [0u8; 2] }; + res.set_analog_1(analog_1)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 2] { + &self.raw + } + + /// Analog_1 + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn analog_1(&self) -> f32 { + self.analog_1_raw() + } + + /// Get raw value of Analog_1 + /// + /// - Start bit: 7 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: BigEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn analog_1_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_be::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Analog_1 + #[inline(always)] + pub fn set_analog_1(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 0_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Analog1::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[0..16].store_be(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Analog1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 2 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 2]; + raw.copy_from_slice(&payload[..2]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Analog1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_DL1MK3_Accel +/// +/// - Extended ID: 155872292 (0x94a6c24) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtDl1mk3Accel { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtDl1mk3Accel { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a6c24)}); + + pub const ACCEL_VERTICAL_MIN: f32 = -65_f32; + pub const ACCEL_VERTICAL_MAX: f32 = 65_f32; + pub const ACCEL_LATERAL_MIN: f32 = -65_f32; + pub const ACCEL_LATERAL_MAX: f32 = 65_f32; + pub const ACCEL_LONGITUDINAL_MIN: f32 = -65_f32; + pub const ACCEL_LONGITUDINAL_MAX: f32 = 65_f32; + pub const ACCURACY_ACCEL_MIN: u8 = 0_u8; + pub const ACCURACY_ACCEL_MAX: u8 = 255_u8; + + /// Construct new RT_DL1MK3_Accel from values + pub fn new(accel_vertical: f32, accel_lateral: f32, accel_longitudinal: f32, accuracy_accel: u8, validity_accel_vertical: bool, validity_accel_lateral: bool, validity_accel_longitudinal: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_accel_vertical(accel_vertical)?; + res.set_accel_lateral(accel_lateral)?; + res.set_accel_longitudinal(accel_longitudinal)?; + res.set_accuracy_accel(accuracy_accel)?; + res.set_validity_accel_vertical(validity_accel_vertical)?; + res.set_validity_accel_lateral(validity_accel_lateral)?; + res.set_validity_accel_longitudinal(validity_accel_longitudinal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Accel_Vertical + /// + /// Vertical acceleration. This is positive when the vehicle accelerates in an upwards direction, e.g. when travelling through a dip. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_vertical(&self) -> f32 { + self.accel_vertical_raw() + } + + /// Get raw value of Accel_Vertical + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_vertical_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Vertical + #[inline(always)] + pub fn set_accel_vertical(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Accel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Accel_Lateral + /// + /// Lateral acceleration. This is positive when the vehicle accelerates towards the right, e.g. when cornering around a right-hand bend. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_lateral(&self) -> f32 { + self.accel_lateral_raw() + } + + /// Get raw value of Accel_Lateral + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_lateral_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Lateral + #[inline(always)] + pub fn set_accel_lateral(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Accel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Accel_Longitudinal + /// + /// Longitudinal acceleration. This is positive when the vehicle accelerates in a forwards direction. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_longitudinal(&self) -> f32 { + self.accel_longitudinal_raw() + } + + /// Get raw value of Accel_Longitudinal + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_longitudinal_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Longitudinal + #[inline(always)] + pub fn set_accel_longitudinal(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Accel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_Accel + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_accel(&self) -> u8 { + self.accuracy_accel_raw() + } + + /// Get raw value of Accuracy_Accel + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_accel_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Accel + #[inline(always)] + pub fn set_accuracy_accel(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtDl1mk3Accel::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtDl1mk3Accel::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Accel_Vertical + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_vertical(&self) -> bool { + self.validity_accel_vertical_raw() + } + + /// Get raw value of Validity_Accel_Vertical + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_vertical_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Vertical + #[inline(always)] + pub fn set_validity_accel_vertical(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Accel_Lateral + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_lateral(&self) -> bool { + self.validity_accel_lateral_raw() + } + + /// Get raw value of Validity_Accel_Lateral + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_lateral_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Lateral + #[inline(always)] + pub fn set_validity_accel_lateral(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Accel_Longitudinal + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_longitudinal(&self) -> bool { + self.validity_accel_longitudinal_raw() + } + + /// Get raw value of Validity_Accel_Longitudinal + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_longitudinal_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Longitudinal + #[inline(always)] + pub fn set_validity_accel_longitudinal(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtDl1mk3Accel { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtDl1mk3Accel { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_4_Vel_NED_2 +/// +/// - Extended ID: 156868130 (0x9599e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt4VelNed2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt4VelNed2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9599e22)}); + + pub const VIRTUAL_4_SLIP_MIN: f32 = -180_f32; + pub const VIRTUAL_4_SLIP_MAX: f32 = 180_f32; + pub const VIRTUAL_4_HEADING_MIN: f32 = -180_f32; + pub const VIRTUAL_4_HEADING_MAX: f32 = 180_f32; + pub const VIRTUAL_4_VEL_NED_D_MIN: f32 = -838_f32; + pub const VIRTUAL_4_VEL_NED_D_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_4_Vel_NED_2 from values + pub fn new(virtual_4_slip: f32, virtual_4_heading: f32, virtual_4_vel_ned_d: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_4_slip(virtual_4_slip)?; + res.set_virtual_4_heading(virtual_4_heading)?; + res.set_virtual_4_vel_ned_d(virtual_4_vel_ned_d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_4_Slip + /// + /// Slip is defined as the difference between yaw and heading. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_slip(&self) -> f32 { + self.virtual_4_slip_raw() + } + + /// Get raw value of Virtual_4_Slip + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_slip_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Slip + #[inline(always)] + pub fn set_virtual_4_slip(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Virtual_4_Heading + /// + /// This is GPS heading, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_heading(&self) -> f32 { + self.virtual_4_heading_raw() + } + + /// Get raw value of Virtual_4_Heading + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Heading + #[inline(always)] + pub fn set_virtual_4_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_4_Vel_NED_D + /// + /// VELNED D velocity. This is the velocity vector directly downwards towards the Earth centre at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_vel_ned_d(&self) -> f32 { + self.virtual_4_vel_ned_d_raw() + } + + /// Get raw value of Virtual_4_Vel_NED_D + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_vel_ned_d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Vel_NED_D + #[inline(always)] + pub fn set_virtual_4_vel_ned_d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4VelNed2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt4VelNed2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt4VelNed2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_4_Vel_NED_1 +/// +/// - Extended ID: 156867874 (0x9599d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt4VelNed1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt4VelNed1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9599d22)}); + + pub const VIRTUAL_4_VEL_NED_E_MIN: f32 = -838_f32; + pub const VIRTUAL_4_VEL_NED_E_MAX: f32 = 838_f32; + pub const VIRTUAL_4_VEL_NED_N_MIN: f32 = -838_f32; + pub const VIRTUAL_4_VEL_NED_N_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_4_Vel_NED_1 from values + pub fn new(virtual_4_vel_ned_e: f32, virtual_4_vel_ned_n: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_4_vel_ned_e(virtual_4_vel_ned_e)?; + res.set_virtual_4_vel_ned_n(virtual_4_vel_ned_n)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_4_Vel_NED_E + /// + /// VELNED E velocity. This is the velocity vector directly East at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_vel_ned_e(&self) -> f32 { + self.virtual_4_vel_ned_e_raw() + } + + /// Get raw value of Virtual_4_Vel_NED_E + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_vel_ned_e_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Vel_NED_E + #[inline(always)] + pub fn set_virtual_4_vel_ned_e(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// Virtual_4_Vel_NED_N + /// + /// VELNED N velocity. This is the velocity vector directly North at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_vel_ned_n(&self) -> f32 { + self.virtual_4_vel_ned_n_raw() + } + + /// Get raw value of Virtual_4_Vel_NED_N + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_vel_ned_n_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Vel_NED_N + #[inline(always)] + pub fn set_virtual_4_vel_ned_n(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt4VelNed1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt4VelNed1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_4_Offset +/// +/// - Extended ID: 156867618 (0x9599c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt4Offset { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt4Offset { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9599c22)}); + + pub const VIRTUAL_4_OFFSET_Z_MIN: f32 = -32.768_f32; + pub const VIRTUAL_4_OFFSET_Z_MAX: f32 = 32.767_f32; + pub const VIRTUAL_4_OFFSET_Y_MIN: f32 = -32.768_f32; + pub const VIRTUAL_4_OFFSET_Y_MAX: f32 = 32.767_f32; + pub const VIRTUAL_4_OFFSET_X_MIN: f32 = -32.768_f32; + pub const VIRTUAL_4_OFFSET_X_MAX: f32 = 32.767_f32; + + /// Construct new RT_SB_INS_Vpt_4_Offset from values + pub fn new(virtual_4_offset_z: f32, virtual_4_offset_y: f32, virtual_4_offset_x: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_4_offset_z(virtual_4_offset_z)?; + res.set_virtual_4_offset_y(virtual_4_offset_y)?; + res.set_virtual_4_offset_x(virtual_4_offset_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_4_Offset_Z + /// + /// Z offset (+ve downwards) of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_offset_z(&self) -> f32 { + self.virtual_4_offset_z_raw() + } + + /// Get raw value of Virtual_4_Offset_Z + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_offset_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Offset_Z + #[inline(always)] + pub fn set_virtual_4_offset_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_4_Offset_Y + /// + /// Y offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_offset_y(&self) -> f32 { + self.virtual_4_offset_y_raw() + } + + /// Get raw value of Virtual_4_Offset_Y + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_offset_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Offset_Y + #[inline(always)] + pub fn set_virtual_4_offset_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Virtual_4_Offset_X + /// + /// X offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_4_offset_x(&self) -> f32 { + self.virtual_4_offset_x_raw() + } + + /// Get raw value of Virtual_4_Offset_X + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_4_offset_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_4_Offset_X + #[inline(always)] + pub fn set_virtual_4_offset_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt4Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt4Offset { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt4Offset { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_3_Vel_NED_2 +/// +/// - Extended ID: 156864034 (0x9598e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt3VelNed2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt3VelNed2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9598e22)}); + + pub const VIRTUAL_3_SLIP_MIN: f32 = -180_f32; + pub const VIRTUAL_3_SLIP_MAX: f32 = 180_f32; + pub const VIRTUAL_3_HEADING_MIN: f32 = -180_f32; + pub const VIRTUAL_3_HEADING_MAX: f32 = 180_f32; + pub const VIRTUAL_3_VEL_NED_D_MIN: f32 = -838_f32; + pub const VIRTUAL_3_VEL_NED_D_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_3_Vel_NED_2 from values + pub fn new(virtual_3_slip: f32, virtual_3_heading: f32, virtual_3_vel_ned_d: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_3_slip(virtual_3_slip)?; + res.set_virtual_3_heading(virtual_3_heading)?; + res.set_virtual_3_vel_ned_d(virtual_3_vel_ned_d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_3_Slip + /// + /// Slip is defined as the difference between yaw and heading. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_slip(&self) -> f32 { + self.virtual_3_slip_raw() + } + + /// Get raw value of Virtual_3_Slip + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_slip_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Slip + #[inline(always)] + pub fn set_virtual_3_slip(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Virtual_3_Heading + /// + /// This is GPS heading, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_heading(&self) -> f32 { + self.virtual_3_heading_raw() + } + + /// Get raw value of Virtual_3_Heading + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Heading + #[inline(always)] + pub fn set_virtual_3_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_3_Vel_NED_D + /// + /// VELNED D velocity. This is the velocity vector directly downwards towards the Earth centre at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_vel_ned_d(&self) -> f32 { + self.virtual_3_vel_ned_d_raw() + } + + /// Get raw value of Virtual_3_Vel_NED_D + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_vel_ned_d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Vel_NED_D + #[inline(always)] + pub fn set_virtual_3_vel_ned_d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3VelNed2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt3VelNed2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt3VelNed2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_3_Vel_NED_1 +/// +/// - Extended ID: 156863778 (0x9598d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt3VelNed1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt3VelNed1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9598d22)}); + + pub const VIRTUAL_3_VEL_NED_E_MIN: f32 = -838_f32; + pub const VIRTUAL_3_VEL_NED_E_MAX: f32 = 838_f32; + pub const VIRTUAL_3_VEL_NED_N_MIN: f32 = -838_f32; + pub const VIRTUAL_3_VEL_NED_N_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_3_Vel_NED_1 from values + pub fn new(virtual_3_vel_ned_e: f32, virtual_3_vel_ned_n: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_3_vel_ned_e(virtual_3_vel_ned_e)?; + res.set_virtual_3_vel_ned_n(virtual_3_vel_ned_n)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_3_Vel_NED_E + /// + /// VELNED E velocity. This is the velocity vector directly East at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_vel_ned_e(&self) -> f32 { + self.virtual_3_vel_ned_e_raw() + } + + /// Get raw value of Virtual_3_Vel_NED_E + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_vel_ned_e_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Vel_NED_E + #[inline(always)] + pub fn set_virtual_3_vel_ned_e(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// Virtual_3_Vel_NED_N + /// + /// VELNED N velocity. This is the velocity vector directly North at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_vel_ned_n(&self) -> f32 { + self.virtual_3_vel_ned_n_raw() + } + + /// Get raw value of Virtual_3_Vel_NED_N + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_vel_ned_n_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Vel_NED_N + #[inline(always)] + pub fn set_virtual_3_vel_ned_n(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt3VelNed1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt3VelNed1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_3_Offset +/// +/// - Extended ID: 156863522 (0x9598c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt3Offset { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt3Offset { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9598c22)}); + + pub const VIRTUAL_3_OFFSET_Z_MIN: f32 = -32.768_f32; + pub const VIRTUAL_3_OFFSET_Z_MAX: f32 = 32.767_f32; + pub const VIRTUAL_3_OFFSET_Y_MIN: f32 = -32.768_f32; + pub const VIRTUAL_3_OFFSET_Y_MAX: f32 = 32.767_f32; + pub const VIRTUAL_3_OFFSET_X_MIN: f32 = -32.768_f32; + pub const VIRTUAL_3_OFFSET_X_MAX: f32 = 32.767_f32; + + /// Construct new RT_SB_INS_Vpt_3_Offset from values + pub fn new(virtual_3_offset_z: f32, virtual_3_offset_y: f32, virtual_3_offset_x: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_3_offset_z(virtual_3_offset_z)?; + res.set_virtual_3_offset_y(virtual_3_offset_y)?; + res.set_virtual_3_offset_x(virtual_3_offset_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_3_Offset_Z + /// + /// Z offset (+ve downwards) of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_offset_z(&self) -> f32 { + self.virtual_3_offset_z_raw() + } + + /// Get raw value of Virtual_3_Offset_Z + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_offset_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Offset_Z + #[inline(always)] + pub fn set_virtual_3_offset_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_3_Offset_Y + /// + /// Y offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_offset_y(&self) -> f32 { + self.virtual_3_offset_y_raw() + } + + /// Get raw value of Virtual_3_Offset_Y + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_offset_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Offset_Y + #[inline(always)] + pub fn set_virtual_3_offset_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Virtual_3_Offset_X + /// + /// X offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_3_offset_x(&self) -> f32 { + self.virtual_3_offset_x_raw() + } + + /// Get raw value of Virtual_3_Offset_X + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_3_offset_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_3_Offset_X + #[inline(always)] + pub fn set_virtual_3_offset_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt3Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt3Offset { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt3Offset { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_2_Vel_NED_2 +/// +/// - Extended ID: 156859938 (0x9597e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt2VelNed2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt2VelNed2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9597e22)}); + + pub const VIRTUAL_2_SLIP_MIN: f32 = -180_f32; + pub const VIRTUAL_2_SLIP_MAX: f32 = 180_f32; + pub const VIRTUAL_2_HEADING_MIN: f32 = -180_f32; + pub const VIRTUAL_2_HEADING_MAX: f32 = 180_f32; + pub const VIRTUAL_2_VEL_NED_D_MIN: f32 = -838_f32; + pub const VIRTUAL_2_VEL_NED_D_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_2_Vel_NED_2 from values + pub fn new(virtual_2_slip: f32, virtual_2_heading: f32, virtual_2_vel_ned_d: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_2_slip(virtual_2_slip)?; + res.set_virtual_2_heading(virtual_2_heading)?; + res.set_virtual_2_vel_ned_d(virtual_2_vel_ned_d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_2_Slip + /// + /// Slip is defined as the difference between yaw and heading. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_slip(&self) -> f32 { + self.virtual_2_slip_raw() + } + + /// Get raw value of Virtual_2_Slip + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_slip_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Slip + #[inline(always)] + pub fn set_virtual_2_slip(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Virtual_2_Heading + /// + /// This is GPS heading, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_heading(&self) -> f32 { + self.virtual_2_heading_raw() + } + + /// Get raw value of Virtual_2_Heading + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Heading + #[inline(always)] + pub fn set_virtual_2_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_2_Vel_NED_D + /// + /// VELNED D velocity. This is the velocity vector directly downwards towards the Earth centre at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_vel_ned_d(&self) -> f32 { + self.virtual_2_vel_ned_d_raw() + } + + /// Get raw value of Virtual_2_Vel_NED_D + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_vel_ned_d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Vel_NED_D + #[inline(always)] + pub fn set_virtual_2_vel_ned_d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2VelNed2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt2VelNed2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt2VelNed2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_2_Vel_NED_1 +/// +/// - Extended ID: 156859682 (0x9597d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt2VelNed1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt2VelNed1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9597d22)}); + + pub const VIRTUAL_2_VEL_NED_E_MIN: f32 = -838_f32; + pub const VIRTUAL_2_VEL_NED_E_MAX: f32 = 838_f32; + pub const VIRTUAL_2_VEL_NED_N_MIN: f32 = -838_f32; + pub const VIRTUAL_2_VEL_NED_N_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_2_Vel_NED_1 from values + pub fn new(virtual_2_vel_ned_e: f32, virtual_2_vel_ned_n: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_2_vel_ned_e(virtual_2_vel_ned_e)?; + res.set_virtual_2_vel_ned_n(virtual_2_vel_ned_n)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_2_Vel_NED_E + /// + /// VELNED E velocity. This is the velocity vector directly East at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_vel_ned_e(&self) -> f32 { + self.virtual_2_vel_ned_e_raw() + } + + /// Get raw value of Virtual_2_Vel_NED_E + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_vel_ned_e_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Vel_NED_E + #[inline(always)] + pub fn set_virtual_2_vel_ned_e(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// Virtual_2_Vel_NED_N + /// + /// VELNED N velocity. This is the velocity vector directly North at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_vel_ned_n(&self) -> f32 { + self.virtual_2_vel_ned_n_raw() + } + + /// Get raw value of Virtual_2_Vel_NED_N + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_vel_ned_n_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Vel_NED_N + #[inline(always)] + pub fn set_virtual_2_vel_ned_n(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt2VelNed1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt2VelNed1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_2_Offset +/// +/// - Extended ID: 156859426 (0x9597c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt2Offset { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt2Offset { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9597c22)}); + + pub const VIRTUAL_2_OFFSET_Z_MIN: f32 = -32.768_f32; + pub const VIRTUAL_2_OFFSET_Z_MAX: f32 = 32.767_f32; + pub const VIRTUAL_2_OFFSET_Y_MIN: f32 = -32.768_f32; + pub const VIRTUAL_2_OFFSET_Y_MAX: f32 = 32.767_f32; + pub const VIRTUAL_2_OFFSET_X_MIN: f32 = -32.768_f32; + pub const VIRTUAL_2_OFFSET_X_MAX: f32 = 32.767_f32; + + /// Construct new RT_SB_INS_Vpt_2_Offset from values + pub fn new(virtual_2_offset_z: f32, virtual_2_offset_y: f32, virtual_2_offset_x: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_2_offset_z(virtual_2_offset_z)?; + res.set_virtual_2_offset_y(virtual_2_offset_y)?; + res.set_virtual_2_offset_x(virtual_2_offset_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_2_Offset_Z + /// + /// Z offset (+ve downwards) of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_offset_z(&self) -> f32 { + self.virtual_2_offset_z_raw() + } + + /// Get raw value of Virtual_2_Offset_Z + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_offset_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Offset_Z + #[inline(always)] + pub fn set_virtual_2_offset_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_2_Offset_Y + /// + /// Y offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_offset_y(&self) -> f32 { + self.virtual_2_offset_y_raw() + } + + /// Get raw value of Virtual_2_Offset_Y + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_offset_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Offset_Y + #[inline(always)] + pub fn set_virtual_2_offset_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Virtual_2_Offset_X + /// + /// X offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_2_offset_x(&self) -> f32 { + self.virtual_2_offset_x_raw() + } + + /// Get raw value of Virtual_2_Offset_X + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_2_offset_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_2_Offset_X + #[inline(always)] + pub fn set_virtual_2_offset_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt2Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt2Offset { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt2Offset { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_1_Vel_NED_2 +/// +/// - Extended ID: 156855842 (0x9596e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt1VelNed2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt1VelNed2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9596e22)}); + + pub const VIRTUAL_1_SLIP_MIN: f32 = -180_f32; + pub const VIRTUAL_1_SLIP_MAX: f32 = 180_f32; + pub const VIRTUAL_1_HEADING_MIN: f32 = -180_f32; + pub const VIRTUAL_1_HEADING_MAX: f32 = 180_f32; + pub const VIRTUAL_1_VEL_NED_D_MIN: f32 = -838_f32; + pub const VIRTUAL_1_VEL_NED_D_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_1_Vel_NED_2 from values + pub fn new(virtual_1_slip: f32, virtual_1_heading: f32, virtual_1_vel_ned_d: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_1_slip(virtual_1_slip)?; + res.set_virtual_1_heading(virtual_1_heading)?; + res.set_virtual_1_vel_ned_d(virtual_1_vel_ned_d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_1_Slip + /// + /// Slip is defined as the difference between yaw and heading. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_slip(&self) -> f32 { + self.virtual_1_slip_raw() + } + + /// Get raw value of Virtual_1_Slip + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_slip_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Slip + #[inline(always)] + pub fn set_virtual_1_slip(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Virtual_1_Heading + /// + /// This is GPS heading, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_heading(&self) -> f32 { + self.virtual_1_heading_raw() + } + + /// Get raw value of Virtual_1_Heading + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Heading + #[inline(always)] + pub fn set_virtual_1_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1VelNed2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_1_Vel_NED_D + /// + /// VELNED D velocity. This is the velocity vector directly downwards towards the Earth centre at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_vel_ned_d(&self) -> f32 { + self.virtual_1_vel_ned_d_raw() + } + + /// Get raw value of Virtual_1_Vel_NED_D + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_vel_ned_d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Vel_NED_D + #[inline(always)] + pub fn set_virtual_1_vel_ned_d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1VelNed2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt1VelNed2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt1VelNed2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_1_Vel_NED_1 +/// +/// - Extended ID: 156855586 (0x9596d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt1VelNed1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt1VelNed1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9596d22)}); + + pub const VIRTUAL_1_VEL_NED_E_MIN: f32 = -838_f32; + pub const VIRTUAL_1_VEL_NED_E_MAX: f32 = 838_f32; + pub const VIRTUAL_1_VEL_NED_N_MIN: f32 = -838_f32; + pub const VIRTUAL_1_VEL_NED_N_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vpt_1_Vel_NED_1 from values + pub fn new(virtual_1_vel_ned_e: f32, virtual_1_vel_ned_n: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_1_vel_ned_e(virtual_1_vel_ned_e)?; + res.set_virtual_1_vel_ned_n(virtual_1_vel_ned_n)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_1_Vel_NED_E + /// + /// VELNED E velocity. This is the velocity vector directly East at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_vel_ned_e(&self) -> f32 { + self.virtual_1_vel_ned_e_raw() + } + + /// Get raw value of Virtual_1_Vel_NED_E + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_vel_ned_e_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Vel_NED_E + #[inline(always)] + pub fn set_virtual_1_vel_ned_e(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// Virtual_1_Vel_NED_N + /// + /// VELNED N velocity. This is the velocity vector directly North at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_vel_ned_n(&self) -> f32 { + self.virtual_1_vel_ned_n_raw() + } + + /// Get raw value of Virtual_1_Vel_NED_N + /// + /// - Start bit: 0 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_vel_ned_n_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..24].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Vel_NED_N + #[inline(always)] + pub fn set_virtual_1_vel_ned_n(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1VelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..24].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt1VelNed1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt1VelNed1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vpt_1_Offset +/// +/// - Extended ID: 156855330 (0x9596c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVpt1Offset { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVpt1Offset { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9596c22)}); + + pub const VIRTUAL_1_OFFSET_Z_MIN: f32 = -32.768_f32; + pub const VIRTUAL_1_OFFSET_Z_MAX: f32 = 32.767_f32; + pub const VIRTUAL_1_OFFSET_Y_MIN: f32 = -32.768_f32; + pub const VIRTUAL_1_OFFSET_Y_MAX: f32 = 32.767_f32; + pub const VIRTUAL_1_OFFSET_X_MIN: f32 = -32.768_f32; + pub const VIRTUAL_1_OFFSET_X_MAX: f32 = 32.767_f32; + + /// Construct new RT_SB_INS_Vpt_1_Offset from values + pub fn new(virtual_1_offset_z: f32, virtual_1_offset_y: f32, virtual_1_offset_x: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_virtual_1_offset_z(virtual_1_offset_z)?; + res.set_virtual_1_offset_y(virtual_1_offset_y)?; + res.set_virtual_1_offset_x(virtual_1_offset_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Virtual_1_Offset_Z + /// + /// Z offset (+ve downwards) of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_offset_z(&self) -> f32 { + self.virtual_1_offset_z_raw() + } + + /// Get raw value of Virtual_1_Offset_Z + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_offset_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Offset_Z + #[inline(always)] + pub fn set_virtual_1_offset_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Virtual_1_Offset_Y + /// + /// Y offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_offset_y(&self) -> f32 { + self.virtual_1_offset_y_raw() + } + + /// Get raw value of Virtual_1_Offset_Y + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_offset_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Offset_Y + #[inline(always)] + pub fn set_virtual_1_offset_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Virtual_1_Offset_X + /// + /// X offset of the virtual point in the vehicle body frame. + /// + /// - Min: -32.768 + /// - Max: 32.767 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn virtual_1_offset_x(&self) -> f32 { + self.virtual_1_offset_x_raw() + } + + /// Get raw value of Virtual_1_Offset_X + /// + /// - Start bit: 0 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn virtual_1_offset_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..16].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Virtual_1_Offset_X + #[inline(always)] + pub fn set_virtual_1_offset_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -32.768_f32 || 32.767_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVpt1Offset::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..16].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVpt1Offset { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVpt1Offset { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Slip +/// +/// - Extended ID: 156795426 (0x9588222) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsSlip { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsSlip { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9588222)}); + + pub const INS_SQUAT_MIN: f32 = -360_f32; + pub const INS_SQUAT_MAX: f32 = 360_f32; + pub const ACCURACY_INS_SQUAT_MIN: u8 = 0_u8; + pub const ACCURACY_INS_SQUAT_MAX: u8 = 255_u8; + pub const INS_SLIP_MIN: f32 = -360_f32; + pub const INS_SLIP_MAX: f32 = 360_f32; + pub const ACCURACY_INS_SLIP_MIN: u8 = 0_u8; + pub const ACCURACY_INS_SLIP_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Slip from values + pub fn new(ins_squat: f32, accuracy_ins_squat: u8, ins_slip: f32, accuracy_ins_slip: u8, validity_ins_squat: bool, validity_ins_slip: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_squat(ins_squat)?; + res.set_accuracy_ins_squat(accuracy_ins_squat)?; + res.set_ins_slip(ins_slip)?; + res.set_accuracy_ins_slip(accuracy_ins_slip)?; + res.set_validity_ins_squat(validity_ins_squat)?; + res.set_validity_ins_slip(validity_ins_slip)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Squat + /// + /// Squat is defined as the difference between pitch and gradient + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_squat(&self) -> f32 { + self.ins_squat_raw() + } + + /// Get raw value of INS_Squat + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_squat_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Squat + #[inline(always)] + pub fn set_ins_squat(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsSlip::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Squat + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_squat(&self) -> u8 { + self.accuracy_ins_squat_raw() + } + + /// Get raw value of Accuracy_INS_Squat + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_squat_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Squat + #[inline(always)] + pub fn set_accuracy_ins_squat(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsSlip::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsSlip::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// INS_Slip + /// + /// Slip is defined as the difference between yaw and heading + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_slip(&self) -> f32 { + self.ins_slip_raw() + } + + /// Get raw value of INS_Slip + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_slip_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Slip + #[inline(always)] + pub fn set_ins_slip(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsSlip::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Slip + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_slip(&self) -> u8 { + self.accuracy_ins_slip_raw() + } + + /// Get raw value of Accuracy_INS_Slip + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_slip_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Slip + #[inline(always)] + pub fn set_accuracy_ins_slip(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsSlip::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsSlip::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Squat + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_squat(&self) -> bool { + self.validity_ins_squat_raw() + } + + /// Get raw value of Validity_INS_Squat + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_squat_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Squat + #[inline(always)] + pub fn set_validity_ins_squat(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Slip + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_slip(&self) -> bool { + self.validity_ins_slip_raw() + } + + /// Get raw value of Validity_INS_Slip + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_slip_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Slip + #[inline(always)] + pub fn set_validity_ins_slip(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsSlip { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsSlip { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vel_ECEF_2 +/// +/// - Extended ID: 156794658 (0x9587f22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVelEcef2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVelEcef2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9587f22)}); + + pub const INS_VEL_ECEF_Z_MIN: f32 = -838_f32; + pub const INS_VEL_ECEF_Z_MAX: f32 = 838_f32; + pub const INS_VEL_ECEF_Y_MIN: f32 = -838_f32; + pub const INS_VEL_ECEF_Y_MAX: f32 = 838_f32; + + /// Construct new RT_SB_INS_Vel_ECEF_2 from values + pub fn new(ins_vel_ecef_z: f32, ins_vel_ecef_y: f32, validity_ins_vel_ecef_z: bool, validity_ins_vel_ecef_y: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_vel_ecef_z(ins_vel_ecef_z)?; + res.set_ins_vel_ecef_y(ins_vel_ecef_y)?; + res.set_validity_ins_vel_ecef_z(validity_ins_vel_ecef_z)?; + res.set_validity_ins_vel_ecef_y(validity_ins_vel_ecef_y)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Vel_ECEF_Z + /// + /// ECEF Z velocity. The ECEF Z axis originates from the Earth centre, and the positive Z axis intersects the Earth surface at the North Pole. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_ecef_z(&self) -> f32 { + self.ins_vel_ecef_z_raw() + } + + /// Get raw value of INS_Vel_ECEF_Z + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_ecef_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_ECEF_Z + #[inline(always)] + pub fn set_ins_vel_ecef_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// INS_Vel_ECEF_Y + /// + /// ECEF Y velocity. The ECEF Y axis originates from the Earth centre, and the positive Y axis intersects the Earth surface at zero degrees latittude and 90 degrees longitude. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_ecef_y(&self) -> f32 { + self.ins_vel_ecef_y_raw() + } + + /// Get raw value of INS_Vel_ECEF_Y + /// + /// - Start bit: 8 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_ecef_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_ECEF_Y + #[inline(always)] + pub fn set_ins_vel_ecef_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_ECEF_Z + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_ecef_z(&self) -> bool { + self.validity_ins_vel_ecef_z_raw() + } + + /// Get raw value of Validity_INS_Vel_ECEF_Z + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_ecef_z_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_ECEF_Z + #[inline(always)] + pub fn set_validity_ins_vel_ecef_z(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_ECEF_Y + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_ecef_y(&self) -> bool { + self.validity_ins_vel_ecef_y_raw() + } + + /// Get raw value of Validity_INS_Vel_ECEF_Y + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_ecef_y_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_ECEF_Y + #[inline(always)] + pub fn set_validity_ins_vel_ecef_y(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVelEcef2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVelEcef2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vel_ECEF_1 +/// +/// - Extended ID: 156794402 (0x9587e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVelEcef1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVelEcef1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9587e22)}); + + pub const INS_VEL_ECEF_X_MIN: f32 = -838_f32; + pub const INS_VEL_ECEF_X_MAX: f32 = 838_f32; + pub const ACCURACY_INS_VEL_ECEF_Z_MIN: u8 = 0_u8; + pub const ACCURACY_INS_VEL_ECEF_Z_MAX: u8 = 255_u8; + pub const ACCURACY_INS_VEL_ECEF_Y_MIN: u8 = 0_u8; + pub const ACCURACY_INS_VEL_ECEF_Y_MAX: u8 = 255_u8; + pub const ACCURACY_INS_VEL_ECEF_X_MIN: u8 = 0_u8; + pub const ACCURACY_INS_VEL_ECEF_X_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Vel_ECEF_1 from values + pub fn new(ins_vel_ecef_x: f32, accuracy_ins_vel_ecef_z: u8, accuracy_ins_vel_ecef_y: u8, accuracy_ins_vel_ecef_x: u8, validity_ins_vel_ecef_x: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_vel_ecef_x(ins_vel_ecef_x)?; + res.set_accuracy_ins_vel_ecef_z(accuracy_ins_vel_ecef_z)?; + res.set_accuracy_ins_vel_ecef_y(accuracy_ins_vel_ecef_y)?; + res.set_accuracy_ins_vel_ecef_x(accuracy_ins_vel_ecef_x)?; + res.set_validity_ins_vel_ecef_x(validity_ins_vel_ecef_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Vel_ECEF_X + /// + /// ECEF X velocity. The ECEF X axis originates from the Earth centre, and the positive X axis intersects the Earth surface at zero degrees latittude and zero degrees longitude (the intersection of the equator and the prime meridian). + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_ecef_x(&self) -> f32 { + self.ins_vel_ecef_x_raw() + } + + /// Get raw value of INS_Vel_ECEF_X + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_ecef_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_ECEF_X + #[inline(always)] + pub fn set_ins_vel_ecef_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Vel_ECEF_Z + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_vel_ecef_z(&self) -> u8 { + self.accuracy_ins_vel_ecef_z_raw() + } + + /// Get raw value of Accuracy_INS_Vel_ECEF_Z + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_vel_ecef_z_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Vel_ECEF_Z + #[inline(always)] + pub fn set_accuracy_ins_vel_ecef_z(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Vel_ECEF_Y + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_vel_ecef_y(&self) -> u8 { + self.accuracy_ins_vel_ecef_y_raw() + } + + /// Get raw value of Accuracy_INS_Vel_ECEF_Y + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_vel_ecef_y_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Vel_ECEF_Y + #[inline(always)] + pub fn set_accuracy_ins_vel_ecef_y(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Vel_ECEF_X + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_vel_ecef_x(&self) -> u8 { + self.accuracy_ins_vel_ecef_x_raw() + } + + /// Get raw value of Accuracy_INS_Vel_ECEF_X + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_vel_ecef_x_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Vel_ECEF_X + #[inline(always)] + pub fn set_accuracy_ins_vel_ecef_x(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsVelEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_ECEF_X + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_ecef_x(&self) -> bool { + self.validity_ins_vel_ecef_x_raw() + } + + /// Get raw value of Validity_INS_Vel_ECEF_X + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_ecef_x_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_ECEF_X + #[inline(always)] + pub fn set_validity_ins_vel_ecef_x(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVelEcef1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVelEcef1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vel_NED_2 +/// +/// - Extended ID: 156794146 (0x9587d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVelNed2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVelNed2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9587d22)}); + + pub const INS_VEL_NED_D_MIN: f32 = -838_f32; + pub const INS_VEL_NED_D_MAX: f32 = 838_f32; + pub const ACCURACY_INS_VEL_D_MIN: u8 = 0_u8; + pub const ACCURACY_INS_VEL_D_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Vel_NED_2 from values + pub fn new(ins_vel_ned_d: f32, accuracy_ins_vel_d: u8, validity_ins_vel_ned_d: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_vel_ned_d(ins_vel_ned_d)?; + res.set_accuracy_ins_vel_d(accuracy_ins_vel_d)?; + res.set_validity_ins_vel_ned_d(validity_ins_vel_ned_d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Vel_NED_D + /// + /// VELNED D velocity. This is the velocity vector directly downwards towards the Earth centre at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_ned_d(&self) -> f32 { + self.ins_vel_ned_d_raw() + } + + /// Get raw value of INS_Vel_NED_D + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_ned_d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_NED_D + #[inline(always)] + pub fn set_ins_vel_ned_d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Vel_D + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_vel_d(&self) -> u8 { + self.accuracy_ins_vel_d_raw() + } + + /// Get raw value of Accuracy_INS_Vel_D + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_vel_d_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Vel_D + #[inline(always)] + pub fn set_accuracy_ins_vel_d(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_NED_D + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_ned_d(&self) -> bool { + self.validity_ins_vel_ned_d_raw() + } + + /// Get raw value of Validity_INS_Vel_NED_D + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_ned_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_NED_D + #[inline(always)] + pub fn set_validity_ins_vel_ned_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVelNed2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVelNed2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Vel_NED_1 +/// +/// - Extended ID: 156793890 (0x9587c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsVelNed1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsVelNed1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9587c22)}); + + pub const INS_VEL_NED_E_MIN: f32 = -838_f32; + pub const INS_VEL_NED_E_MAX: f32 = 838_f32; + pub const INS_VEL_NED_N_MIN: f32 = -838_f32; + pub const INS_VEL_NED_N_MAX: f32 = 838_f32; + pub const ACCURACY_INS_VEL_NE_MIN: u8 = 0_u8; + pub const ACCURACY_INS_VEL_NE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Vel_NED_1 from values + pub fn new(ins_vel_ned_e: f32, ins_vel_ned_n: f32, accuracy_ins_vel_ne: u8, validity_ins_vel_ned_e: bool, validity_ins_vel_ned_n: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_vel_ned_e(ins_vel_ned_e)?; + res.set_ins_vel_ned_n(ins_vel_ned_n)?; + res.set_accuracy_ins_vel_ne(accuracy_ins_vel_ne)?; + res.set_validity_ins_vel_ned_e(validity_ins_vel_ned_e)?; + res.set_validity_ins_vel_ned_n(validity_ins_vel_ned_n)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Vel_NED_E + /// + /// VELNED E velocity. This is the velocity vector directly East at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_ned_e(&self) -> f32 { + self.ins_vel_ned_e_raw() + } + + /// Get raw value of INS_Vel_NED_E + /// + /// - Start bit: 40 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_ned_e_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_NED_E + #[inline(always)] + pub fn set_ins_vel_ned_e(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) + } + + /// INS_Vel_NED_N + /// + /// VELNED N velocity. This is the velocity vector directly North at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_vel_ned_n(&self) -> f32 { + self.ins_vel_ned_n_raw() + } + + /// Get raw value of INS_Vel_NED_N + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_vel_ned_n_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Vel_NED_N + #[inline(always)] + pub fn set_ins_vel_ned_n(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Vel_NE + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_vel_ne(&self) -> u8 { + self.accuracy_ins_vel_ne_raw() + } + + /// Get raw value of Accuracy_INS_Vel_NE + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_vel_ne_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Vel_NE + #[inline(always)] + pub fn set_accuracy_ins_vel_ne(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsVelNed1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_NED_E + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_ned_e(&self) -> bool { + self.validity_ins_vel_ned_e_raw() + } + + /// Get raw value of Validity_INS_Vel_NED_E + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_ned_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_NED_E + #[inline(always)] + pub fn set_validity_ins_vel_ned_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Vel_NED_N + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_vel_ned_n(&self) -> bool { + self.validity_ins_vel_ned_n_raw() + } + + /// Get raw value of Validity_INS_Vel_NED_N + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_vel_ned_n_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Vel_NED_N + #[inline(always)] + pub fn set_validity_ins_vel_ned_n(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsVelNed1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsVelNed1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Pos_ECEF_2 +/// +/// - Extended ID: 156791074 (0x9587122) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsPosEcef2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsPosEcef2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9587122)}); + + pub const INS_POS_ECEF_Z_MIN: f32 = -10000000_f32; + pub const INS_POS_ECEF_Z_MAX: f32 = 10000000_f32; + pub const INS_POS_ECEF_Y_MIN: f32 = -10000000_f32; + pub const INS_POS_ECEF_Y_MAX: f32 = 10000000_f32; + + /// Construct new RT_SB_INS_Pos_ECEF_2 from values + pub fn new(ins_pos_ecef_z: f32, ins_pos_ecef_y: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_pos_ecef_z(ins_pos_ecef_z)?; + res.set_ins_pos_ecef_y(ins_pos_ecef_y)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Pos_ECEF_Z + /// + /// ECEF Z position. The ECEF Z axis originates from the Earth centre, and the positive Z axis intersects the Earth surface at the North Pole. + /// + /// - Min: -10000000 + /// - Max: 10000000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_pos_ecef_z(&self) -> f32 { + self.ins_pos_ecef_z_raw() + } + + /// Get raw value of INS_Pos_ECEF_Z + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_pos_ecef_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Pos_ECEF_Z + #[inline(always)] + pub fn set_ins_pos_ecef_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -10000000_f32 || 10000000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// INS_Pos_ECEF_Y + /// + /// ECEF Y position. The ECEF Y axis originates from the Earth centre, and the positive Y axis intersects the Earth surface at zero degrees latittude and 90 degrees longitude. + /// + /// - Min: -10000000 + /// - Max: 10000000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_pos_ecef_y(&self) -> f32 { + self.ins_pos_ecef_y_raw() + } + + /// Get raw value of INS_Pos_ECEF_Y + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_pos_ecef_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Pos_ECEF_Y + #[inline(always)] + pub fn set_ins_pos_ecef_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -10000000_f32 || 10000000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsPosEcef2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsPosEcef2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Pos_ECEF_1 +/// +/// - Extended ID: 156790818 (0x9587022) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsPosEcef1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsPosEcef1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9587022)}); + + pub const INS_POS_ECEF_X_MIN: f32 = -10000000_f32; + pub const INS_POS_ECEF_X_MAX: f32 = 10000000_f32; + pub const ACCURACY_INS_POS_ECEF_Z_MIN: u8 = 0_u8; + pub const ACCURACY_INS_POS_ECEF_Z_MAX: u8 = 255_u8; + pub const ACCURACY_INS_POS_ECEF_Y_MIN: u8 = 0_u8; + pub const ACCURACY_INS_POS_ECEF_Y_MAX: u8 = 255_u8; + pub const ACCURACY_INS_POS_ECEF_X_MIN: u8 = 0_u8; + pub const ACCURACY_INS_POS_ECEF_X_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Pos_ECEF_1 from values + pub fn new(ins_pos_ecef_x: f32, accuracy_ins_pos_ecef_z: u8, accuracy_ins_pos_ecef_y: u8, accuracy_ins_pos_ecef_x: u8, validity_ins_pos_ecef_z: bool, validity_ins_pos_ecef_y: bool, validity_ins_pos_ecef_x: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_pos_ecef_x(ins_pos_ecef_x)?; + res.set_accuracy_ins_pos_ecef_z(accuracy_ins_pos_ecef_z)?; + res.set_accuracy_ins_pos_ecef_y(accuracy_ins_pos_ecef_y)?; + res.set_accuracy_ins_pos_ecef_x(accuracy_ins_pos_ecef_x)?; + res.set_validity_ins_pos_ecef_z(validity_ins_pos_ecef_z)?; + res.set_validity_ins_pos_ecef_y(validity_ins_pos_ecef_y)?; + res.set_validity_ins_pos_ecef_x(validity_ins_pos_ecef_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Pos_ECEF_X + /// + /// ECEF X position. The ECEF X axis originates from the Earth centre, and the positive X axis intersects the Earth surface at zero degrees latittude and zero degrees longitude (the intersection of the equator and the prime meridian). + /// + /// - Min: -10000000 + /// - Max: 10000000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_pos_ecef_x(&self) -> f32 { + self.ins_pos_ecef_x_raw() + } + + /// Get raw value of INS_Pos_ECEF_X + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_pos_ecef_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Pos_ECEF_X + #[inline(always)] + pub fn set_ins_pos_ecef_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -10000000_f32 || 10000000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Pos_ECEF_Z + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_pos_ecef_z(&self) -> u8 { + self.accuracy_ins_pos_ecef_z_raw() + } + + /// Get raw value of Accuracy_INS_Pos_ECEF_Z + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_pos_ecef_z_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Pos_ECEF_Z + #[inline(always)] + pub fn set_accuracy_ins_pos_ecef_z(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Pos_ECEF_Y + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_pos_ecef_y(&self) -> u8 { + self.accuracy_ins_pos_ecef_y_raw() + } + + /// Get raw value of Accuracy_INS_Pos_ECEF_Y + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_pos_ecef_y_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Pos_ECEF_Y + #[inline(always)] + pub fn set_accuracy_ins_pos_ecef_y(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Pos_ECEF_X + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_pos_ecef_x(&self) -> u8 { + self.accuracy_ins_pos_ecef_x_raw() + } + + /// Get raw value of Accuracy_INS_Pos_ECEF_X + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_pos_ecef_x_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Pos_ECEF_X + #[inline(always)] + pub fn set_accuracy_ins_pos_ecef_x(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsPosEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Pos_ECEF_Z + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_pos_ecef_z(&self) -> bool { + self.validity_ins_pos_ecef_z_raw() + } + + /// Get raw value of Validity_INS_Pos_ECEF_Z + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_pos_ecef_z_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Pos_ECEF_Z + #[inline(always)] + pub fn set_validity_ins_pos_ecef_z(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_INS_Pos_ECEF_Y + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_pos_ecef_y(&self) -> bool { + self.validity_ins_pos_ecef_y_raw() + } + + /// Get raw value of Validity_INS_Pos_ECEF_Y + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_pos_ecef_y_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Pos_ECEF_Y + #[inline(always)] + pub fn set_validity_ins_pos_ecef_y(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Pos_ECEF_X + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_pos_ecef_x(&self) -> bool { + self.validity_ins_pos_ecef_x_raw() + } + + /// Get raw value of Validity_INS_Pos_ECEF_X + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_pos_ecef_x_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Pos_ECEF_X + #[inline(always)] + pub fn set_validity_ins_pos_ecef_x(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsPosEcef1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsPosEcef1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Pos_LLH_2 +/// +/// - Extended ID: 156790562 (0x9586f22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsPosLlh2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsPosLlh2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9586f22)}); + + pub const INS_POS_LLH_ALTITUDE_MIN: f32 = -1000_f32; + pub const INS_POS_LLH_ALTITUDE_MAX: f32 = 100000_f32; + pub const INS_POS_LLH_LONGITUDE_MIN: f32 = -180_f32; + pub const INS_POS_LLH_LONGITUDE_MAX: f32 = 180_f32; + + /// Construct new RT_SB_INS_Pos_LLH_2 from values + pub fn new(ins_pos_llh_altitude: f32, ins_pos_llh_longitude: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_pos_llh_altitude(ins_pos_llh_altitude)?; + res.set_ins_pos_llh_longitude(ins_pos_llh_longitude)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Pos_LLH_Altitude + /// + /// - Min: -1000 + /// - Max: 100000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_pos_llh_altitude(&self) -> f32 { + self.ins_pos_llh_altitude_raw() + } + + /// Get raw value of INS_Pos_LLH_Altitude + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_pos_llh_altitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_ins_pos_llh_altitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -1000_f32 || 100000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh2::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// INS_Pos_LLH_Longitude + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_pos_llh_longitude(&self) -> f32 { + self.ins_pos_llh_longitude_raw() + } + + /// Get raw value of INS_Pos_LLH_Longitude + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.0000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_pos_llh_longitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.0000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_ins_pos_llh_longitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh2::MESSAGE_ID }); + } + let factor = 0.0000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsPosLlh2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsPosLlh2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Pos_LLH_1 +/// +/// - Extended ID: 156790306 (0x9586e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsPosLlh1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsPosLlh1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9586e22)}); + + pub const INS_POS_LLH_LATITUDE_MIN: f32 = -90_f32; + pub const INS_POS_LLH_LATITUDE_MAX: f32 = 90_f32; + pub const ACCURACY_INS_POS_LLH_ALTITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_INS_POS_LLH_ALTITUDE_MAX: u8 = 255_u8; + pub const ACCURACY_INS_POS_LLH_LONGITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_INS_POS_LLH_LONGITUDE_MAX: u8 = 255_u8; + pub const ACCURACY_INS_POS_LLH_LATITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_INS_POS_LLH_LATITUDE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Pos_LLH_1 from values + pub fn new(ins_pos_llh_latitude: f32, accuracy_ins_pos_llh_altitude: u8, accuracy_ins_pos_llh_longitude: u8, accuracy_ins_pos_llh_latitude: u8, validity_ins_pos_llh_altitude: bool, validity_ins_pos_llh_longitude: bool, validity_ins_pos_llh_latitude: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_pos_llh_latitude(ins_pos_llh_latitude)?; + res.set_accuracy_ins_pos_llh_altitude(accuracy_ins_pos_llh_altitude)?; + res.set_accuracy_ins_pos_llh_longitude(accuracy_ins_pos_llh_longitude)?; + res.set_accuracy_ins_pos_llh_latitude(accuracy_ins_pos_llh_latitude)?; + res.set_validity_ins_pos_llh_altitude(validity_ins_pos_llh_altitude)?; + res.set_validity_ins_pos_llh_longitude(validity_ins_pos_llh_longitude)?; + res.set_validity_ins_pos_llh_latitude(validity_ins_pos_llh_latitude)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Pos_LLH_Latitude + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_pos_llh_latitude(&self) -> f32 { + self.ins_pos_llh_latitude_raw() + } + + /// Get raw value of INS_Pos_LLH_Latitude + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.0000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_pos_llh_latitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.0000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_ins_pos_llh_latitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID }); + } + let factor = 0.0000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Pos_LLH_Altitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_pos_llh_altitude(&self) -> u8 { + self.accuracy_ins_pos_llh_altitude_raw() + } + + /// Get raw value of Accuracy_INS_Pos_LLH_Altitude + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_pos_llh_altitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_accuracy_ins_pos_llh_altitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Pos_LLH_Longitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_pos_llh_longitude(&self) -> u8 { + self.accuracy_ins_pos_llh_longitude_raw() + } + + /// Get raw value of Accuracy_INS_Pos_LLH_Longitude + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_pos_llh_longitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_accuracy_ins_pos_llh_longitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Pos_LLH_Latitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_pos_llh_latitude(&self) -> u8 { + self.accuracy_ins_pos_llh_latitude_raw() + } + + /// Get raw value of Accuracy_INS_Pos_LLH_Latitude + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_pos_llh_latitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_accuracy_ins_pos_llh_latitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Pos_LLH_Altitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_pos_llh_altitude(&self) -> bool { + self.validity_ins_pos_llh_altitude_raw() + } + + /// Get raw value of Validity_INS_Pos_LLH_Altitude + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_pos_llh_altitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_validity_ins_pos_llh_altitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_INS_Pos_LLH_Longitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_pos_llh_longitude(&self) -> bool { + self.validity_ins_pos_llh_longitude_raw() + } + + /// Get raw value of Validity_INS_Pos_LLH_Longitude + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_pos_llh_longitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_validity_ins_pos_llh_longitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Pos_LLH_Latitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_pos_llh_latitude(&self) -> bool { + self.validity_ins_pos_llh_latitude_raw() + } + + /// Get raw value of Validity_INS_Pos_LLH_Latitude + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_pos_llh_latitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_validity_ins_pos_llh_latitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsPosLlh1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsPosLlh1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Heading_Gradient_2 +/// +/// - Extended ID: 156795170 (0x9588122) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsHeadingGradient2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsHeadingGradient2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9588122)}); + + pub const INS_GRADIENT_MIN: f32 = -90_f32; + pub const INS_GRADIENT_MAX: f32 = 90_f32; + pub const ACCURACY_INS_GRADIENT_MIN: u8 = 0_u8; + pub const ACCURACY_INS_GRADIENT_MAX: u8 = 255_u8; + pub const INS_HEADING_2_MIN: f32 = 0_f32; + pub const INS_HEADING_2_MAX: f32 = 360_f32; + pub const ACCURACY_INS_HEADING_MIN: u8 = 0_u8; + pub const ACCURACY_INS_HEADING_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Heading_Gradient_2 from values + pub fn new(ins_gradient: f32, accuracy_ins_gradient: u8, ins_heading_2: f32, accuracy_ins_heading: u8, validity_ins_gradient: bool, validity_ins_heading: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_gradient(ins_gradient)?; + res.set_accuracy_ins_gradient(accuracy_ins_gradient)?; + res.set_ins_heading_2(ins_heading_2)?; + res.set_accuracy_ins_heading(accuracy_ins_heading)?; + res.set_validity_ins_gradient(validity_ins_gradient)?; + res.set_validity_ins_heading(validity_ins_heading)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Gradient + /// + /// This is GPS gradient, i.e. the vertical direction that the vehicle is travelling, NOT pointing (pitch). + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_gradient(&self) -> f32 { + self.ins_gradient_raw() + } + + /// Get raw value of INS_Gradient + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_gradient_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Gradient + #[inline(always)] + pub fn set_ins_gradient(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Gradient + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_gradient(&self) -> u8 { + self.accuracy_ins_gradient_raw() + } + + /// Get raw value of Accuracy_INS_Gradient + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_gradient_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Gradient + #[inline(always)] + pub fn set_accuracy_ins_gradient(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// INS_Heading_2 + /// + /// This is GPS heading in the range 0 - 360°, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: 0 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_heading_2(&self) -> f32 { + self.ins_heading_2_raw() + } + + /// Get raw value of INS_Heading_2 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ins_heading_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Heading_2 + #[inline(always)] + pub fn set_ins_heading_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Heading + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_heading(&self) -> u8 { + self.accuracy_ins_heading_raw() + } + + /// Get raw value of Accuracy_INS_Heading + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_heading_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Heading + #[inline(always)] + pub fn set_accuracy_ins_heading(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Gradient + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_gradient(&self) -> bool { + self.validity_ins_gradient_raw() + } + + /// Get raw value of Validity_INS_Gradient + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_gradient_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Gradient + #[inline(always)] + pub fn set_validity_ins_gradient(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Heading + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_heading(&self) -> bool { + self.validity_ins_heading_raw() + } + + /// Get raw value of Validity_INS_Heading + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_heading_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Heading + #[inline(always)] + pub fn set_validity_ins_heading(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsHeadingGradient2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsHeadingGradient2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Heading_Gradient +/// +/// - Extended ID: 156794914 (0x9588022) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsHeadingGradient { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsHeadingGradient { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9588022)}); + + pub const INS_GRADIENT_MIN: f32 = -90_f32; + pub const INS_GRADIENT_MAX: f32 = 90_f32; + pub const ACCURACY_INS_GRADIENT_MIN: u8 = 0_u8; + pub const ACCURACY_INS_GRADIENT_MAX: u8 = 255_u8; + pub const INS_HEADING_MIN: f32 = -180_f32; + pub const INS_HEADING_MAX: f32 = 180_f32; + pub const ACCURACY_INS_HEADING_MIN: u8 = 0_u8; + pub const ACCURACY_INS_HEADING_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Heading_Gradient from values + pub fn new(ins_gradient: f32, accuracy_ins_gradient: u8, ins_heading: f32, accuracy_ins_heading: u8, validity_ins_gradient: bool, validity_ins_heading: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_gradient(ins_gradient)?; + res.set_accuracy_ins_gradient(accuracy_ins_gradient)?; + res.set_ins_heading(ins_heading)?; + res.set_accuracy_ins_heading(accuracy_ins_heading)?; + res.set_validity_ins_gradient(validity_ins_gradient)?; + res.set_validity_ins_heading(validity_ins_heading)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Gradient + /// + /// This is GPS gradient, i.e. the vertical direction that the vehicle is travelling, NOT pointing (pitch). + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_gradient(&self) -> f32 { + self.ins_gradient_raw() + } + + /// Get raw value of INS_Gradient + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_gradient_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Gradient + #[inline(always)] + pub fn set_ins_gradient(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Gradient + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_gradient(&self) -> u8 { + self.accuracy_ins_gradient_raw() + } + + /// Get raw value of Accuracy_INS_Gradient + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_gradient_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Gradient + #[inline(always)] + pub fn set_accuracy_ins_gradient(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// INS_Heading + /// + /// This is GPS heading, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_heading(&self) -> f32 { + self.ins_heading_raw() + } + + /// Get raw value of INS_Heading + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn ins_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of INS_Heading + #[inline(always)] + pub fn set_ins_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_INS_Heading + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_ins_heading(&self) -> u8 { + self.accuracy_ins_heading_raw() + } + + /// Get raw value of Accuracy_INS_Heading + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_ins_heading_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_INS_Heading + #[inline(always)] + pub fn set_accuracy_ins_heading(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsHeadingGradient::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_INS_Gradient + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_gradient(&self) -> bool { + self.validity_ins_gradient_raw() + } + + /// Get raw value of Validity_INS_Gradient + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_gradient_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Gradient + #[inline(always)] + pub fn set_validity_ins_gradient(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_INS_Heading + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_ins_heading(&self) -> bool { + self.validity_ins_heading_raw() + } + + /// Get raw value of Validity_INS_Heading + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_ins_heading_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_INS_Heading + #[inline(always)] + pub fn set_validity_ins_heading(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsHeadingGradient { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsHeadingGradient { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_INS_Status +/// +/// - Extended ID: 156789794 (0x9586c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsStatus { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9586c22)}); + + pub const INS_STATUS_MIN: u8 = 0_u8; + pub const INS_STATUS_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Status from values + pub fn new(ins_status: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_ins_status(ins_status)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// INS_Status + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn ins_status(&self) -> RtSbInsStatusInsStatus { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 2 => RtSbInsStatusInsStatus::Converged, + 1 => RtSbInsStatusInsStatus::Initialised, + 0 => RtSbInsStatusInsStatus::Uninitialised, + _ => RtSbInsStatusInsStatus::_Other(self.ins_status_raw()), + } + } + + /// Get raw value of INS_Status + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn ins_status_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of INS_Status + #[inline(always)] + pub fn set_ins_status(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for INS_Status +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbInsStatusInsStatus { + Converged, + Initialised, + Uninitialised, + _Other(u8), +} + +impl From for u8 { + fn from(val: RtSbInsStatusInsStatus) -> u8 { + match val { + RtSbInsStatusInsStatus::Converged => 2, + RtSbInsStatusInsStatus::Initialised => 1, + RtSbInsStatusInsStatus::Uninitialised => 0, + RtSbInsStatusInsStatus::_Other(x) => x, + } + } +} + + +/// RT_SB_INS_Attitude +/// +/// - Extended ID: 156790050 (0x9586d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbInsAttitude { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbInsAttitude { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9586d22)}); + + pub const ATTITUDE_ROLL_MIN: f32 = -360_f32; + pub const ATTITUDE_ROLL_MAX: f32 = 360_f32; + pub const ATTITUDE_PITCH_MIN: f32 = -360_f32; + pub const ATTITUDE_PITCH_MAX: f32 = 360_f32; + pub const ATTITUDE_YAW_MIN: f32 = -360_f32; + pub const ATTITUDE_YAW_MAX: f32 = 360_f32; + pub const ACCURACY_ATTITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_ATTITUDE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_INS_Attitude from values + pub fn new(attitude_roll: f32, attitude_pitch: f32, attitude_yaw: f32, accuracy_attitude: u8, validity_roll: bool, validity_pitch: bool, validity_yaw: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_attitude_roll(attitude_roll)?; + res.set_attitude_pitch(attitude_pitch)?; + res.set_attitude_yaw(attitude_yaw)?; + res.set_accuracy_attitude(accuracy_attitude)?; + res.set_validity_roll(validity_roll)?; + res.set_validity_pitch(validity_pitch)?; + res.set_validity_yaw(validity_yaw)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Attitude_Roll + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn attitude_roll(&self) -> f32 { + self.attitude_roll_raw() + } + + /// Get raw value of Attitude_Roll + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn attitude_roll_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Attitude_Roll + #[inline(always)] + pub fn set_attitude_roll(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsAttitude::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Attitude_Pitch + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn attitude_pitch(&self) -> f32 { + self.attitude_pitch_raw() + } + + /// Get raw value of Attitude_Pitch + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn attitude_pitch_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Attitude_Pitch + #[inline(always)] + pub fn set_attitude_pitch(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsAttitude::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Attitude_Yaw + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn attitude_yaw(&self) -> f32 { + self.attitude_yaw_raw() + } + + /// Get raw value of Attitude_Yaw + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn attitude_yaw_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Attitude_Yaw + #[inline(always)] + pub fn set_attitude_yaw(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsAttitude::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_Attitude + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_attitude(&self) -> u8 { + self.accuracy_attitude_raw() + } + + /// Get raw value of Accuracy_Attitude + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_attitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Attitude + #[inline(always)] + pub fn set_accuracy_attitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbInsAttitude::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbInsAttitude::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Roll + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_roll(&self) -> RtSbInsAttitudeValidityRoll { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + match signal { + 1 => RtSbInsAttitudeValidityRoll::Valid, + 0 => RtSbInsAttitudeValidityRoll::Invalid, + _ => RtSbInsAttitudeValidityRoll::_Other(self.validity_roll_raw()), + } + } + + /// Get raw value of Validity_Roll + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_roll_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Roll + #[inline(always)] + pub fn set_validity_roll(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Pitch + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_pitch(&self) -> RtSbInsAttitudeValidityPitch { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + match signal { + 1 => RtSbInsAttitudeValidityPitch::Valid, + 0 => RtSbInsAttitudeValidityPitch::Invalid, + _ => RtSbInsAttitudeValidityPitch::_Other(self.validity_pitch_raw()), + } + } + + /// Get raw value of Validity_Pitch + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_pitch_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Pitch + #[inline(always)] + pub fn set_validity_pitch(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Yaw + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_yaw(&self) -> RtSbInsAttitudeValidityYaw { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + match signal { + 1 => RtSbInsAttitudeValidityYaw::Valid, + 0 => RtSbInsAttitudeValidityYaw::Invalid, + _ => RtSbInsAttitudeValidityYaw::_Other(self.validity_yaw_raw()), + } + } + + /// Get raw value of Validity_Yaw + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_yaw_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Yaw + #[inline(always)] + pub fn set_validity_yaw(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbInsAttitude { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbInsAttitude { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Validity_Roll +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbInsAttitudeValidityRoll { + Valid, + Invalid, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbInsAttitudeValidityRoll) -> bool { + match val { + RtSbInsAttitudeValidityRoll::Valid => true, + RtSbInsAttitudeValidityRoll::Invalid => false, + RtSbInsAttitudeValidityRoll::_Other(x) => x, + } + } +} + +/// Defined values for Validity_Pitch +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbInsAttitudeValidityPitch { + Valid, + Invalid, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbInsAttitudeValidityPitch) -> bool { + match val { + RtSbInsAttitudeValidityPitch::Valid => true, + RtSbInsAttitudeValidityPitch::Invalid => false, + RtSbInsAttitudeValidityPitch::_Other(x) => x, + } + } +} + +/// Defined values for Validity_Yaw +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbInsAttitudeValidityYaw { + Valid, + Invalid, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbInsAttitudeValidityYaw) -> bool { + match val { + RtSbInsAttitudeValidityYaw::Valid => true, + RtSbInsAttitudeValidityYaw::Invalid => false, + RtSbInsAttitudeValidityYaw::_Other(x) => x, + } + } +} + + +/// RT_SB_Output_Status +/// +/// - Extended ID: 156724514 (0x9576d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbOutputStatus { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbOutputStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9576d22)}); + + pub const GPS_TIME_MIN: f32 = 0_f32; + pub const GPS_TIME_MAX: f32 = 604800_f32; + + /// Construct new RT_SB_Output_Status from values + pub fn new(gps_time: f32, status_trigger: bool, status_serial_output_2: bool, status_serial_output_1: bool, status_pulse_output: bool, status_analogue_4: bool, status_analogue_3: bool, status_analogue_2: bool, status_analogue_1: bool, validity_status_timestamp: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_time(gps_time)?; + res.set_status_trigger(status_trigger)?; + res.set_status_serial_output_2(status_serial_output_2)?; + res.set_status_serial_output_1(status_serial_output_1)?; + res.set_status_pulse_output(status_pulse_output)?; + res.set_status_analogue_4(status_analogue_4)?; + res.set_status_analogue_3(status_analogue_3)?; + res.set_status_analogue_2(status_analogue_2)?; + res.set_status_analogue_1(status_analogue_1)?; + res.set_validity_status_timestamp(validity_status_timestamp)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Time + /// + /// GPS time is the time in seconds since midnight GMT on Saturday night. + /// + /// - Min: 0 + /// - Max: 604800 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_time(&self) -> f32 { + self.gps_time_raw() + } + + /// Get raw value of GPS_Time + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Time + #[inline(always)] + pub fn set_gps_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 604800_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbOutputStatus::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Status_Trigger + /// + /// Status of the trigger input + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_trigger(&self) -> RtSbOutputStatusStatusTrigger { + let signal = self.raw.view_bits::()[15..16].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusTrigger::Active, + 0 => RtSbOutputStatusStatusTrigger::Inactive, + _ => RtSbOutputStatusStatusTrigger::_Other(self.status_trigger_raw()), + } + } + + /// Get raw value of Status_Trigger + /// + /// - Start bit: 15 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_trigger_raw(&self) -> bool { + let signal = self.raw.view_bits::()[15..16].load_le::(); + + signal == 1 + } + + /// Set value of Status_Trigger + #[inline(always)] + pub fn set_status_trigger(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[15..16].store_le(value); + Ok(()) + } + + /// Status_Serial_Output_2 + /// + /// Status output of serial port 1 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_serial_output_2(&self) -> RtSbOutputStatusStatusSerialOutput2 { + let signal = self.raw.view_bits::()[14..15].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusSerialOutput2::Active, + 0 => RtSbOutputStatusStatusSerialOutput2::Inactive, + _ => RtSbOutputStatusStatusSerialOutput2::_Other(self.status_serial_output_2_raw()), + } + } + + /// Get raw value of Status_Serial_Output_2 + /// + /// - Start bit: 14 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_serial_output_2_raw(&self) -> bool { + let signal = self.raw.view_bits::()[14..15].load_le::(); + + signal == 1 + } + + /// Set value of Status_Serial_Output_2 + #[inline(always)] + pub fn set_status_serial_output_2(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[14..15].store_le(value); + Ok(()) + } + + /// Status_Serial_Output_1 + /// + /// Status output of serial port 1 + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_serial_output_1(&self) -> RtSbOutputStatusStatusSerialOutput1 { + let signal = self.raw.view_bits::()[13..14].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusSerialOutput1::Active, + 0 => RtSbOutputStatusStatusSerialOutput1::Inactive, + _ => RtSbOutputStatusStatusSerialOutput1::_Other(self.status_serial_output_1_raw()), + } + } + + /// Get raw value of Status_Serial_Output_1 + /// + /// - Start bit: 13 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_serial_output_1_raw(&self) -> bool { + let signal = self.raw.view_bits::()[13..14].load_le::(); + + signal == 1 + } + + /// Set value of Status_Serial_Output_1 + #[inline(always)] + pub fn set_status_serial_output_1(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[13..14].store_le(value); + Ok(()) + } + + /// Status_Pulse_Output + /// + /// Pulse output activity status + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_pulse_output(&self) -> RtSbOutputStatusStatusPulseOutput { + let signal = self.raw.view_bits::()[12..13].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusPulseOutput::Active, + 0 => RtSbOutputStatusStatusPulseOutput::Inactive, + _ => RtSbOutputStatusStatusPulseOutput::_Other(self.status_pulse_output_raw()), + } + } + + /// Get raw value of Status_Pulse_Output + /// + /// - Start bit: 12 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_pulse_output_raw(&self) -> bool { + let signal = self.raw.view_bits::()[12..13].load_le::(); + + signal == 1 + } + + /// Set value of Status_Pulse_Output + #[inline(always)] + pub fn set_status_pulse_output(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[12..13].store_le(value); + Ok(()) + } + + /// Status_Analogue_4 + /// + /// Analogue output status for channel 4. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_analogue_4(&self) -> RtSbOutputStatusStatusAnalogue4 { + let signal = self.raw.view_bits::()[11..12].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusAnalogue4::Active, + 0 => RtSbOutputStatusStatusAnalogue4::Inactive, + _ => RtSbOutputStatusStatusAnalogue4::_Other(self.status_analogue_4_raw()), + } + } + + /// Get raw value of Status_Analogue_4 + /// + /// - Start bit: 11 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_analogue_4_raw(&self) -> bool { + let signal = self.raw.view_bits::()[11..12].load_le::(); + + signal == 1 + } + + /// Set value of Status_Analogue_4 + #[inline(always)] + pub fn set_status_analogue_4(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[11..12].store_le(value); + Ok(()) + } + + /// Status_Analogue_3 + /// + /// Analogue output status for channel 3. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_analogue_3(&self) -> RtSbOutputStatusStatusAnalogue3 { + let signal = self.raw.view_bits::()[10..11].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusAnalogue3::Active, + 0 => RtSbOutputStatusStatusAnalogue3::Inactive, + _ => RtSbOutputStatusStatusAnalogue3::_Other(self.status_analogue_3_raw()), + } + } + + /// Get raw value of Status_Analogue_3 + /// + /// - Start bit: 10 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_analogue_3_raw(&self) -> bool { + let signal = self.raw.view_bits::()[10..11].load_le::(); + + signal == 1 + } + + /// Set value of Status_Analogue_3 + #[inline(always)] + pub fn set_status_analogue_3(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[10..11].store_le(value); + Ok(()) + } + + /// Status_Analogue_2 + /// + /// Analogue output status for channel 1. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_analogue_2(&self) -> RtSbOutputStatusStatusAnalogue2 { + let signal = self.raw.view_bits::()[9..10].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusAnalogue2::Active, + 0 => RtSbOutputStatusStatusAnalogue2::Inactive, + _ => RtSbOutputStatusStatusAnalogue2::_Other(self.status_analogue_2_raw()), + } + } + + /// Get raw value of Status_Analogue_2 + /// + /// - Start bit: 9 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_analogue_2_raw(&self) -> bool { + let signal = self.raw.view_bits::()[9..10].load_le::(); + + signal == 1 + } + + /// Set value of Status_Analogue_2 + #[inline(always)] + pub fn set_status_analogue_2(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[9..10].store_le(value); + Ok(()) + } + + /// Status_Analogue_1 + /// + /// Analogue output status for channel 1. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn status_analogue_1(&self) -> RtSbOutputStatusStatusAnalogue1 { + let signal = self.raw.view_bits::()[8..9].load_le::(); + + match signal { + 1 => RtSbOutputStatusStatusAnalogue1::Active, + 0 => RtSbOutputStatusStatusAnalogue1::Inactive, + _ => RtSbOutputStatusStatusAnalogue1::_Other(self.status_analogue_1_raw()), + } + } + + /// Get raw value of Status_Analogue_1 + /// + /// - Start bit: 8 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn status_analogue_1_raw(&self) -> bool { + let signal = self.raw.view_bits::()[8..9].load_le::(); + + signal == 1 + } + + /// Set value of Status_Analogue_1 + #[inline(always)] + pub fn set_status_analogue_1(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[8..9].store_le(value); + Ok(()) + } + + /// Validity_Status_Timestamp + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_status_timestamp(&self) -> bool { + self.validity_status_timestamp_raw() + } + + /// Get raw value of Validity_Status_Timestamp + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_status_timestamp_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Status_Timestamp + #[inline(always)] + pub fn set_validity_status_timestamp(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbOutputStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbOutputStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Status_Trigger +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusTrigger { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusTrigger) -> bool { + match val { + RtSbOutputStatusStatusTrigger::Active => true, + RtSbOutputStatusStatusTrigger::Inactive => false, + RtSbOutputStatusStatusTrigger::_Other(x) => x, + } + } +} + +/// Defined values for Status_Serial_Output_2 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusSerialOutput2 { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusSerialOutput2) -> bool { + match val { + RtSbOutputStatusStatusSerialOutput2::Active => true, + RtSbOutputStatusStatusSerialOutput2::Inactive => false, + RtSbOutputStatusStatusSerialOutput2::_Other(x) => x, + } + } +} + +/// Defined values for Status_Serial_Output_1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusSerialOutput1 { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusSerialOutput1) -> bool { + match val { + RtSbOutputStatusStatusSerialOutput1::Active => true, + RtSbOutputStatusStatusSerialOutput1::Inactive => false, + RtSbOutputStatusStatusSerialOutput1::_Other(x) => x, + } + } +} + +/// Defined values for Status_Pulse_Output +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusPulseOutput { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusPulseOutput) -> bool { + match val { + RtSbOutputStatusStatusPulseOutput::Active => true, + RtSbOutputStatusStatusPulseOutput::Inactive => false, + RtSbOutputStatusStatusPulseOutput::_Other(x) => x, + } + } +} + +/// Defined values for Status_Analogue_4 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusAnalogue4 { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusAnalogue4) -> bool { + match val { + RtSbOutputStatusStatusAnalogue4::Active => true, + RtSbOutputStatusStatusAnalogue4::Inactive => false, + RtSbOutputStatusStatusAnalogue4::_Other(x) => x, + } + } +} + +/// Defined values for Status_Analogue_3 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusAnalogue3 { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusAnalogue3) -> bool { + match val { + RtSbOutputStatusStatusAnalogue3::Active => true, + RtSbOutputStatusStatusAnalogue3::Inactive => false, + RtSbOutputStatusStatusAnalogue3::_Other(x) => x, + } + } +} + +/// Defined values for Status_Analogue_2 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusAnalogue2 { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusAnalogue2) -> bool { + match val { + RtSbOutputStatusStatusAnalogue2::Active => true, + RtSbOutputStatusStatusAnalogue2::Inactive => false, + RtSbOutputStatusStatusAnalogue2::_Other(x) => x, + } + } +} + +/// Defined values for Status_Analogue_1 +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbOutputStatusStatusAnalogue1 { + Active, + Inactive, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbOutputStatusStatusAnalogue1) -> bool { + match val { + RtSbOutputStatusStatusAnalogue1::Active => true, + RtSbOutputStatusStatusAnalogue1::Inactive => false, + RtSbOutputStatusStatusAnalogue1::_Other(x) => x, + } + } +} + + +/// RT_SB_GPS_Heading_Gradient_2 +/// +/// - Extended ID: 156664354 (0x9568222) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsHeadingGradient2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsHeadingGradient2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9568222)}); + + pub const GPS_GRADIENT_MIN: f32 = -90_f32; + pub const GPS_GRADIENT_MAX: f32 = 90_f32; + pub const ACCURACY_GPS_GRADIENT_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_GRADIENT_MAX: u8 = 255_u8; + pub const GPS_HEADING_2_MIN: f32 = 0_f32; + pub const GPS_HEADING_2_MAX: f32 = 360_f32; + pub const ACCURACY_GPS_HEADING_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_HEADING_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Heading_Gradient_2 from values + pub fn new(gps_gradient: f32, accuracy_gps_gradient: u8, gps_heading_2: f32, accuracy_gps_heading: u8, validity_gps_gradient: bool, validity_gps_heading: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_gradient(gps_gradient)?; + res.set_accuracy_gps_gradient(accuracy_gps_gradient)?; + res.set_gps_heading_2(gps_heading_2)?; + res.set_accuracy_gps_heading(accuracy_gps_heading)?; + res.set_validity_gps_gradient(validity_gps_gradient)?; + res.set_validity_gps_heading(validity_gps_heading)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Gradient + /// + /// This is GPS gradient, i.e. the vertical direction that the vehicle is travelling, NOT pointing (pitch). + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_gradient(&self) -> f32 { + self.gps_gradient_raw() + } + + /// Get raw value of GPS_Gradient + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_gradient_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Gradient + #[inline(always)] + pub fn set_gps_gradient(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Gradient + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_gradient(&self) -> u8 { + self.accuracy_gps_gradient_raw() + } + + /// Get raw value of Accuracy_GPS_Gradient + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_gradient_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Gradient + #[inline(always)] + pub fn set_accuracy_gps_gradient(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// GPS_Heading_2 + /// + /// This is GPS heading in the range 0 - 360°, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: 0 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_heading_2(&self) -> f32 { + self.gps_heading_2_raw() + } + + /// Get raw value of GPS_Heading_2 + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_heading_2_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Heading_2 + #[inline(always)] + pub fn set_gps_heading_2(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u16; + + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Heading + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_heading(&self) -> u8 { + self.accuracy_gps_heading_raw() + } + + /// Get raw value of Accuracy_GPS_Heading + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_heading_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Heading + #[inline(always)] + pub fn set_accuracy_gps_heading(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Gradient + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_gradient(&self) -> bool { + self.validity_gps_gradient_raw() + } + + /// Get raw value of Validity_GPS_Gradient + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_gradient_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Gradient + #[inline(always)] + pub fn set_validity_gps_gradient(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Heading + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_heading(&self) -> bool { + self.validity_gps_heading_raw() + } + + /// Get raw value of Validity_GPS_Heading + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_heading_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Heading + #[inline(always)] + pub fn set_validity_gps_heading(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsHeadingGradient2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsHeadingGradient2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Cumulative_Distance_2 +/// +/// - Extended ID: 155880738 (0x94a8d22) +/// - Size: 8 bytes +/// +/// This cumulative distance calculation is updated when the trigger is active. +#[derive(Clone, Copy)] +pub struct RtSbCumulativeDistance2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbCumulativeDistance2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a8d22)}); + + pub const CUMULATIVE_DISTANCE_MIN: f32 = 0_f32; + pub const CUMULATIVE_DISTANCE_MAX: f32 = 4294967_f32; + pub const CUMULATIVE_TIME_MIN: f32 = 0_f32; + pub const CUMULATIVE_TIME_MAX: f32 = 167772_f32; + + /// Construct new RT_SB_Cumulative_Distance_2 from values + pub fn new(cumulative_distance: f32, cumulative_time: f32, validity_cumulative_distance: bool, validity_cumulative_time: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_cumulative_distance(cumulative_distance)?; + res.set_cumulative_time(cumulative_time)?; + res.set_validity_cumulative_distance(validity_cumulative_distance)?; + res.set_validity_cumulative_time(validity_cumulative_time)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Cumulative_Distance + /// + /// - Min: 0 + /// - Max: 4294967 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn cumulative_distance(&self) -> f32 { + self.cumulative_distance_raw() + } + + /// Get raw value of Cumulative_Distance + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cumulative_distance_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Cumulative_Distance + #[inline(always)] + pub fn set_cumulative_distance(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 4294967_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbCumulativeDistance2::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Cumulative_Time + /// + /// - Min: 0 + /// - Max: 167772 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn cumulative_time(&self) -> f32 { + self.cumulative_time_raw() + } + + /// Get raw value of Cumulative_Time + /// + /// - Start bit: 8 + /// - Signal size: 24 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cumulative_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Cumulative_Time + #[inline(always)] + pub fn set_cumulative_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 167772_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbCumulativeDistance2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) + } + + /// Validity_Cumulative_Distance + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_cumulative_distance(&self) -> bool { + self.validity_cumulative_distance_raw() + } + + /// Get raw value of Validity_Cumulative_Distance + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_cumulative_distance_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Cumulative_Distance + #[inline(always)] + pub fn set_validity_cumulative_distance(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Cumulative_Time + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_cumulative_time(&self) -> bool { + self.validity_cumulative_time_raw() + } + + /// Get raw value of Validity_Cumulative_Time + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_cumulative_time_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Cumulative_Time + #[inline(always)] + pub fn set_validity_cumulative_time(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbCumulativeDistance2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbCumulativeDistance2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Cumulative_Distance_1 +/// +/// - Extended ID: 155880482 (0x94a8c22) +/// - Size: 8 bytes +/// +/// This cumulative distance calculation is updated continuously once the first good GPS lock is obtained. +#[derive(Clone, Copy)] +pub struct RtSbCumulativeDistance1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbCumulativeDistance1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a8c22)}); + + pub const CUMULATIVE_DISTANCE_MIN: f32 = 0_f32; + pub const CUMULATIVE_DISTANCE_MAX: f32 = 4294967_f32; + pub const CUMULATIVE_TIME_MIN: f32 = 0_f32; + pub const CUMULATIVE_TIME_MAX: f32 = 167772_f32; + + /// Construct new RT_SB_Cumulative_Distance_1 from values + pub fn new(cumulative_distance: f32, cumulative_time: f32, validity_cumulative_distance: bool, validity_cumulative_time: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_cumulative_distance(cumulative_distance)?; + res.set_cumulative_time(cumulative_time)?; + res.set_validity_cumulative_distance(validity_cumulative_distance)?; + res.set_validity_cumulative_time(validity_cumulative_time)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Cumulative_Distance + /// + /// - Min: 0 + /// - Max: 4294967 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn cumulative_distance(&self) -> f32 { + self.cumulative_distance_raw() + } + + /// Get raw value of Cumulative_Distance + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cumulative_distance_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Cumulative_Distance + #[inline(always)] + pub fn set_cumulative_distance(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 4294967_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbCumulativeDistance1::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Cumulative_Time + /// + /// - Min: 0 + /// - Max: 167772 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn cumulative_time(&self) -> f32 { + self.cumulative_time_raw() + } + + /// Get raw value of Cumulative_Time + /// + /// - Start bit: 8 + /// - Signal size: 24 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn cumulative_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Cumulative_Time + #[inline(always)] + pub fn set_cumulative_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 167772_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbCumulativeDistance1::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) + } + + /// Validity_Cumulative_Distance + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_cumulative_distance(&self) -> bool { + self.validity_cumulative_distance_raw() + } + + /// Get raw value of Validity_Cumulative_Distance + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_cumulative_distance_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Cumulative_Distance + #[inline(always)] + pub fn set_validity_cumulative_distance(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Cumulative_Time + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_cumulative_time(&self) -> bool { + self.validity_cumulative_time_raw() + } + + /// Get raw value of Validity_Cumulative_Time + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_cumulative_time_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Cumulative_Time + #[inline(always)] + pub fn set_validity_cumulative_time(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbCumulativeDistance1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbCumulativeDistance1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Trigger_Timestamp +/// +/// - Extended ID: 156724258 (0x9576c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbTriggerTimestamp { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbTriggerTimestamp { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9576c22)}); + + pub const GPS_HIGH_RESOLUTION_TIME_MIN: f32 = 0_f32; + pub const GPS_HIGH_RESOLUTION_TIME_MAX: f32 = 604800_f32; + pub const TRIGGER_NUMBER_MIN: u8 = 0_u8; + pub const TRIGGER_NUMBER_MAX: u8 = 128_u8; + pub const ACCURACY_TRIGGER_TIMESTAMP_MIN: u8 = 0_u8; + pub const ACCURACY_TRIGGER_TIMESTAMP_MAX: u8 = 255_u8; + + /// Construct new RT_SB_Trigger_Timestamp from values + pub fn new(gps_high_resolution_time: f32, trigger_timestamp_type: bool, trigger_number: u8, accuracy_trigger_timestamp: u8, validity_trigger_timestamp: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_high_resolution_time(gps_high_resolution_time)?; + res.set_trigger_timestamp_type(trigger_timestamp_type)?; + res.set_trigger_number(trigger_number)?; + res.set_accuracy_trigger_timestamp(accuracy_trigger_timestamp)?; + res.set_validity_trigger_timestamp(validity_trigger_timestamp)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_High_Resolution_Time + /// + /// GPS time of week to micro-second resolution. + /// + /// - Min: 0 + /// - Max: 604800 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_high_resolution_time(&self) -> f32 { + self.gps_high_resolution_time_raw() + } + + /// Get raw value of GPS_High_Resolution_Time + /// + /// - Start bit: 24 + /// - Signal size: 40 bits + /// - Factor: 0.000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_high_resolution_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[24..64].load_le::(); + + let factor = 0.000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_High_Resolution_Time + #[inline(always)] + pub fn set_gps_high_resolution_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 604800_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTriggerTimestamp::MESSAGE_ID }); + } + let factor = 0.000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u64; + + self.raw.view_bits_mut::()[24..64].store_le(value); + Ok(()) + } + + /// Trigger_Timestamp_Type + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn trigger_timestamp_type(&self) -> RtSbTriggerTimestampTriggerTimestampType { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + match signal { + 1 => RtSbTriggerTimestampTriggerTimestampType::RisingEdge, + 0 => RtSbTriggerTimestampTriggerTimestampType::FallingEdge, + _ => RtSbTriggerTimestampTriggerTimestampType::_Other(self.trigger_timestamp_type_raw()), + } + } + + /// Get raw value of Trigger_Timestamp_Type + /// + /// - Start bit: 23 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn trigger_timestamp_type_raw(&self) -> bool { + let signal = self.raw.view_bits::()[23..24].load_le::(); + + signal == 1 + } + + /// Set value of Trigger_Timestamp_Type + #[inline(always)] + pub fn set_trigger_timestamp_type(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[23..24].store_le(value); + Ok(()) + } + + /// Trigger_Number + /// + /// This is the ID of the trigger that generated the event, as marked on the case of the logger + /// + /// - Min: 0 + /// - Max: 128 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn trigger_number(&self) -> u8 { + self.trigger_number_raw() + } + + /// Get raw value of Trigger_Number + /// + /// - Start bit: 16 + /// - Signal size: 7 bits + /// - Factor: 1 + /// - Offset: 1 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn trigger_number_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..23].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(1) + } + + /// Set value of Trigger_Number + #[inline(always)] + pub fn set_trigger_number(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 128_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTriggerTimestamp::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(1) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbTriggerTimestamp::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..23].store_le(value); + Ok(()) + } + + /// Accuracy_Trigger_Timestamp + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_trigger_timestamp(&self) -> u8 { + self.accuracy_trigger_timestamp_raw() + } + + /// Get raw value of Accuracy_Trigger_Timestamp + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_trigger_timestamp_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Trigger_Timestamp + #[inline(always)] + pub fn set_accuracy_trigger_timestamp(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbTriggerTimestamp::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbTriggerTimestamp::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Trigger_Timestamp + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_trigger_timestamp(&self) -> bool { + self.validity_trigger_timestamp_raw() + } + + /// Get raw value of Validity_Trigger_Timestamp + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_trigger_timestamp_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Trigger_Timestamp + #[inline(always)] + pub fn set_validity_trigger_timestamp(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbTriggerTimestamp { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbTriggerTimestamp { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for Trigger_Timestamp_Type +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbTriggerTimestampTriggerTimestampType { + RisingEdge, + FallingEdge, + _Other(bool), +} + +impl From for bool { + fn from(val: RtSbTriggerTimestampTriggerTimestampType) -> bool { + match val { + RtSbTriggerTimestampTriggerTimestampType::RisingEdge => true, + RtSbTriggerTimestampTriggerTimestampType::FallingEdge => false, + RtSbTriggerTimestampTriggerTimestampType::_Other(x) => x, + } + } +} + + +/// RT_IMU06_Gyro_Rates +/// +/// - Extended ID: 155872545 (0x94a6d21) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtImu06GyroRates { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtImu06GyroRates { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a6d21)}); + + pub const GYRO_RATE_ROLL_MIN: f32 = -327_f32; + pub const GYRO_RATE_ROLL_MAX: f32 = 327_f32; + pub const GYRO_RATE_PITCH_MIN: f32 = -327_f32; + pub const GYRO_RATE_PITCH_MAX: f32 = 327_f32; + pub const GYRO_RATE_YAW_MIN: f32 = -327_f32; + pub const GYRO_RATE_YAW_MAX: f32 = 327_f32; + pub const ACCURACY_GYRO_RATES_MIN: u8 = 0_u8; + pub const ACCURACY_GYRO_RATES_MAX: u8 = 0_u8; + + /// Construct new RT_IMU06_Gyro_Rates from values + pub fn new(gyro_rate_roll: f32, gyro_rate_pitch: f32, gyro_rate_yaw: f32, accuracy_gyro_rates: u8, validity_gyro_rate_roll: bool, validity_gyro_rate_pitch: bool, validity_gyro_rate_yaw: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gyro_rate_roll(gyro_rate_roll)?; + res.set_gyro_rate_pitch(gyro_rate_pitch)?; + res.set_gyro_rate_yaw(gyro_rate_yaw)?; + res.set_accuracy_gyro_rates(accuracy_gyro_rates)?; + res.set_validity_gyro_rate_roll(validity_gyro_rate_roll)?; + res.set_validity_gyro_rate_pitch(validity_gyro_rate_pitch)?; + res.set_validity_gyro_rate_yaw(validity_gyro_rate_yaw)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Gyro_Rate_Roll + /// + /// Roll rate is positive for clockwise rotation when looking at the rear of the vehicle from behind the vehicle. + /// + /// - Min: -327 + /// - Max: 327 + /// - Unit: "degrees/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gyro_rate_roll(&self) -> f32 { + self.gyro_rate_roll_raw() + } + + /// Get raw value of Gyro_Rate_Roll + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gyro_rate_roll_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Gyro_Rate_Roll + #[inline(always)] + pub fn set_gyro_rate_roll(&mut self, value: f32) -> Result<(), CanError> { + if value < -327_f32 || 327_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06GyroRates::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Gyro_Rate_Pitch + /// + /// Pitch rate is positive for clockwise rotation when looking at the left hand side of the vehicle from the left of the vehicle. + /// + /// - Min: -327 + /// - Max: 327 + /// - Unit: "degrees/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gyro_rate_pitch(&self) -> f32 { + self.gyro_rate_pitch_raw() + } + + /// Get raw value of Gyro_Rate_Pitch + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gyro_rate_pitch_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Gyro_Rate_Pitch + #[inline(always)] + pub fn set_gyro_rate_pitch(&mut self, value: f32) -> Result<(), CanError> { + if value < -327_f32 || 327_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06GyroRates::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Gyro_Rate_Yaw + /// + /// Yaw rate is positive for clockwise rotation when looking down on the vehicle from above. + /// + /// - Min: -327 + /// - Max: 327 + /// - Unit: "degrees/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gyro_rate_yaw(&self) -> f32 { + self.gyro_rate_yaw_raw() + } + + /// Get raw value of Gyro_Rate_Yaw + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gyro_rate_yaw_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Gyro_Rate_Yaw + #[inline(always)] + pub fn set_gyro_rate_yaw(&mut self, value: f32) -> Result<(), CanError> { + if value < -327_f32 || 327_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06GyroRates::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_Gyro_Rates + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gyro_rates(&self) -> u8 { + self.accuracy_gyro_rates_raw() + } + + /// Get raw value of Accuracy_Gyro_Rates + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gyro_rates_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Gyro_Rates + #[inline(always)] + pub fn set_accuracy_gyro_rates(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06GyroRates::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtImu06GyroRates::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Gyro_Rate_Roll + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gyro_rate_roll(&self) -> bool { + self.validity_gyro_rate_roll_raw() + } + + /// Get raw value of Validity_Gyro_Rate_Roll + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gyro_rate_roll_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Gyro_Rate_Roll + #[inline(always)] + pub fn set_validity_gyro_rate_roll(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Gyro_Rate_Pitch + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gyro_rate_pitch(&self) -> bool { + self.validity_gyro_rate_pitch_raw() + } + + /// Get raw value of Validity_Gyro_Rate_Pitch + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gyro_rate_pitch_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Gyro_Rate_Pitch + #[inline(always)] + pub fn set_validity_gyro_rate_pitch(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Gyro_Rate_Yaw + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gyro_rate_yaw(&self) -> bool { + self.validity_gyro_rate_yaw_raw() + } + + /// Get raw value of Validity_Gyro_Rate_Yaw + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gyro_rate_yaw_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Gyro_Rate_Yaw + #[inline(always)] + pub fn set_validity_gyro_rate_yaw(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtImu06GyroRates { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtImu06GyroRates { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_IMU06_Accel +/// +/// - Extended ID: 155872289 (0x94a6c21) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtImu06Accel { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtImu06Accel { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a6c21)}); + + pub const ACCEL_VERTICAL_MIN: f32 = -65_f32; + pub const ACCEL_VERTICAL_MAX: f32 = 65_f32; + pub const ACCEL_LATERAL_MIN: f32 = -65_f32; + pub const ACCEL_LATERAL_MAX: f32 = 65_f32; + pub const ACCEL_LONGITUDINAL_MIN: f32 = -65_f32; + pub const ACCEL_LONGITUDINAL_MAX: f32 = 65_f32; + pub const ACCURACY_ACCEL_MIN: u8 = 0_u8; + pub const ACCURACY_ACCEL_MAX: u8 = 255_u8; + + /// Construct new RT_IMU06_Accel from values + pub fn new(accel_vertical: f32, accel_lateral: f32, accel_longitudinal: f32, accuracy_accel: u8, validity_accel_vertical: bool, validity_accel_lateral: bool, validity_accel_longitudinal: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_accel_vertical(accel_vertical)?; + res.set_accel_lateral(accel_lateral)?; + res.set_accel_longitudinal(accel_longitudinal)?; + res.set_accuracy_accel(accuracy_accel)?; + res.set_validity_accel_vertical(validity_accel_vertical)?; + res.set_validity_accel_lateral(validity_accel_lateral)?; + res.set_validity_accel_longitudinal(validity_accel_longitudinal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Accel_Vertical + /// + /// Vertical acceleration. This is positive when the vehicle accelerates in an upwards direction, e.g. when travelling through a dip. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_vertical(&self) -> f32 { + self.accel_vertical_raw() + } + + /// Get raw value of Accel_Vertical + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_vertical_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Vertical + #[inline(always)] + pub fn set_accel_vertical(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06Accel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Accel_Lateral + /// + /// Lateral acceleration. This is positive when the vehicle accelerates towards the right, e.g. when cornering around a right-hand bend. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_lateral(&self) -> f32 { + self.accel_lateral_raw() + } + + /// Get raw value of Accel_Lateral + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_lateral_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Lateral + #[inline(always)] + pub fn set_accel_lateral(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06Accel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Accel_Longitudinal + /// + /// Longitudinal acceleration. This is positive when the vehicle accelerates in a forwards direction. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_longitudinal(&self) -> f32 { + self.accel_longitudinal_raw() + } + + /// Get raw value of Accel_Longitudinal + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_longitudinal_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Longitudinal + #[inline(always)] + pub fn set_accel_longitudinal(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06Accel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_Accel + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_accel(&self) -> u8 { + self.accuracy_accel_raw() + } + + /// Get raw value of Accuracy_Accel + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_accel_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Accel + #[inline(always)] + pub fn set_accuracy_accel(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtImu06Accel::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtImu06Accel::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Accel_Vertical + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_vertical(&self) -> bool { + self.validity_accel_vertical_raw() + } + + /// Get raw value of Validity_Accel_Vertical + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_vertical_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Vertical + #[inline(always)] + pub fn set_validity_accel_vertical(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Accel_Lateral + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_lateral(&self) -> bool { + self.validity_accel_lateral_raw() + } + + /// Get raw value of Validity_Accel_Lateral + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_lateral_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Lateral + #[inline(always)] + pub fn set_validity_accel_lateral(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Accel_Longitudinal + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_longitudinal(&self) -> bool { + self.validity_accel_longitudinal_raw() + } + + /// Get raw value of Validity_Accel_Longitudinal + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_longitudinal_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Longitudinal + #[inline(always)] + pub fn set_validity_accel_longitudinal(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtImu06Accel { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtImu06Accel { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Speed +/// +/// - Extended ID: 155876386 (0x94a7c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a7c22)}); + + pub const SPEED_MIN: f32 = -20000_f32; + pub const SPEED_MAX: f32 = 20000_f32; + pub const ACCURACY_SPEED_MIN: u8 = 0_u8; + pub const ACCURACY_SPEED_MAX: u8 = 255_u8; + + /// Construct new RT_SB_Speed from values + pub fn new(speed: f32, accuracy_speed: u8, validity_speed: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_speed(speed)?; + res.set_accuracy_speed(accuracy_speed)?; + res.set_validity_speed(validity_speed)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Speed + /// + /// - Min: -20000 + /// - Max: 20000 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn speed(&self) -> f32 { + self.speed_raw() + } + + /// Get raw value of Speed + /// + /// - Start bit: 16 + /// - Signal size: 32 bits + /// - Factor: 0.00001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn speed_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..48].load_le::(); + + let factor = 0.00001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Speed + #[inline(always)] + pub fn set_speed(&mut self, value: f32) -> Result<(), CanError> { + if value < -20000_f32 || 20000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbSpeed::MESSAGE_ID }); + } + let factor = 0.00001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..48].store_le(value); + Ok(()) + } + + /// Accuracy_Speed + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_speed(&self) -> u8 { + self.accuracy_speed_raw() + } + + /// Get raw value of Accuracy_Speed + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_speed_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Speed + #[inline(always)] + pub fn set_accuracy_speed(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbSpeed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbSpeed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Speed + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_speed(&self) -> bool { + self.validity_speed_raw() + } + + /// Get raw value of Validity_Speed + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_speed_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Speed + #[inline(always)] + pub fn set_validity_speed(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_RTK_Slip +/// +/// - Extended ID: 156667170 (0x9568d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbRtkSlip { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbRtkSlip { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9568d22)}); + + pub const RTK_BASELINE_MIN: u16 = 0_u16; + pub const RTK_BASELINE_MAX: u16 = 65535_u16; + pub const RTK_SQUAT_MIN: f32 = -360_f32; + pub const RTK_SQUAT_MAX: f32 = 360_f32; + pub const RTK_SLIP_MIN: f32 = -360_f32; + pub const RTK_SLIP_MAX: f32 = 360_f32; + pub const ACCURACY_RTK_BASELINE_MIN: u8 = 0_u8; + pub const ACCURACY_RTK_BASELINE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_RTK_Slip from values + pub fn new(rtk_baseline: u16, rtk_squat: f32, rtk_slip: f32, accuracy_rtk_baseline: u8, validity_rtk_baseline: bool, validity_rtk_squat: bool, validity_rtk_slip: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rtk_baseline(rtk_baseline)?; + res.set_rtk_squat(rtk_squat)?; + res.set_rtk_slip(rtk_slip)?; + res.set_accuracy_rtk_baseline(accuracy_rtk_baseline)?; + res.set_validity_rtk_baseline(validity_rtk_baseline)?; + res.set_validity_rtk_squat(validity_rtk_squat)?; + res.set_validity_rtk_slip(validity_rtk_slip)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// RTK_Baseline + /// + /// This is the estimated baseline length calculated by the RTK solution. + /// + /// - Min: 0 + /// - Max: 65535 + /// - Unit: "mm" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_baseline(&self) -> u16 { + self.rtk_baseline_raw() + } + + /// Get raw value of RTK_Baseline + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn rtk_baseline_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of RTK_Baseline + #[inline(always)] + pub fn set_rtk_baseline(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 65535_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkSlip::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbRtkSlip::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// RTK_Squat + /// + /// Squat is defined as the difference between pitch and gradient. + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_squat(&self) -> f32 { + self.rtk_squat_raw() + } + + /// Get raw value of RTK_Squat + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rtk_squat_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of RTK_Squat + #[inline(always)] + pub fn set_rtk_squat(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkSlip::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// RTK_Slip + /// + /// Slip is defined as the difference between yaw and heading. + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_slip(&self) -> f32 { + self.rtk_slip_raw() + } + + /// Get raw value of RTK_Slip + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rtk_slip_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of RTK_Slip + #[inline(always)] + pub fn set_rtk_slip(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkSlip::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_RTK_Baseline + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_rtk_baseline(&self) -> u8 { + self.accuracy_rtk_baseline_raw() + } + + /// Get raw value of Accuracy_RTK_Baseline + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_rtk_baseline_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_RTK_Baseline + #[inline(always)] + pub fn set_accuracy_rtk_baseline(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkSlip::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbRtkSlip::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_RTK_Baseline + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_rtk_baseline(&self) -> bool { + self.validity_rtk_baseline_raw() + } + + /// Get raw value of Validity_RTK_Baseline + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_rtk_baseline_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_RTK_Baseline + #[inline(always)] + pub fn set_validity_rtk_baseline(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_RTK_Squat + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_rtk_squat(&self) -> bool { + self.validity_rtk_squat_raw() + } + + /// Get raw value of Validity_RTK_Squat + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_rtk_squat_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_RTK_Squat + #[inline(always)] + pub fn set_validity_rtk_squat(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_RTK_Slip + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_rtk_slip(&self) -> bool { + self.validity_rtk_slip_raw() + } + + /// Get raw value of Validity_RTK_Slip + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_rtk_slip_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_RTK_Slip + #[inline(always)] + pub fn set_validity_rtk_slip(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbRtkSlip { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbRtkSlip { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_RTK_Attitude +/// +/// - Extended ID: 156666914 (0x9568c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbRtkAttitude { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbRtkAttitude { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9568c22)}); + + pub const RTK_ATTITUDE_ROLL_MIN: f32 = -90_f32; + pub const RTK_ATTITUDE_ROLL_MAX: f32 = 90_f32; + pub const RTK_ATTITUDE_PITCH_MIN: f32 = -90_f32; + pub const RTK_ATTITUDE_PITCH_MAX: f32 = 90_f32; + pub const RTK_ATTITUDE_YAW_MIN: f32 = -360_f32; + pub const RTK_ATTITUDE_YAW_MAX: f32 = 360_f32; + pub const ACCURACY_RTK_ATTITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_RTK_ATTITUDE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_RTK_Attitude from values + pub fn new(rtk_attitude_roll: f32, rtk_attitude_pitch: f32, rtk_attitude_yaw: f32, accuracy_rtk_attitude: u8, validity_rtk_roll: bool, validity_rtk_pitch: bool, validity_rtk_yaw: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rtk_attitude_roll(rtk_attitude_roll)?; + res.set_rtk_attitude_pitch(rtk_attitude_pitch)?; + res.set_rtk_attitude_yaw(rtk_attitude_yaw)?; + res.set_accuracy_rtk_attitude(accuracy_rtk_attitude)?; + res.set_validity_rtk_roll(validity_rtk_roll)?; + res.set_validity_rtk_pitch(validity_rtk_pitch)?; + res.set_validity_rtk_yaw(validity_rtk_yaw)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// RTK_Attitude_Roll + /// + /// RTK attitude is determined from the MB-RTK solution only. Roll is positive for a clockwise rotational displacement relative to the local horizontal plane when looking at the vehicle from the rear of it. + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_attitude_roll(&self) -> f32 { + self.rtk_attitude_roll_raw() + } + + /// Get raw value of RTK_Attitude_Roll + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rtk_attitude_roll_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of RTK_Attitude_Roll + #[inline(always)] + pub fn set_rtk_attitude_roll(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkAttitude::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// RTK_Attitude_Pitch + /// + /// RTK attitude is determined from the MB-RTK solution only. Pitch is positive for a clockwise rotational displacement from the local horizontal plane when looking at the vehicle from the left hand side of it. + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_attitude_pitch(&self) -> f32 { + self.rtk_attitude_pitch_raw() + } + + /// Get raw value of RTK_Attitude_Pitch + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rtk_attitude_pitch_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of RTK_Attitude_Pitch + #[inline(always)] + pub fn set_rtk_attitude_pitch(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkAttitude::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// RTK_Attitude_Yaw + /// + /// RTK attitude is determined from the MB-RTK solution only. Yaw is positive for a clockwise rotational displacement from due North, looking down on the vehicle from above. + /// + /// - Min: -360 + /// - Max: 360 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_attitude_yaw(&self) -> f32 { + self.rtk_attitude_yaw_raw() + } + + /// Get raw value of RTK_Attitude_Yaw + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn rtk_attitude_yaw_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of RTK_Attitude_Yaw + #[inline(always)] + pub fn set_rtk_attitude_yaw(&mut self, value: f32) -> Result<(), CanError> { + if value < -360_f32 || 360_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkAttitude::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_RTK_Attitude + /// + /// Note that RTK yaw is typically up to about 4 times more accurate than RTK pitch or roll. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_rtk_attitude(&self) -> u8 { + self.accuracy_rtk_attitude_raw() + } + + /// Get raw value of Accuracy_RTK_Attitude + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_rtk_attitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_RTK_Attitude + #[inline(always)] + pub fn set_accuracy_rtk_attitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbRtkAttitude::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbRtkAttitude::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_RTK_Roll + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_rtk_roll(&self) -> bool { + self.validity_rtk_roll_raw() + } + + /// Get raw value of Validity_RTK_Roll + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_rtk_roll_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_RTK_Roll + #[inline(always)] + pub fn set_validity_rtk_roll(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_RTK_Pitch + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_rtk_pitch(&self) -> bool { + self.validity_rtk_pitch_raw() + } + + /// Get raw value of Validity_RTK_Pitch + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_rtk_pitch_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_RTK_Pitch + #[inline(always)] + pub fn set_validity_rtk_pitch(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_RTK_Yaw + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_rtk_yaw(&self) -> bool { + self.validity_rtk_yaw_raw() + } + + /// Get raw value of Validity_RTK_Yaw + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_rtk_yaw_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_RTK_Yaw + #[inline(always)] + pub fn set_validity_rtk_yaw(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbRtkAttitude { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbRtkAttitude { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Mcycle_Lean +/// +/// - Extended ID: 156671010 (0x9569c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsMcycleLean { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsMcycleLean { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9569c22)}); + + pub const GPS_MCYCLE_LEAN_ANGLE_MIN: f32 = -90_f32; + pub const GPS_MCYCLE_LEAN_ANGLE_MAX: f32 = 90_f32; + pub const GPS_LATERAL_ACCEL_MIN: f32 = -65_f32; + pub const GPS_LATERAL_ACCEL_MAX: f32 = 65_f32; + pub const ACCURACY_GPS_LATERAL_ACCEL_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_LATERAL_ACCEL_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Mcycle_Lean from values + pub fn new(gps_mcycle_lean_angle: f32, gps_lateral_accel: f32, accuracy_gps_lateral_accel: u8, validity_gps_mcycle_lean: bool, validity_gps_lateral_accel: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_mcycle_lean_angle(gps_mcycle_lean_angle)?; + res.set_gps_lateral_accel(gps_lateral_accel)?; + res.set_accuracy_gps_lateral_accel(accuracy_gps_lateral_accel)?; + res.set_validity_gps_mcycle_lean(validity_gps_mcycle_lean)?; + res.set_validity_gps_lateral_accel(validity_gps_lateral_accel)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Mcycle_Lean_Angle + /// + /// Motorcycle lean angle, derived from rate of change of heading from GPS. This is the lean angle of the centre of mass of the combined bike + rider. + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_mcycle_lean_angle(&self) -> f32 { + self.gps_mcycle_lean_angle_raw() + } + + /// Get raw value of GPS_Mcycle_Lean_Angle + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_mcycle_lean_angle_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Mcycle_Lean_Angle + #[inline(always)] + pub fn set_gps_mcycle_lean_angle(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsMcycleLean::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// GPS_Lateral_Accel + /// + /// GPS-derived lateral acceleration. This is derived by differentiating GPS heading - it is much more noisy than lateral accel from the accelerometers, but useful for m/cycle applications. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_lateral_accel(&self) -> f32 { + self.gps_lateral_accel_raw() + } + + /// Get raw value of GPS_Lateral_Accel + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_lateral_accel_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Lateral_Accel + #[inline(always)] + pub fn set_gps_lateral_accel(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsMcycleLean::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Lateral_Accel + /// + /// This accuracy value applies to both GPS-derived lateral acceleration and motorcycle lean angle, since both are derived from the rate of change of GPS heading. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_lateral_accel(&self) -> u8 { + self.accuracy_gps_lateral_accel_raw() + } + + /// Get raw value of Accuracy_GPS_Lateral_Accel + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_lateral_accel_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Lateral_Accel + #[inline(always)] + pub fn set_accuracy_gps_lateral_accel(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsMcycleLean::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsMcycleLean::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Mcycle_Lean + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_mcycle_lean(&self) -> bool { + self.validity_gps_mcycle_lean_raw() + } + + /// Get raw value of Validity_GPS_Mcycle_Lean + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_mcycle_lean_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Mcycle_Lean + #[inline(always)] + pub fn set_validity_gps_mcycle_lean(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Lateral_Accel + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_lateral_accel(&self) -> bool { + self.validity_gps_lateral_accel_raw() + } + + /// Get raw value of Validity_GPS_Lateral_Accel + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_lateral_accel_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Lateral_Accel + #[inline(always)] + pub fn set_validity_gps_lateral_accel(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsMcycleLean { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsMcycleLean { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Status +/// +/// - Extended ID: 156658722 (0x9566c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsStatus { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsStatus { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566c22)}); + + pub const RTK_STATUS_MIN: u8 = 0_u8; + pub const RTK_STATUS_MAX: u8 = 255_u8; + pub const GPS_N_SV_RTK_MIN: u8 = 0_u8; + pub const GPS_N_SV_RTK_MAX: u8 = 16_u8; + pub const GPS_N_SV_2_MIN: u8 = 0_u8; + pub const GPS_N_SV_2_MAX: u8 = 16_u8; + pub const GPS_N_SV_MIN: u8 = 0_u8; + pub const GPS_N_SV_MAX: u8 = 16_u8; + pub const FIRMWARE_VERSION_MINOR_MIN: u8 = 0_u8; + pub const FIRMWARE_VERSION_MINOR_MAX: u8 = 255_u8; + pub const FIRMWARE_VERSION_INTERMEDIATE_MIN: u8 = 0_u8; + pub const FIRMWARE_VERSION_INTERMEDIATE_MAX: u8 = 255_u8; + pub const FIRMWARE_VERSION_MAJOR_MIN: u8 = 0_u8; + pub const FIRMWARE_VERSION_MAJOR_MAX: u8 = 255_u8; + pub const GPS_STATUS_MIN: u8 = 0_u8; + pub const GPS_STATUS_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Status from values + pub fn new(rtk_status: u8, gps_n_sv_rtk: u8, gps_n_sv_2: u8, gps_n_sv: u8, firmware_version_minor: u8, firmware_version_intermediate: u8, firmware_version_major: u8, gps_status: u8) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_rtk_status(rtk_status)?; + res.set_gps_n_sv_rtk(gps_n_sv_rtk)?; + res.set_gps_n_sv_2(gps_n_sv_2)?; + res.set_gps_n_sv(gps_n_sv)?; + res.set_firmware_version_minor(firmware_version_minor)?; + res.set_firmware_version_intermediate(firmware_version_intermediate)?; + res.set_firmware_version_major(firmware_version_major)?; + res.set_gps_status(gps_status)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// RTK_Status + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn rtk_status(&self) -> RtSbGpsStatusRtkStatus { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + match signal { + 4 => RtSbGpsStatusRtkStatus::MultipleRtkSolutionsFound, + 3 => RtSbGpsStatusRtkStatus::RtkSolutionOk, + 2 => RtSbGpsStatusRtkStatus::RtkSolutionFailed, + 1 => RtSbGpsStatusRtkStatus::NotEnoughCommonSatellites, + 0 => RtSbGpsStatusRtkStatus::NotAttemptingRtkSolution, + _ => RtSbGpsStatusRtkStatus::_Other(self.rtk_status_raw()), + } + } + + /// Get raw value of RTK_Status + /// + /// - Start bit: 56 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn rtk_status_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[56..64].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of RTK_Status + #[inline(always)] + pub fn set_rtk_status(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[56..64].store_le(value); + Ok(()) + } + + /// GPS_nSv_RTK + /// + /// Number of common satellites available to RTK solution + /// + /// - Min: 0 + /// - Max: 16 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_n_sv_rtk(&self) -> u8 { + self.gps_n_sv_rtk_raw() + } + + /// Get raw value of GPS_nSv_RTK + /// + /// - Start bit: 48 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_n_sv_rtk_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[48..56].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GPS_nSv_RTK + #[inline(always)] + pub fn set_gps_n_sv_rtk(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 16_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[48..56].store_le(value); + Ok(()) + } + + /// GPS_nSv_2 + /// + /// Number of satellites used in GPS solution by module 2 on RTK units. + /// + /// - Min: 0 + /// - Max: 16 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_n_sv_2(&self) -> u8 { + self.gps_n_sv_2_raw() + } + + /// Get raw value of GPS_nSv_2 + /// + /// - Start bit: 40 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_n_sv_2_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[40..48].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GPS_nSv_2 + #[inline(always)] + pub fn set_gps_n_sv_2(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 16_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[40..48].store_le(value); + Ok(()) + } + + /// GPS_nSv + /// + /// Number of satellites used in GPS solution + /// + /// - Min: 0 + /// - Max: 16 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_n_sv(&self) -> u8 { + self.gps_n_sv_raw() + } + + /// Get raw value of GPS_nSv + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_n_sv_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GPS_nSv + #[inline(always)] + pub fn set_gps_n_sv(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 16_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// Firmware_Version_Minor + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn firmware_version_minor(&self) -> u8 { + self.firmware_version_minor_raw() + } + + /// Get raw value of Firmware_Version_Minor + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn firmware_version_minor_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Firmware_Version_Minor + #[inline(always)] + pub fn set_firmware_version_minor(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Firmware_Version_Intermediate + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn firmware_version_intermediate(&self) -> u8 { + self.firmware_version_intermediate_raw() + } + + /// Get raw value of Firmware_Version_Intermediate + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn firmware_version_intermediate_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Firmware_Version_Intermediate + #[inline(always)] + pub fn set_firmware_version_intermediate(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Firmware_Version_Major + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn firmware_version_major(&self) -> u8 { + self.firmware_version_major_raw() + } + + /// Get raw value of Firmware_Version_Major + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn firmware_version_major_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Firmware_Version_Major + #[inline(always)] + pub fn set_firmware_version_major(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// GPS_Status + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_status(&self) -> RtSbGpsStatusGpsStatus { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + match signal { + 12 => RtSbGpsStatusGpsStatus::LockCarrierSpeedAndPosition, + 11 => RtSbGpsStatusGpsStatus::LockDopplerSpeedAndPosition, + 10 => RtSbGpsStatusGpsStatus::LockPositionButNoSpeed, + 9 => RtSbGpsStatusGpsStatus::Unused, + 8 => RtSbGpsStatusGpsStatus::Unused, + 7 => RtSbGpsStatusGpsStatus::Unused, + 6 => RtSbGpsStatusGpsStatus::Unused, + 5 => RtSbGpsStatusGpsStatus::ExceededMaxSpeedOrAlt, + 4 => RtSbGpsStatusGpsStatus::SolutionFailed, + 3 => RtSbGpsStatusGpsStatus::SolutionAborted, + 2 => RtSbGpsStatusGpsStatus::InsufficientSatellites, + 1 => RtSbGpsStatusGpsStatus::SearchingForSatellites, + 0 => RtSbGpsStatusGpsStatus::GpsModuleNotDetected, + _ => RtSbGpsStatusGpsStatus::_Other(self.gps_status_raw()), + } + } + + /// Get raw value of GPS_Status + /// + /// - Start bit: 0 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_status_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[0..8].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GPS_Status + #[inline(always)] + pub fn set_gps_status(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsStatus::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[0..8].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsStatus { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsStatus { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} +/// Defined values for RTK_Status +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbGpsStatusRtkStatus { + MultipleRtkSolutionsFound, + RtkSolutionOk, + RtkSolutionFailed, + NotEnoughCommonSatellites, + NotAttemptingRtkSolution, + _Other(u8), +} + +impl From for u8 { + fn from(val: RtSbGpsStatusRtkStatus) -> u8 { + match val { + RtSbGpsStatusRtkStatus::MultipleRtkSolutionsFound => 4, + RtSbGpsStatusRtkStatus::RtkSolutionOk => 3, + RtSbGpsStatusRtkStatus::RtkSolutionFailed => 2, + RtSbGpsStatusRtkStatus::NotEnoughCommonSatellites => 1, + RtSbGpsStatusRtkStatus::NotAttemptingRtkSolution => 0, + RtSbGpsStatusRtkStatus::_Other(x) => x, + } + } +} + +/// Defined values for GPS_Status +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +#[derive(Clone, Copy, PartialEq)] +pub enum RtSbGpsStatusGpsStatus { + LockCarrierSpeedAndPosition, + LockDopplerSpeedAndPosition, + LockPositionButNoSpeed, + Unused, + Unused, + Unused, + Unused, + ExceededMaxSpeedOrAlt, + SolutionFailed, + SolutionAborted, + InsufficientSatellites, + SearchingForSatellites, + GpsModuleNotDetected, + _Other(u8), +} + +impl From for u8 { + fn from(val: RtSbGpsStatusGpsStatus) -> u8 { + match val { + RtSbGpsStatusGpsStatus::LockCarrierSpeedAndPosition => 12, + RtSbGpsStatusGpsStatus::LockDopplerSpeedAndPosition => 11, + RtSbGpsStatusGpsStatus::LockPositionButNoSpeed => 10, + RtSbGpsStatusGpsStatus::Unused => 9, + RtSbGpsStatusGpsStatus::Unused => 8, + RtSbGpsStatusGpsStatus::Unused => 7, + RtSbGpsStatusGpsStatus::Unused => 6, + RtSbGpsStatusGpsStatus::ExceededMaxSpeedOrAlt => 5, + RtSbGpsStatusGpsStatus::SolutionFailed => 4, + RtSbGpsStatusGpsStatus::SolutionAborted => 3, + RtSbGpsStatusGpsStatus::InsufficientSatellites => 2, + RtSbGpsStatusGpsStatus::SearchingForSatellites => 1, + RtSbGpsStatusGpsStatus::GpsModuleNotDetected => 0, + RtSbGpsStatusGpsStatus::_Other(x) => x, + } + } +} + + +/// RT_SB_GPS_Pos_ECEF_2 +/// +/// - Extended ID: 156660002 (0x9567122) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsPosEcef2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsPosEcef2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567122)}); + + pub const GPS_POS_ECEF_Z_MIN: f32 = -10000000_f32; + pub const GPS_POS_ECEF_Z_MAX: f32 = 10000000_f32; + pub const GPS_POS_ECEF_Y_MIN: f32 = -10000000_f32; + pub const GPS_POS_ECEF_Y_MAX: f32 = 10000000_f32; + + /// Construct new RT_SB_GPS_Pos_ECEF_2 from values + pub fn new(gps_pos_ecef_z: f32, gps_pos_ecef_y: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_pos_ecef_z(gps_pos_ecef_z)?; + res.set_gps_pos_ecef_y(gps_pos_ecef_y)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Pos_ECEF_Z + /// + /// ECEF Z position. The ECEF Z axis originates from the Earth centre, and the positive Z axis intersects the Earth surface at the North Pole. + /// + /// - Min: -10000000 + /// - Max: 10000000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_ecef_z(&self) -> f32 { + self.gps_pos_ecef_z_raw() + } + + /// Get raw value of GPS_Pos_ECEF_Z + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_ecef_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_ECEF_Z + #[inline(always)] + pub fn set_gps_pos_ecef_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -10000000_f32 || 10000000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// GPS_Pos_ECEF_Y + /// + /// ECEF Y position. The ECEF Y axis originates from the Earth centre, and the positive Y axis intersects the Earth surface at zero degrees latittude and 90 degrees longitude. + /// + /// - Min: -10000000 + /// - Max: 10000000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_ecef_y(&self) -> f32 { + self.gps_pos_ecef_y_raw() + } + + /// Get raw value of GPS_Pos_ECEF_Y + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_ecef_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_ECEF_Y + #[inline(always)] + pub fn set_gps_pos_ecef_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -10000000_f32 || 10000000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef2::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsPosEcef2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsPosEcef2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Pos_ECEF_1 +/// +/// - Extended ID: 156659746 (0x9567022) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsPosEcef1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsPosEcef1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567022)}); + + pub const GPS_POS_ECEF_X_MIN: f32 = -10000000_f32; + pub const GPS_POS_ECEF_X_MAX: f32 = 10000000_f32; + pub const ACCURACY_GPS_POS_ECEF_Z_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_ECEF_Z_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_POS_ECEF_Y_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_ECEF_Y_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_POS_ECEF_X_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_ECEF_X_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Pos_ECEF_1 from values + pub fn new(gps_pos_ecef_x: f32, accuracy_gps_pos_ecef_z: u8, accuracy_gps_pos_ecef_y: u8, accuracy_gps_pos_ecef_x: u8, validity_gps_pos_ecef_z: bool, validity_gps_pos_ecef_y: bool, validity_gps_pos_ecef_x: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_pos_ecef_x(gps_pos_ecef_x)?; + res.set_accuracy_gps_pos_ecef_z(accuracy_gps_pos_ecef_z)?; + res.set_accuracy_gps_pos_ecef_y(accuracy_gps_pos_ecef_y)?; + res.set_accuracy_gps_pos_ecef_x(accuracy_gps_pos_ecef_x)?; + res.set_validity_gps_pos_ecef_z(validity_gps_pos_ecef_z)?; + res.set_validity_gps_pos_ecef_y(validity_gps_pos_ecef_y)?; + res.set_validity_gps_pos_ecef_x(validity_gps_pos_ecef_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Pos_ECEF_X + /// + /// ECEF X position. The ECEF X axis originates from the Earth centre, and the positive X axis intersects the Earth surface at zero degrees latittude and zero degrees longitude (the intersection of the equator and the prime meridian). + /// + /// - Min: -10000000 + /// - Max: 10000000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_ecef_x(&self) -> f32 { + self.gps_pos_ecef_x_raw() + } + + /// Get raw value of GPS_Pos_ECEF_X + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_ecef_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_ECEF_X + #[inline(always)] + pub fn set_gps_pos_ecef_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -10000000_f32 || 10000000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_ECEF_Z + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_ecef_z(&self) -> u8 { + self.accuracy_gps_pos_ecef_z_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_ECEF_Z + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_ecef_z_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_ECEF_Z + #[inline(always)] + pub fn set_accuracy_gps_pos_ecef_z(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_ECEF_Y + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_ecef_y(&self) -> u8 { + self.accuracy_gps_pos_ecef_y_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_ECEF_Y + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_ecef_y_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_ECEF_Y + #[inline(always)] + pub fn set_accuracy_gps_pos_ecef_y(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_ECEF_X + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_ecef_x(&self) -> u8 { + self.accuracy_gps_pos_ecef_x_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_ECEF_X + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_ecef_x_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_ECEF_X + #[inline(always)] + pub fn set_accuracy_gps_pos_ecef_x(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsPosEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_ECEF_Z + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_ecef_z(&self) -> bool { + self.validity_gps_pos_ecef_z_raw() + } + + /// Get raw value of Validity_GPS_Pos_ECEF_Z + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_ecef_z_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_ECEF_Z + #[inline(always)] + pub fn set_validity_gps_pos_ecef_z(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_ECEF_Y + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_ecef_y(&self) -> bool { + self.validity_gps_pos_ecef_y_raw() + } + + /// Get raw value of Validity_GPS_Pos_ECEF_Y + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_ecef_y_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_ECEF_Y + #[inline(always)] + pub fn set_validity_gps_pos_ecef_y(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_ECEF_X + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_ecef_x(&self) -> bool { + self.validity_gps_pos_ecef_x_raw() + } + + /// Get raw value of Validity_GPS_Pos_ECEF_X + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_ecef_x_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_ECEF_X + #[inline(always)] + pub fn set_validity_gps_pos_ecef_x(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsPosEcef1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsPosEcef1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Pos_LLH_2 +/// +/// - Extended ID: 156659490 (0x9566f22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsPosLlh2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsPosLlh2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566f22)}); + + pub const GPS_POS_LLH_ALTITUDE_MIN: f32 = -1000_f32; + pub const GPS_POS_LLH_ALTITUDE_MAX: f32 = 100000_f32; + pub const GPS_POS_LLH_LONGITUDE_MIN: f32 = -180_f32; + pub const GPS_POS_LLH_LONGITUDE_MAX: f32 = 180_f32; + + /// Construct new RT_SB_GPS_Pos_LLH_2 from values + pub fn new(gps_pos_llh_altitude: f32, gps_pos_llh_longitude: f32) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_pos_llh_altitude(gps_pos_llh_altitude)?; + res.set_gps_pos_llh_longitude(gps_pos_llh_longitude)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Pos_LLH_Altitude + /// + /// - Min: -1000 + /// - Max: 100000 + /// - Unit: "m" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_llh_altitude(&self) -> f32 { + self.gps_pos_llh_altitude_raw() + } + + /// Get raw value of GPS_Pos_LLH_Altitude + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_llh_altitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_gps_pos_llh_altitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -1000_f32 || 100000_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh2::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// GPS_Pos_LLH_Longitude + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_llh_longitude(&self) -> f32 { + self.gps_pos_llh_longitude_raw() + } + + /// Get raw value of GPS_Pos_LLH_Longitude + /// + /// - Start bit: 0 + /// - Signal size: 32 bits + /// - Factor: 0.0000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_llh_longitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[0..32].load_le::(); + + let factor = 0.0000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_gps_pos_llh_longitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh2::MESSAGE_ID }); + } + let factor = 0.0000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[0..32].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsPosLlh2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsPosLlh2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Pos_LLH_1 +/// +/// - Extended ID: 156659234 (0x9566e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsPosLlh1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsPosLlh1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566e22)}); + + pub const GPS_POS_LLH_LATITUDE_MIN: f32 = -90_f32; + pub const GPS_POS_LLH_LATITUDE_MAX: f32 = 90_f32; + pub const ACCURACY_GPS_POS_LLH_ALTITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_LLH_ALTITUDE_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_POS_LLH_LONGITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_LLH_LONGITUDE_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_POS_LLH_LATITUDE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_POS_LLH_LATITUDE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Pos_LLH_1 from values + pub fn new(gps_pos_llh_latitude: f32, accuracy_gps_pos_llh_altitude: u8, accuracy_gps_pos_llh_longitude: u8, accuracy_gps_pos_llh_latitude: u8, validity_gps_pos_llh_altitude: bool, validity_gps_pos_llh_longitude: bool, validity_gps_pos_llh_latitude: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_pos_llh_latitude(gps_pos_llh_latitude)?; + res.set_accuracy_gps_pos_llh_altitude(accuracy_gps_pos_llh_altitude)?; + res.set_accuracy_gps_pos_llh_longitude(accuracy_gps_pos_llh_longitude)?; + res.set_accuracy_gps_pos_llh_latitude(accuracy_gps_pos_llh_latitude)?; + res.set_validity_gps_pos_llh_altitude(validity_gps_pos_llh_altitude)?; + res.set_validity_gps_pos_llh_longitude(validity_gps_pos_llh_longitude)?; + res.set_validity_gps_pos_llh_latitude(validity_gps_pos_llh_latitude)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Pos_LLH_Latitude + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_pos_llh_latitude(&self) -> f32 { + self.gps_pos_llh_latitude_raw() + } + + /// Get raw value of GPS_Pos_LLH_Latitude + /// + /// - Start bit: 32 + /// - Signal size: 32 bits + /// - Factor: 0.0000001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_pos_llh_latitude_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..64].load_le::(); + + let factor = 0.0000001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_gps_pos_llh_latitude(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID }); + } + let factor = 0.0000001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..64].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_LLH_Altitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_llh_altitude(&self) -> u8 { + self.accuracy_gps_pos_llh_altitude_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_LLH_Altitude + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_llh_altitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_accuracy_gps_pos_llh_altitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_LLH_Longitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_llh_longitude(&self) -> u8 { + self.accuracy_gps_pos_llh_longitude_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_LLH_Longitude + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_llh_longitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_accuracy_gps_pos_llh_longitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Pos_LLH_Latitude + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_pos_llh_latitude(&self) -> u8 { + self.accuracy_gps_pos_llh_latitude_raw() + } + + /// Get raw value of Accuracy_GPS_Pos_LLH_Latitude + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_pos_llh_latitude_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_accuracy_gps_pos_llh_latitude(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsPosLlh1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_LLH_Altitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_llh_altitude(&self) -> bool { + self.validity_gps_pos_llh_altitude_raw() + } + + /// Get raw value of Validity_GPS_Pos_LLH_Altitude + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_llh_altitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_LLH_Altitude + #[inline(always)] + pub fn set_validity_gps_pos_llh_altitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_LLH_Longitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_llh_longitude(&self) -> bool { + self.validity_gps_pos_llh_longitude_raw() + } + + /// Get raw value of Validity_GPS_Pos_LLH_Longitude + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_llh_longitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_LLH_Longitude + #[inline(always)] + pub fn set_validity_gps_pos_llh_longitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Pos_LLH_Latitude + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_pos_llh_latitude(&self) -> bool { + self.validity_gps_pos_llh_latitude_raw() + } + + /// Get raw value of Validity_GPS_Pos_LLH_Latitude + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_pos_llh_latitude_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Pos_LLH_Latitude + #[inline(always)] + pub fn set_validity_gps_pos_llh_latitude(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsPosLlh1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsPosLlh1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Heading_Gradient +/// +/// - Extended ID: 156664098 (0x9568122) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsHeadingGradient { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsHeadingGradient { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9568122)}); + + pub const GPS_GRADIENT_MIN: f32 = -90_f32; + pub const GPS_GRADIENT_MAX: f32 = 90_f32; + pub const ACCURACY_GPS_GRADIENT_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_GRADIENT_MAX: u8 = 255_u8; + pub const GPS_HEADING_MIN: f32 = -180_f32; + pub const GPS_HEADING_MAX: f32 = 180_f32; + pub const ACCURACY_GPS_HEADING_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_HEADING_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Heading_Gradient from values + pub fn new(gps_gradient: f32, accuracy_gps_gradient: u8, gps_heading: f32, accuracy_gps_heading: u8, validity_gps_gradient: bool, validity_gps_heading: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_gradient(gps_gradient)?; + res.set_accuracy_gps_gradient(accuracy_gps_gradient)?; + res.set_gps_heading(gps_heading)?; + res.set_accuracy_gps_heading(accuracy_gps_heading)?; + res.set_validity_gps_gradient(validity_gps_gradient)?; + res.set_validity_gps_heading(validity_gps_heading)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Gradient + /// + /// This is GPS gradient, i.e. the vertical direction that the vehicle is travelling, NOT pointing (pitch). + /// + /// - Min: -90 + /// - Max: 90 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_gradient(&self) -> f32 { + self.gps_gradient_raw() + } + + /// Get raw value of GPS_Gradient + /// + /// - Start bit: 40 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_gradient_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..56].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Gradient + #[inline(always)] + pub fn set_gps_gradient(&mut self, value: f32) -> Result<(), CanError> { + if value < -90_f32 || 90_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..56].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Gradient + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_gradient(&self) -> u8 { + self.accuracy_gps_gradient_raw() + } + + /// Get raw value of Accuracy_GPS_Gradient + /// + /// - Start bit: 32 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_gradient_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[32..40].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Gradient + #[inline(always)] + pub fn set_accuracy_gps_gradient(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[32..40].store_le(value); + Ok(()) + } + + /// GPS_Heading + /// + /// This is GPS heading, the direction that the vehicle is travelling in the local horizontal plane. + /// + /// - Min: -180 + /// - Max: 180 + /// - Unit: "degrees" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_heading(&self) -> f32 { + self.gps_heading_raw() + } + + /// Get raw value of GPS_Heading + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_heading_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Heading + #[inline(always)] + pub fn set_gps_heading(&mut self, value: f32) -> Result<(), CanError> { + if value < -180_f32 || 180_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Heading + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_heading(&self) -> u8 { + self.accuracy_gps_heading_raw() + } + + /// Get raw value of Accuracy_GPS_Heading + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_heading_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Heading + #[inline(always)] + pub fn set_accuracy_gps_heading(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsHeadingGradient::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Gradient + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_gradient(&self) -> bool { + self.validity_gps_gradient_raw() + } + + /// Get raw value of Validity_GPS_Gradient + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_gradient_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Gradient + #[inline(always)] + pub fn set_validity_gps_gradient(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Heading + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_heading(&self) -> bool { + self.validity_gps_heading_raw() + } + + /// Get raw value of Validity_GPS_Heading + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_heading_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Heading + #[inline(always)] + pub fn set_validity_gps_heading(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsHeadingGradient { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsHeadingGradient { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Vel_ECEF_2 +/// +/// - Extended ID: 156663842 (0x9568022) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsVelEcef2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsVelEcef2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9568022)}); + + pub const GPS_VEL_ECEF_Z_MIN: f32 = -838_f32; + pub const GPS_VEL_ECEF_Z_MAX: f32 = 838_f32; + pub const GPS_VEL_ECEF_Y_MIN: f32 = -838_f32; + pub const GPS_VEL_ECEF_Y_MAX: f32 = 838_f32; + + /// Construct new RT_SB_GPS_Vel_ECEF_2 from values + pub fn new(gps_vel_ecef_z: f32, gps_vel_ecef_y: f32, validity_gps_vel_ecef_z: bool, validity_gps_vel_ecef_y: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_vel_ecef_z(gps_vel_ecef_z)?; + res.set_gps_vel_ecef_y(gps_vel_ecef_y)?; + res.set_validity_gps_vel_ecef_z(validity_gps_vel_ecef_z)?; + res.set_validity_gps_vel_ecef_y(validity_gps_vel_ecef_y)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Vel_ECEF_Z + /// + /// ECEF Z velocity. The ECEF Z axis originates from the Earth centre, and the positive Z axis intersects the Earth surface at the North Pole. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_vel_ecef_z(&self) -> f32 { + self.gps_vel_ecef_z_raw() + } + + /// Get raw value of GPS_Vel_ECEF_Z + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_vel_ecef_z_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Vel_ECEF_Z + #[inline(always)] + pub fn set_gps_vel_ecef_z(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// GPS_Vel_ECEF_Y + /// + /// ECEF Y velocity. The ECEF Y axis originates from the Earth centre, and the positive Y axis intersects the Earth surface at zero degrees latittude and 90 degrees longitude. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_vel_ecef_y(&self) -> f32 { + self.gps_vel_ecef_y_raw() + } + + /// Get raw value of GPS_Vel_ECEF_Y + /// + /// - Start bit: 8 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_vel_ecef_y_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[8..32].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Vel_ECEF_Y + #[inline(always)] + pub fn set_gps_vel_ecef_y(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[8..32].store_le(value); + Ok(()) + } + + /// Validity_GPS_Vel_ECEF_Z + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_vel_ecef_z(&self) -> bool { + self.validity_gps_vel_ecef_z_raw() + } + + /// Get raw value of Validity_GPS_Vel_ECEF_Z + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_vel_ecef_z_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Vel_ECEF_Z + #[inline(always)] + pub fn set_validity_gps_vel_ecef_z(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Vel_ECEF_Y + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_vel_ecef_y(&self) -> bool { + self.validity_gps_vel_ecef_y_raw() + } + + /// Get raw value of Validity_GPS_Vel_ECEF_Y + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_vel_ecef_y_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Vel_ECEF_Y + #[inline(always)] + pub fn set_validity_gps_vel_ecef_y(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsVelEcef2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsVelEcef2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Vel_ECEF_1 +/// +/// - Extended ID: 156663586 (0x9567f22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsVelEcef1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsVelEcef1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567f22)}); + + pub const GPS_VEL_ECEF_X_MIN: f32 = -838_f32; + pub const GPS_VEL_ECEF_X_MAX: f32 = 838_f32; + pub const ACCURACY_GPS_VEL_ECEF_Z_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_VEL_ECEF_Z_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_VEL_ECEF_Y_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_VEL_ECEF_Y_MAX: u8 = 255_u8; + pub const ACCURACY_GPS_VEL_ECEF_X_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_VEL_ECEF_X_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Vel_ECEF_1 from values + pub fn new(gps_vel_ecef_x: f32, accuracy_gps_vel_ecef_z: u8, accuracy_gps_vel_ecef_y: u8, accuracy_gps_vel_ecef_x: u8, validity_gps_vel_ecef_x: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_vel_ecef_x(gps_vel_ecef_x)?; + res.set_accuracy_gps_vel_ecef_z(accuracy_gps_vel_ecef_z)?; + res.set_accuracy_gps_vel_ecef_y(accuracy_gps_vel_ecef_y)?; + res.set_accuracy_gps_vel_ecef_x(accuracy_gps_vel_ecef_x)?; + res.set_validity_gps_vel_ecef_x(validity_gps_vel_ecef_x)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Vel_ECEF_X + /// + /// ECEF X velocity. The ECEF X axis originates from the Earth centre, and the positive X axis intersects the Earth surface at zero degrees latittude and zero degrees longitude (the intersection of the equator and the prime meridian). + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_vel_ecef_x(&self) -> f32 { + self.gps_vel_ecef_x_raw() + } + + /// Get raw value of GPS_Vel_ECEF_X + /// + /// - Start bit: 32 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_vel_ecef_x_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..56].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Vel_ECEF_X + #[inline(always)] + pub fn set_gps_vel_ecef_x(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..56].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Vel_ECEF_Z + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_vel_ecef_z(&self) -> u8 { + self.accuracy_gps_vel_ecef_z_raw() + } + + /// Get raw value of Accuracy_GPS_Vel_ECEF_Z + /// + /// - Start bit: 24 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_vel_ecef_z_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[24..32].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Vel_ECEF_Z + #[inline(always)] + pub fn set_accuracy_gps_vel_ecef_z(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[24..32].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Vel_ECEF_Y + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_vel_ecef_y(&self) -> u8 { + self.accuracy_gps_vel_ecef_y_raw() + } + + /// Get raw value of Accuracy_GPS_Vel_ECEF_Y + /// + /// - Start bit: 16 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_vel_ecef_y_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[16..24].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Vel_ECEF_Y + #[inline(always)] + pub fn set_accuracy_gps_vel_ecef_y(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[16..24].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Vel_ECEF_X + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_vel_ecef_x(&self) -> u8 { + self.accuracy_gps_vel_ecef_x_raw() + } + + /// Get raw value of Accuracy_GPS_Vel_ECEF_X + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_vel_ecef_x_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Vel_ECEF_X + #[inline(always)] + pub fn set_accuracy_gps_vel_ecef_x(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsVelEcef1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Vel_ECEF_X + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_vel_ecef_x(&self) -> bool { + self.validity_gps_vel_ecef_x_raw() + } + + /// Get raw value of Validity_GPS_Vel_ECEF_X + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_vel_ecef_x_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Vel_ECEF_X + #[inline(always)] + pub fn set_validity_gps_vel_ecef_x(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsVelEcef1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsVelEcef1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Vel_NED_2 +/// +/// - Extended ID: 156663330 (0x9567e22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsVelNed2 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsVelNed2 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567e22)}); + + pub const GPS_VEL_NED_D_MIN: f32 = -838_f32; + pub const GPS_VEL_NED_D_MAX: f32 = 838_f32; + pub const ACCURACY_GPS_VEL_D_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_VEL_D_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Vel_NED_2 from values + pub fn new(gps_vel_ned_d: f32, accuracy_gps_vel_d: u8, validity_gps_vel_ned_d: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_vel_ned_d(gps_vel_ned_d)?; + res.set_accuracy_gps_vel_d(accuracy_gps_vel_d)?; + res.set_validity_gps_vel_ned_d(validity_gps_vel_ned_d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Vel_NED_D + /// + /// VELNED D velocity. This is the velocity vector directly downwards towards the Earth centre at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_vel_ned_d(&self) -> f32 { + self.gps_vel_ned_d_raw() + } + + /// Get raw value of GPS_Vel_NED_D + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_vel_ned_d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Vel_NED_D + #[inline(always)] + pub fn set_gps_vel_ned_d(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed2::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Vel_D + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_vel_d(&self) -> u8 { + self.accuracy_gps_vel_d_raw() + } + + /// Get raw value of Accuracy_GPS_Vel_D + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_vel_d_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Vel_D + #[inline(always)] + pub fn set_accuracy_gps_vel_d(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed2::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed2::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Vel_NED_D + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_vel_ned_d(&self) -> bool { + self.validity_gps_vel_ned_d_raw() + } + + /// Get raw value of Validity_GPS_Vel_NED_D + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_vel_ned_d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Vel_NED_D + #[inline(always)] + pub fn set_validity_gps_vel_ned_d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsVelNed2 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsVelNed2 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Vel_NED_1 +/// +/// - Extended ID: 156663074 (0x9567d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsVelNed1 { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsVelNed1 { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567d22)}); + + pub const GPS_VEL_NED_E_MIN: f32 = -838_f32; + pub const GPS_VEL_NED_E_MAX: f32 = 838_f32; + pub const GPS_VEL_NED_N_MIN: f32 = -838_f32; + pub const GPS_VEL_NED_N_MAX: f32 = 838_f32; + pub const ACCURACY_GPS_VEL_NE_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_VEL_NE_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Vel_NED_1 from values + pub fn new(gps_vel_ned_e: f32, gps_vel_ned_n: f32, accuracy_gps_vel_ne: u8, validity_gps_vel_ned_e: bool, validity_gps_vel_ned_n: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_vel_ned_e(gps_vel_ned_e)?; + res.set_gps_vel_ned_n(gps_vel_ned_n)?; + res.set_accuracy_gps_vel_ne(accuracy_gps_vel_ne)?; + res.set_validity_gps_vel_ned_e(validity_gps_vel_ned_e)?; + res.set_validity_gps_vel_ned_n(validity_gps_vel_ned_n)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Vel_NED_E + /// + /// VELNED E velocity. This is the velocity vector directly East at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_vel_ned_e(&self) -> f32 { + self.gps_vel_ned_e_raw() + } + + /// Get raw value of GPS_Vel_NED_E + /// + /// - Start bit: 40 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_vel_ned_e_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Vel_NED_E + #[inline(always)] + pub fn set_gps_vel_ned_e(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) + } + + /// GPS_Vel_NED_N + /// + /// VELNED N velocity. This is the velocity vector directly North at the current local Earth surface position. + /// + /// - Min: -838 + /// - Max: 838 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_vel_ned_n(&self) -> f32 { + self.gps_vel_ned_n_raw() + } + + /// Get raw value of GPS_Vel_NED_N + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gps_vel_ned_n_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Vel_NED_N + #[inline(always)] + pub fn set_gps_vel_ned_n(&mut self, value: f32) -> Result<(), CanError> { + if value < -838_f32 || 838_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed1::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i32; + + let value = u32::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Vel_NE + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_vel_ne(&self) -> u8 { + self.accuracy_gps_vel_ne_raw() + } + + /// Get raw value of Accuracy_GPS_Vel_NE + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_vel_ne_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Vel_NE + #[inline(always)] + pub fn set_accuracy_gps_vel_ne(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed1::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsVelNed1::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Vel_NED_E + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_vel_ned_e(&self) -> bool { + self.validity_gps_vel_ned_e_raw() + } + + /// Get raw value of Validity_GPS_Vel_NED_E + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_vel_ned_e_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Vel_NED_E + #[inline(always)] + pub fn set_validity_gps_vel_ned_e(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Vel_NED_N + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_vel_ned_n(&self) -> bool { + self.validity_gps_vel_ned_n_raw() + } + + /// Get raw value of Validity_GPS_Vel_NED_N + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_vel_ned_n_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Vel_NED_N + #[inline(always)] + pub fn set_validity_gps_vel_ned_n(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsVelNed1 { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsVelNed1 { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Speed +/// +/// - Extended ID: 156662818 (0x9567c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsSpeed { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsSpeed { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9567c22)}); + + pub const GPS_SPEED_3D_MIN: f32 = 0_f32; + pub const GPS_SPEED_3D_MAX: f32 = 1675_f32; + pub const GPS_SPEED_2D_MIN: f32 = 0_f32; + pub const GPS_SPEED_2D_MAX: f32 = 1675_f32; + pub const ACCURACY_GPS_SPEED_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_SPEED_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Speed from values + pub fn new(gps_speed_3d: f32, gps_speed_2d: f32, accuracy_gps_speed: u8, validity_gps_speed_3d: bool, validity_gps_speed_2d: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_speed_3d(gps_speed_3d)?; + res.set_gps_speed_2d(gps_speed_2d)?; + res.set_accuracy_gps_speed(accuracy_gps_speed)?; + res.set_validity_gps_speed_3d(validity_gps_speed_3d)?; + res.set_validity_gps_speed_2d(validity_gps_speed_2d)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Speed_3D + /// + /// This is GPS scalar 3D speed - scalar speed with the local Z axis component included. + /// + /// - Min: 0 + /// - Max: 1675 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_speed_3d(&self) -> f32 { + self.gps_speed_3d_raw() + } + + /// Get raw value of GPS_Speed_3D + /// + /// - Start bit: 40 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_speed_3d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[40..64].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Speed_3D + #[inline(always)] + pub fn set_gps_speed_3d(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 1675_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsSpeed::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[40..64].store_le(value); + Ok(()) + } + + /// GPS_Speed_2D + /// + /// This is GPS scalar 2D speed - scalar speed with no local Z axis component included. + /// + /// - Min: 0 + /// - Max: 1675 + /// - Unit: "m/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_speed_2d(&self) -> f32 { + self.gps_speed_2d_raw() + } + + /// Get raw value of GPS_Speed_2D + /// + /// - Start bit: 16 + /// - Signal size: 24 bits + /// - Factor: 0.0001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_speed_2d_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..40].load_le::(); + + let factor = 0.0001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Speed_2D + #[inline(always)] + pub fn set_gps_speed_2d(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 1675_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsSpeed::MESSAGE_ID }); + } + let factor = 0.0001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[16..40].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Speed + /// + /// This accuracy value applies to both 2D and 3D GPS speed. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_speed(&self) -> u8 { + self.accuracy_gps_speed_raw() + } + + /// Get raw value of Accuracy_GPS_Speed + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_speed_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Speed + #[inline(always)] + pub fn set_accuracy_gps_speed(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsSpeed::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsSpeed::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Speed_3D + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_speed_3d(&self) -> bool { + self.validity_gps_speed_3d_raw() + } + + /// Get raw value of Validity_GPS_Speed_3D + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_speed_3d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Speed_3D + #[inline(always)] + pub fn set_validity_gps_speed_3d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Speed_2D + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_speed_2d(&self) -> bool { + self.validity_gps_speed_2d_raw() + } + + /// Get raw value of Validity_GPS_Speed_2D + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_speed_2d_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Speed_2D + #[inline(always)] + pub fn set_validity_gps_speed_2d(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsSpeed { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsSpeed { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_GPS_Time +/// +/// - Extended ID: 156658978 (0x9566d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGpsTime { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGpsTime { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x9566d22)}); + + pub const GPS_WEEK_MIN: u16 = 0_u16; + pub const GPS_WEEK_MAX: u16 = 65535_u16; + pub const GPS_TIME_MIN: f32 = 0_f32; + pub const GPS_TIME_MAX: f32 = 604800_f32; + pub const ACCURACY_GPS_TIME_MIN: u8 = 0_u8; + pub const ACCURACY_GPS_TIME_MAX: u8 = 255_u8; + + /// Construct new RT_SB_GPS_Time from values + pub fn new(gps_week: u16, gps_time: f32, accuracy_gps_time: u8, validity_gps_week: bool, validity_gps_time: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gps_week(gps_week)?; + res.set_gps_time(gps_time)?; + res.set_accuracy_gps_time(accuracy_gps_time)?; + res.set_validity_gps_week(validity_gps_week)?; + res.set_validity_gps_time(validity_gps_time)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// GPS_Week + /// + /// - Min: 0 + /// - Max: 65535 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_week(&self) -> u16 { + self.gps_week_raw() + } + + /// Get raw value of GPS_Week + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_week_raw(&self) -> u16 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 1; + u16::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of GPS_Week + #[inline(always)] + pub fn set_gps_week(&mut self, value: u16) -> Result<(), CanError> { + if value < 0_u16 || 65535_u16 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsTime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsTime::MESSAGE_ID })?; + let value = (value / factor) as u16; + + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// GPS_Time + /// + /// GPS time is the time in seconds since midnight GMT on Saturday night. + /// + /// - Min: 0 + /// - Max: 604800 + /// - Unit: "s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gps_time(&self) -> f32 { + self.gps_time_raw() + } + + /// Get raw value of GPS_Time + /// + /// - Start bit: 16 + /// - Signal size: 32 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn gps_time_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of GPS_Time + #[inline(always)] + pub fn set_gps_time(&mut self, value: f32) -> Result<(), CanError> { + if value < 0_f32 || 604800_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsTime::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as u32; + + self.raw.view_bits_mut::()[16..48].store_le(value); + Ok(()) + } + + /// Accuracy_GPS_Time + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gps_time(&self) -> u8 { + self.accuracy_gps_time_raw() + } + + /// Get raw value of Accuracy_GPS_Time + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gps_time_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_GPS_Time + #[inline(always)] + pub fn set_accuracy_gps_time(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGpsTime::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGpsTime::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_GPS_Week + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_week(&self) -> bool { + self.validity_gps_week_raw() + } + + /// Get raw value of Validity_GPS_Week + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_week_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Week + #[inline(always)] + pub fn set_validity_gps_week(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_GPS_Time + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gps_time(&self) -> bool { + self.validity_gps_time_raw() + } + + /// Get raw value of Validity_GPS_Time + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gps_time_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_GPS_Time + #[inline(always)] + pub fn set_validity_gps_time(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGpsTime { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGpsTime { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Accel +/// +/// - Extended ID: 155872290 (0x94a6c22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbAccel { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbAccel { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a6c22)}); + + pub const ACCEL_VERTICAL_MIN: f32 = -65_f32; + pub const ACCEL_VERTICAL_MAX: f32 = 65_f32; + pub const ACCEL_LATERAL_MIN: f32 = -65_f32; + pub const ACCEL_LATERAL_MAX: f32 = 65_f32; + pub const ACCEL_LONGITUDINAL_MIN: f32 = -65_f32; + pub const ACCEL_LONGITUDINAL_MAX: f32 = 65_f32; + pub const ACCURACY_ACCEL_MIN: u8 = 0_u8; + pub const ACCURACY_ACCEL_MAX: u8 = 255_u8; + + /// Construct new RT_SB_Accel from values + pub fn new(accel_vertical: f32, accel_lateral: f32, accel_longitudinal: f32, accuracy_accel: u8, validity_accel_vertical: bool, validity_accel_lateral: bool, validity_accel_longitudinal: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_accel_vertical(accel_vertical)?; + res.set_accel_lateral(accel_lateral)?; + res.set_accel_longitudinal(accel_longitudinal)?; + res.set_accuracy_accel(accuracy_accel)?; + res.set_validity_accel_vertical(validity_accel_vertical)?; + res.set_validity_accel_lateral(validity_accel_lateral)?; + res.set_validity_accel_longitudinal(validity_accel_longitudinal)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Accel_Vertical + /// + /// Vertical acceleration. This is positive when the vehicle accelerates in an upwards direction, e.g. when travelling through a dip. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_vertical(&self) -> f32 { + self.accel_vertical_raw() + } + + /// Get raw value of Accel_Vertical + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_vertical_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Vertical + #[inline(always)] + pub fn set_accel_vertical(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbAccel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Accel_Lateral + /// + /// Lateral acceleration. This is positive when the vehicle accelerates towards the right, e.g. when cornering around a right-hand bend. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_lateral(&self) -> f32 { + self.accel_lateral_raw() + } + + /// Get raw value of Accel_Lateral + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_lateral_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Lateral + #[inline(always)] + pub fn set_accel_lateral(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbAccel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Accel_Longitudinal + /// + /// Longitudinal acceleration. This is positive when the vehicle accelerates in a forwards direction. + /// + /// - Min: -65 + /// - Max: 65 + /// - Unit: "g" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accel_longitudinal(&self) -> f32 { + self.accel_longitudinal_raw() + } + + /// Get raw value of Accel_Longitudinal + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.001 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn accel_longitudinal_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.001_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Accel_Longitudinal + #[inline(always)] + pub fn set_accel_longitudinal(&mut self, value: f32) -> Result<(), CanError> { + if value < -65_f32 || 65_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbAccel::MESSAGE_ID }); + } + let factor = 0.001_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_Accel + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 255 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_accel(&self) -> u8 { + self.accuracy_accel_raw() + } + + /// Get raw value of Accuracy_Accel + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_accel_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Accel + #[inline(always)] + pub fn set_accuracy_accel(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 255_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbAccel::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbAccel::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Accel_Vertical + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_vertical(&self) -> bool { + self.validity_accel_vertical_raw() + } + + /// Get raw value of Validity_Accel_Vertical + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_vertical_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Vertical + #[inline(always)] + pub fn set_validity_accel_vertical(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Accel_Lateral + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_lateral(&self) -> bool { + self.validity_accel_lateral_raw() + } + + /// Get raw value of Validity_Accel_Lateral + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_lateral_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Lateral + #[inline(always)] + pub fn set_validity_accel_lateral(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Accel_Longitudinal + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_accel_longitudinal(&self) -> bool { + self.validity_accel_longitudinal_raw() + } + + /// Get raw value of Validity_Accel_Longitudinal + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_accel_longitudinal_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Accel_Longitudinal + #[inline(always)] + pub fn set_validity_accel_longitudinal(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbAccel { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbAccel { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + +/// RT_SB_Gyro_Rates +/// +/// - Extended ID: 155872546 (0x94a6d22) +/// - Size: 8 bytes +#[derive(Clone, Copy)] +pub struct RtSbGyroRates { + raw: [u8; 8], +} + +#[allow( + clippy::absurd_extreme_comparisons, + clippy::excessive_precision, + clippy::manual_range_contains, + clippy::unnecessary_cast, + clippy::useless_conversion, + unused_comparisons, + unused_variables, +)] +impl RtSbGyroRates { + pub const MESSAGE_ID: embedded_can::Id = Id::Extended(unsafe { ExtendedId::new_unchecked(0x94a6d22)}); + + pub const GYRO_RATE_ROLL_MIN: f32 = -327_f32; + pub const GYRO_RATE_ROLL_MAX: f32 = 327_f32; + pub const GYRO_RATE_PITCH_MIN: f32 = -327_f32; + pub const GYRO_RATE_PITCH_MAX: f32 = 327_f32; + pub const GYRO_RATE_YAW_MIN: f32 = -327_f32; + pub const GYRO_RATE_YAW_MAX: f32 = 327_f32; + pub const ACCURACY_GYRO_RATES_MIN: u8 = 0_u8; + pub const ACCURACY_GYRO_RATES_MAX: u8 = 0_u8; + + /// Construct new RT_SB_Gyro_Rates from values + pub fn new(gyro_rate_roll: f32, gyro_rate_pitch: f32, gyro_rate_yaw: f32, accuracy_gyro_rates: u8, validity_gyro_rate_roll: bool, validity_gyro_rate_pitch: bool, validity_gyro_rate_yaw: bool) -> Result { + let mut res = Self { raw: [0u8; 8] }; + res.set_gyro_rate_roll(gyro_rate_roll)?; + res.set_gyro_rate_pitch(gyro_rate_pitch)?; + res.set_gyro_rate_yaw(gyro_rate_yaw)?; + res.set_accuracy_gyro_rates(accuracy_gyro_rates)?; + res.set_validity_gyro_rate_roll(validity_gyro_rate_roll)?; + res.set_validity_gyro_rate_pitch(validity_gyro_rate_pitch)?; + res.set_validity_gyro_rate_yaw(validity_gyro_rate_yaw)?; + Ok(res) + } + + /// Access message payload raw value + pub fn raw(&self) -> &[u8; 8] { + &self.raw + } + + /// Gyro_Rate_Roll + /// + /// Roll rate is positive for clockwise rotation when looking at the rear of the vehicle from behind the vehicle. + /// + /// - Min: -327 + /// - Max: 327 + /// - Unit: "degrees/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gyro_rate_roll(&self) -> f32 { + self.gyro_rate_roll_raw() + } + + /// Get raw value of Gyro_Rate_Roll + /// + /// - Start bit: 48 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gyro_rate_roll_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[48..64].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Gyro_Rate_Roll + #[inline(always)] + pub fn set_gyro_rate_roll(&mut self, value: f32) -> Result<(), CanError> { + if value < -327_f32 || 327_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGyroRates::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[48..64].store_le(value); + Ok(()) + } + + /// Gyro_Rate_Pitch + /// + /// Pitch rate is positive for clockwise rotation when looking at the left hand side of the vehicle from the left of the vehicle. + /// + /// - Min: -327 + /// - Max: 327 + /// - Unit: "degrees/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gyro_rate_pitch(&self) -> f32 { + self.gyro_rate_pitch_raw() + } + + /// Get raw value of Gyro_Rate_Pitch + /// + /// - Start bit: 32 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gyro_rate_pitch_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[32..48].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Gyro_Rate_Pitch + #[inline(always)] + pub fn set_gyro_rate_pitch(&mut self, value: f32) -> Result<(), CanError> { + if value < -327_f32 || 327_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGyroRates::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[32..48].store_le(value); + Ok(()) + } + + /// Gyro_Rate_Yaw + /// + /// Yaw rate is positive for clockwise rotation when looking down on the vehicle from above. + /// + /// - Min: -327 + /// - Max: 327 + /// - Unit: "degrees/s" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn gyro_rate_yaw(&self) -> f32 { + self.gyro_rate_yaw_raw() + } + + /// Get raw value of Gyro_Rate_Yaw + /// + /// - Start bit: 16 + /// - Signal size: 16 bits + /// - Factor: 0.01 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Signed + #[inline(always)] + pub fn gyro_rate_yaw_raw(&self) -> f32 { + let signal = self.raw.view_bits::()[16..32].load_le::(); + + let factor = 0.01_f32; + let offset = 0_f32; + (signal as f32) * factor + offset + } + + /// Set value of Gyro_Rate_Yaw + #[inline(always)] + pub fn set_gyro_rate_yaw(&mut self, value: f32) -> Result<(), CanError> { + if value < -327_f32 || 327_f32 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGyroRates::MESSAGE_ID }); + } + let factor = 0.01_f32; + let offset = 0_f32; + let value = ((value - offset) / factor) as i16; + + let value = u16::from_ne_bytes(value.to_ne_bytes()); + self.raw.view_bits_mut::()[16..32].store_le(value); + Ok(()) + } + + /// Accuracy_Gyro_Rates + /// + /// Dimensionless. Lower values imply but do not guarantee better accuracy than higher values. + /// + /// - Min: 0 + /// - Max: 0 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn accuracy_gyro_rates(&self) -> u8 { + self.accuracy_gyro_rates_raw() + } + + /// Get raw value of Accuracy_Gyro_Rates + /// + /// - Start bit: 8 + /// - Signal size: 8 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn accuracy_gyro_rates_raw(&self) -> u8 { + let signal = self.raw.view_bits::()[8..16].load_le::(); + + let factor = 1; + u8::from(signal).saturating_mul(factor).saturating_add(0) + } + + /// Set value of Accuracy_Gyro_Rates + #[inline(always)] + pub fn set_accuracy_gyro_rates(&mut self, value: u8) -> Result<(), CanError> { + if value < 0_u8 || 0_u8 < value { + return Err(CanError::ParameterOutOfRange { message_id: RtSbGyroRates::MESSAGE_ID }); + } + let factor = 1; + let value = value.checked_sub(0) + .ok_or(CanError::ParameterOutOfRange { message_id: RtSbGyroRates::MESSAGE_ID })?; + let value = (value / factor) as u8; + + self.raw.view_bits_mut::()[8..16].store_le(value); + Ok(()) + } + + /// Validity_Gyro_Rate_Roll + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gyro_rate_roll(&self) -> bool { + self.validity_gyro_rate_roll_raw() + } + + /// Get raw value of Validity_Gyro_Rate_Roll + /// + /// - Start bit: 2 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gyro_rate_roll_raw(&self) -> bool { + let signal = self.raw.view_bits::()[2..3].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Gyro_Rate_Roll + #[inline(always)] + pub fn set_validity_gyro_rate_roll(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[2..3].store_le(value); + Ok(()) + } + + /// Validity_Gyro_Rate_Pitch + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gyro_rate_pitch(&self) -> bool { + self.validity_gyro_rate_pitch_raw() + } + + /// Get raw value of Validity_Gyro_Rate_Pitch + /// + /// - Start bit: 1 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gyro_rate_pitch_raw(&self) -> bool { + let signal = self.raw.view_bits::()[1..2].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Gyro_Rate_Pitch + #[inline(always)] + pub fn set_validity_gyro_rate_pitch(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[1..2].store_le(value); + Ok(()) + } + + /// Validity_Gyro_Rate_Yaw + /// + /// Valid when bit is set, invalid when bit is clear. + /// + /// - Min: 0 + /// - Max: 1 + /// - Unit: "" + /// - Receivers: Vector__XXX + #[inline(always)] + pub fn validity_gyro_rate_yaw(&self) -> bool { + self.validity_gyro_rate_yaw_raw() + } + + /// Get raw value of Validity_Gyro_Rate_Yaw + /// + /// - Start bit: 0 + /// - Signal size: 1 bits + /// - Factor: 1 + /// - Offset: 0 + /// - Byte order: LittleEndian + /// - Value type: Unsigned + #[inline(always)] + pub fn validity_gyro_rate_yaw_raw(&self) -> bool { + let signal = self.raw.view_bits::()[0..1].load_le::(); + + signal == 1 + } + + /// Set value of Validity_Gyro_Rate_Yaw + #[inline(always)] + pub fn set_validity_gyro_rate_yaw(&mut self, value: bool) -> Result<(), CanError> { + let value = value as u8; + self.raw.view_bits_mut::()[0..1].store_le(value); + Ok(()) + } + +} + +impl core::convert::TryFrom<&[u8]> for RtSbGyroRates { + type Error = CanError; + + #[inline(always)] + fn try_from(payload: &[u8]) -> Result { + if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); } + let mut raw = [0u8; 8]; + raw.copy_from_slice(&payload[..8]); + Ok(Self { raw }) + } +} + +impl embedded_can::Frame for RtSbGyroRates { + fn new(id: impl Into, data: &[u8]) -> Option { + if id.into() != Self::MESSAGE_ID { + None + } else { + data.try_into().ok() + } + } + + fn new_remote(_id: impl Into, _dlc: usize) -> Option { + unimplemented!() + } + + fn is_extended(&self) -> bool { + match self.id() { + Id::Standard(_) => false, + Id::Extended(_) => true, + } + } + + fn is_remote_frame(&self) -> bool { + false + } + + fn id(&self) -> Id { + Self::MESSAGE_ID + } + + fn dlc(&self) -> usize { + self.raw.len() + } + + fn data(&self) -> &[u8] { + &self.raw + } +} + + +/// This is just to make testing easier +#[allow(dead_code)] +fn main() {} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CanError { + UnknownMessageId(embedded_can::Id), + /// Signal parameter is not within the range + /// defined in the dbc + ParameterOutOfRange { + /// dbc message id + message_id: embedded_can::Id, + }, + InvalidPayloadSize, + /// Multiplexor value not defined in the dbc + InvalidMultiplexor { + /// dbc message id + message_id: embedded_can::Id, + /// Multiplexor value not defined in the dbc + multiplexor: u16, + }, +} + +impl core::fmt::Display for CanError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{self:?}") + } +} + diff --git a/tests-snapshots/dbc-cantools/vehicle.snap.stderr b/tests-snapshots/dbc-cantools/vehicle.snap.stderr new file mode 100644 index 0000000..8a28621 --- /dev/null +++ b/tests-snapshots/dbc-cantools/vehicle.snap.stderr @@ -0,0 +1,85 @@ +error[E0428]: the name `Unused` is defined multiple times + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36025:5 + | +36024 | Unused, + | ------ previous definition of the type `Unused` here +36025 | Unused, + | ^^^^^^ `Unused` redefined here + | + = note: `Unused` must be defined only once in the type namespace of this enum + +error[E0428]: the name `Unused` is defined multiple times + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36026:5 + | +36024 | Unused, + | ------ previous definition of the type `Unused` here +36025 | Unused, +36026 | Unused, + | ^^^^^^ `Unused` redefined here + | + = note: `Unused` must be defined only once in the type namespace of this enum + +error[E0428]: the name `Unused` is defined multiple times + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36027:5 + | +36024 | Unused, + | ------ previous definition of the type `Unused` here +... +36027 | Unused, + | ^^^^^^ `Unused` redefined here + | + = note: `Unused` must be defined only once in the type namespace of this enum + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36044:13 + | +36043 | RtSbGpsStatusGpsStatus::Unused => 9, + | ------------------------------ matches all the relevant values +36044 | RtSbGpsStatusGpsStatus::Unused => 8, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + | + = note: `-D unreachable-patterns` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(unreachable_patterns)]` + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36045:13 + | +36043 | RtSbGpsStatusGpsStatus::Unused => 9, + | ------------------------------ matches all the relevant values +36044 | RtSbGpsStatusGpsStatus::Unused => 8, +36045 | RtSbGpsStatusGpsStatus::Unused => 7, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error: unreachable pattern + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36046:13 + | +36043 | RtSbGpsStatusGpsStatus::Unused => 9, + | ------------------------------ matches all the relevant values +... +36046 | RtSbGpsStatusGpsStatus::Unused => 6, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this + +error[E0004]: non-exhaustive patterns: `RtSbGpsStatusGpsStatus::Unused`, `RtSbGpsStatusGpsStatus::Unused` and `RtSbGpsStatusGpsStatus::Unused` not covered + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36039:15 + | +36039 | match val { + | ^^^ patterns `RtSbGpsStatusGpsStatus::Unused`, `RtSbGpsStatusGpsStatus::Unused` and `RtSbGpsStatusGpsStatus::Unused` not covered + | +note: `RtSbGpsStatusGpsStatus` defined here + --> tests-snapshots/dbc-cantools/vehicle.snap.rs:36020:10 + | +36020 | pub enum RtSbGpsStatusGpsStatus { + | ^^^^^^^^^^^^^^^^^^^^^^ +... +36025 | Unused, + | ------ not covered +36026 | Unused, + | ------ not covered +36027 | Unused, + | ------ not covered + = note: the matched value is of type `RtSbGpsStatusGpsStatus` +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms + | +36053 ~ RtSbGpsStatusGpsStatus::_Other(x) => x, +36054 ~ RtSbGpsStatusGpsStatus::Unused | RtSbGpsStatusGpsStatus::Unused | RtSbGpsStatusGpsStatus::Unused => todo!(), + | diff --git a/tests-snapshots/opendbc/!error___FORD_CADS_64.snap b/tests-snapshots/opendbc/!error___FORD_CADS_64.snap new file mode 100644 index 0000000..b35ad7f --- /dev/null +++ b/tests-snapshots/opendbc/!error___FORD_CADS_64.snap @@ -0,0 +1,4 @@ +--- +source: tests/snapshots.rs +--- +"could not generate Rust code" diff --git a/tests-snapshots/opendbc/!error___mazda_2017.snap b/tests-snapshots/opendbc/!error___mazda_2017.snap new file mode 100644 index 0000000..b35ad7f --- /dev/null +++ b/tests-snapshots/opendbc/!error___mazda_2017.snap @@ -0,0 +1,4 @@ +--- +source: tests/snapshots.rs +--- +"could not generate Rust code" diff --git a/tests-snapshots/opendbc/!error___mazda_3_2019.snap b/tests-snapshots/opendbc/!error___mazda_3_2019.snap new file mode 100644 index 0000000..b35ad7f --- /dev/null +++ b/tests-snapshots/opendbc/!error___mazda_3_2019.snap @@ -0,0 +1,4 @@ +--- +source: tests/snapshots.rs +--- +"could not generate Rust code" diff --git a/tests-snapshots/opendbc/!error___vw_pq.snap b/tests-snapshots/opendbc/!error___vw_pq.snap new file mode 100644 index 0000000..b35ad7f --- /dev/null +++ b/tests-snapshots/opendbc/!error___vw_pq.snap @@ -0,0 +1,4 @@ +--- +source: tests/snapshots.rs +--- +"could not generate Rust code" diff --git a/tests-snapshots/opendbc/generator/hyundai/!error___hyundai_palisade_2023.snap b/tests-snapshots/opendbc/generator/hyundai/!error___hyundai_palisade_2023.snap new file mode 100644 index 0000000..b35ad7f --- /dev/null +++ b/tests-snapshots/opendbc/generator/hyundai/!error___hyundai_palisade_2023.snap @@ -0,0 +1,4 @@ +--- +source: tests/snapshots.rs +--- +"could not generate Rust code" diff --git a/tests/fixtures/opendbc b/tests/fixtures/opendbc new file mode 160000 index 0000000..f8f370b --- /dev/null +++ b/tests/fixtures/opendbc @@ -0,0 +1 @@ +Subproject commit f8f370b3c93f77dc4ee6cada75870b3e00ec02bc diff --git a/tests/fixtures/shared-test-files b/tests/fixtures/shared-test-files new file mode 160000 index 0000000..baea2be --- /dev/null +++ b/tests/fixtures/shared-test-files @@ -0,0 +1 @@ +Subproject commit baea2beee79177892323495a15e1853751bd339d diff --git a/tests/snapshots.rs b/tests/snapshots.rs new file mode 100644 index 0000000..e7aa693 --- /dev/null +++ b/tests/snapshots.rs @@ -0,0 +1,274 @@ +#![cfg(feature = "std")] + +use std::borrow::Cow; +use std::io::{Error, ErrorKind}; +use std::path::{Path, PathBuf}; +use std::{env, fs}; + +use can_dbc::decode_cp1252; +use insta::{assert_binary_snapshot, assert_debug_snapshot, with_settings}; +use test_each_file::test_each_path; +use walkdir::WalkDir; + +struct TestConfig { + test_root: &'static str, + snapshot_suffix: &'static str, + use_cp1251: bool, + create_snapshot: bool, +} + +static TEST_DIRS: &[TestConfig] = &[ + TestConfig { + test_root: "shared-test-files", + snapshot_suffix: "", + use_cp1251: true, + create_snapshot: true, + }, + TestConfig { + test_root: "opendbc/opendbc/dbc", + snapshot_suffix: "opendbc", + use_cp1251: false, + create_snapshot: false, + }, +]; + +test_each_path! { for ["dbc"] in "./tests/fixtures/opendbc/opendbc/dbc" as dbc => parse_one_file } +test_each_path! { for ["dbc"] in "./tests/fixtures/shared-test-files" as shared => parse_one_file } +// upper case extension +test_each_path! { for ["DBC"] in "./tests/fixtures/shared-test-files" as shared2 => parse_one_file } + +struct Test { + config: &'static TestConfig, + path: PathBuf, + file_name: String, +} + +impl Test { + fn new(config: &'static TestConfig, path: PathBuf, file_name: String) -> Self { + Self { + config, + path, + file_name, + } + } + fn decode<'a>(&self, data: &'a [u8]) -> Cow<'a, str> { + if self.config.use_cp1251 { + decode_cp1252(data) + .unwrap_or_else(|| panic!("Cannot decode {} as cp1252", self.path.display())) + } else { + std::str::from_utf8(data) + .unwrap_or_else(|_| panic!("Cannot decode {} as utf-8", self.path.display())) + .into() + } + } + fn snapshot_path(&self, is_error: bool) -> Option { + (if is_error || self.config.create_snapshot { + Some("../tests-snapshots") + } else if env::var("FORCE_INSTA").is_ok() { + Some("../tests-snapshots") // some content is .gitignored + } else { + None + }) + .map(|v| { + PathBuf::from(v) + .join(self.config.snapshot_suffix) + .join(&self.path) + }) + } + fn file_name(&self, is_error: bool) -> String { + if is_error { + format!("!error___{}", self.file_name) + } else { + format!("{}.rs", self.file_name) + } + } +} + +/// Get snapshot path (if snapshot should be created) and a decoding +/// function for a test file path +fn get_test_info(path: &Path) -> Test { + let path_str = path.display().to_string(); + let parent = path.parent().unwrap(); + for item in TEST_DIRS { + // Ensure slashes are there for easier matching + let test_root = format!("/{}/", item.test_root); + let mut path_dir = parent.to_str().unwrap().to_string(); + if !path_dir.ends_with('/') { + path_dir.push('/'); + } + if let Some(pos) = path_dir.find(&test_root) { + let file_name = path.file_stem().unwrap().to_string_lossy().to_string(); + let path = PathBuf::from(&path_dir[pos + test_root.len()..]); + return Test::new(item, path, file_name); + } + } + panic!("Unknown test directory: {path_str}"); +} + +/// Test parsing all DBC files +#[test] +fn test_if_submodules_are_present() { + for test in TEST_DIRS { + let dir = Path::new("./tests/fixtures").join(test.test_root); + fs::read_dir(&dir) + .and_then(|v| { + v.into_iter() + .next() + .map(|_| ()) + .ok_or_else(|| Error::new(ErrorKind::NotFound, "No files or dirs found")) + }) + .unwrap_or_else(|e| { + let dir_display = dir.display(); + panic!( + " +-------------------------------------------------------------------------- +Error reading dbc test files from {dir_display} +{e} +Make sure git submodules are up to date by running + git submodule update --init --recursive +-------------------------------------------------------------------------- +" + ) + }); + } +} + +/// Parse a single DBC file and assert a snapshot of the result. +fn parse_one_file([path]: [&Path; 1]) { + let test = get_test_info(path); + let buffer = fs::read(path).unwrap(); + let buffer = test.decode(&buffer); + + let config = dbc_codegen::Config::builder() + .dbc_name(&test.file_name) + .dbc_content(&buffer) + .build(); + + let mut out = Vec::::new(); + let result = dbc_codegen::codegen(config, &mut out); + let result = result.and_then(|()| String::from_utf8(out).map_err(anyhow::Error::from)); + let is_err = result.is_err(); + + if let Some(snapshot_path) = test.snapshot_path(is_err) { + with_settings! { + { + omit_expression => true, + prepend_module_to_snapshot => false, + snapshot_path => snapshot_path, + }, + { + match result { + Ok(v) => assert_binary_snapshot!(&test.file_name(is_err), v.as_bytes().to_vec()), + Err(e) => assert_debug_snapshot!(test.file_name(is_err), e.to_string()), + } + } + } + } else if let Err(e) = result { + panic!("Failed to parse {}.dbc: {e:#?}", test.file_name); + } +} + +static BAD_TESTS: &[&str] = &[ + // + "bus_comment_bare.snap.rs", + "bus_comment_bare_out.snap.rs", + "choices.snap.rs", + "cp1252.snap.rs", + "empty_choice.snap.rs", + "empty_ns.snap.rs", + "issue_184_extended_mux_cascaded.snap.rs", + "issue_184_extended_mux_cascaded_dumped.snap.rs", + "issue_184_extended_mux_independent_multiplexors.snap.rs", + "issue_184_extended_mux_independent_multiplexors_dumped.snap.rs", + "issue_184_extended_mux_multiple_values.snap.rs", + "issue_184_extended_mux_multiple_values_dumped.snap.rs", + "issue_199.snap.rs", + "issue_199_extended.snap.rs", + "issue_62.snap.rs", + "long_names_multiple_relations.snap.rs", + "long_names_multiple_relations_dumped.snap.rs", + "multiplex_2.snap.rs", + "multiplex_2_dumped.snap.rs", + "padding_bit_order.snap.rs", + "signed.snap.rs", + "vehicle.snap.rs", + // + "FORD_CADS.snap.rs", + "bmw_e9x_e8x.snap.rs", + "cadillac_ct6_object.snap.rs", + "cadillac_ct6_powertrain.snap.rs", + "chrysler_pacifica_2017_hybrid_private_fusion.snap.rs", + "ford_lincoln_base_pt.snap.rs", + "gm_global_a_high_voltage_management.snap.rs", + "gm_global_a_lowspeed.snap.rs", + "gm_global_a_lowspeed_1818125.snap.rs", + "hyundai_2015_ccan.snap.rs", + "hyundai_2015_mcan.snap.rs", + "hyundai_i30_2014.snap.rs", + "hyundai_kia_generic.snap.rs", + "luxgen_s5_2015.snap.rs", + "mercedes_benz_e350_2010.snap.rs", + "psa_aee2010_r3.snap.rs", + "rivian_primary_actuator.snap.rs", + "tesla_can.snap.rs", + "tesla_model3_party.snap.rs", + "tesla_powertrain.snap.rs", + "toyota_iQ_2009_can.snap.rs", + "toyota_prius_2010_pt.snap.rs", + "toyota_radar_dsu_tssp.snap.rs", + "volvo_v40_2017_pt.snap.rs", + "volvo_v60_2015_pt.snap.rs", + "vw_meb.snap.rs", + "vw_mlb.snap.rs", + "vw_mqb.snap.rs", + "vw_mqbevo.snap.rs", + /* generator/chrysler */ "_stellantis_common.snap.rs", + /* generator/gm */ "gm_global_a_powertrain.snap.rs", + /* generator/honda */ "_bosch_2018.snap.rs", + /* generator/honda */ "_bosch_radar_acc.snap.rs", + /* generator/honda */ "_gearbox_common.snap.rs", + /* generator/honda */ "_honda_common.snap.rs", + /* generator/honda */ "_nidec_common.snap.rs", + /* generator/honda */ "_nidec_scm_group_a.snap.rs", + /* generator/honda */ "_nidec_scm_group_b.snap.rs", + /* generator/honda */ "_steering_control_b.snap.rs", + /* generator/honda */ "acura_ilx_2016_can.snap.rs", + /* generator/honda */ "acura_rdx_2020_can.snap.rs", + /* generator/honda */ "honda_civic_hatchback_ex_2017_can.snap.rs", + /* generator/honda */ "honda_common_canfd.snap.rs", + /* generator/honda */ "honda_crv_touring_2016_can.snap.rs", + /* generator/honda */ "honda_odyssey_exl_2018.snap.rs", + /* generator/hyundai */ "hyundai_canfd.snap.rs", + /* generator/nissan */ "_nissan_common.snap.rs", + /* generator/nissan */ "nissan_leaf_2018.snap.rs", + /* generator/nissan */ "nissan_x_trail_2017.snap.rs", + /* generator/subaru */ "_subaru_global.snap.rs", + /* generator/subaru */ "_subaru_preglobal_2015.snap.rs", + /* generator/toyota */ "_toyota_2017.snap.rs", + /* generator/toyota */ "_toyota_adas_standard.snap.rs", + /* generator/toyota */ "toyota_secoc_pt.snap.rs", +]; + +#[test] +fn compile_test() { + env::set_var("CARGO_ENCODED_RUSTFLAGS", "--deny=warnings"); + let t = trybuild::TestCases::new(); + + // Once all tests are fixed, switch to this: + // t.pass("tests-snapshots/**/*.rs"); + + for entry in WalkDir::new("tests-snapshots") + .into_iter() + .filter_map(Result::ok) + { + let path = entry.path(); + if path.extension().and_then(|s| s.to_str()) != Some("rs") { + continue; + } + if BAD_TESTS.iter().any(|bad| path.ends_with(bad)) { + t.compile_fail(path); + } else { + t.pass(path); + } + } +}