rust/va416xx-rs
6
0
Fork 0
Code Issues Pull Requests Projects Releases 5 Wiki Activity

Update SVD files #1

Merged
muellerr merged 8 commits from update-svd-files into main 2024-06-12 10:13:34 +02:00
Conversation 0 Commits 8 Files Changed 599 +28024 -85453
599 changed files with 28024 additions and 85453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
.cargo/def-config.toml
View File

@ -1,39 +1,38 @@
[target.'cfg(all(target_arch = "arm", target_os = "none"))'] [target.'cfg(all(target_arch = "arm", target_os = "none"))']
# uncomment ONE of these three option to make `cargo run` start a GDB session runner = "gdb-multiarch -q -x jlink/jlink.gdb"
# which option to pick depends on your system
# If the RevA board is used, replace jlink.gdb with jlink-reva.gdb
# runner = "arm-none-eabi-gdb -q -x jlink/jlink.gdb"
# runner = "gdb-multiarch -q -x jlink/jlink.gdb"
# runner = "arm-none-eabi-gdb -q -x jlink/jlink-reva.gdb" # runner = "arm-none-eabi-gdb -q -x jlink/jlink-reva.gdb"
# runner = "gdb-multiarch -q -x jlink/jlink-reva.gdb" # runner = "gdb-multiarch -q -x jlink/jlink-reva.gdb"
# Probe-rs is currently problematic, possibly because of the
# ROM protection?
# runner = "probe-rs run --chip-description-path ./scripts/VA416xx_Series.yaml"
# runner = ["probe-rs", "run", "--chip", "$CHIP", "--log-format", "{L} {s}"]
rustflags = [ rustflags = [
"-C",
"link-arg=-Tlink.x",
# "-C",
# "linker=flip-link",
# "-C",
# "link-arg=-Tdefmt.x",
# This is needed if your flash or ram addresses are not aligned to 0x10000 in memory.x # This is needed if your flash or ram addresses are not aligned to 0x10000 in memory.x
# See https://github.com/rust-embedded/cortex-m-quickstart/pull/95 # See https://github.com/rust-embedded/cortex-m-quickstart/pull/95
"-C", "link-arg=--nmagic", "-C",
"link-arg=--nmagic",
# LLD (shipped with the Rust toolchain) is used as the default linker
"-C", "link-arg=-Tlink.x",
# if you run into problems with LLD switch to the GNU linker by commenting out
# this line
# "-C", "linker=arm-none-eabi-ld",
# if you need to link to pre-compiled C libraries provided by a C toolchain
# use GCC as the linker by commenting out both lines above and then
# uncommenting the three lines below
# "-C", "linker=arm-none-eabi-gcc",
# "-C", "link-arg=-Wl,-Tlink.x",
# "-C", "link-arg=-nostartfiles",
] ]
[build] [build]
# Pick ONE of these compilation targets # (`thumbv6m-*` is compatible with all ARM Cortex-M chips but using the right
# target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0+ # target improves performance)
# target = "thumbv7m-none-eabi" # Cortex-M3 # target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0+
# target = "thumbv7em-none-eabi" # Cortex-M4 and Cortex-M7 (no FPU) # target = "thumbv7m-none-eabi" # Cortex-M3
target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU) # target = "thumbv7em-none-eabi" # Cortex-M4 and Cortex-M7 (no FPU)
# target = "thumbv8m.base-none-eabi" # Cortex-M23 target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
# target = "thumbv8m.main-none-eabi" # Cortex-M33 (no FPU)
# target = "thumbv8m.main-none-eabihf" # Cortex-M33 (with FPU) [alias]
rb = "run --bin"
rrb = "run --release --bin"
[env]
DEFMT_LOG = "info"

5
.gitignore vendored
View File

@ -1,6 +1,7 @@
# Generated by Cargo # Generated by Cargo
# will have compiled files and executables # will have compiled files and executables
/target/ /target/
/.vscode
# Ignore user config # Ignore user config
/.cargo/config.toml /.cargo/config.toml
@ -11,7 +12,3 @@ Cargo.lock
# These are backup files generated by rustfmt # These are backup files generated by rustfmt
**/*.rs.bk **/*.rs.bk
/.vscode/.cortex-debug.*
/.vscode/settings.json

2
Cargo.toml
View File

@ -1,5 +1,5 @@
[workspace] [workspace]
resolver = "2"
members = [ members = [
"va416xx", "va416xx",
"va416xx-hal", "va416xx-hal",

27
jlink/JLinkSettings.JLinkScript
View File

@ -14,30 +14,13 @@ Purpose : J-Link target setup file for VORAGO VA416xx
---------------------------END-OF-HEADER------------------------------ ---------------------------END-OF-HEADER------------------------------
*/ */
int DisableRomProt(void) {
JLINK_SYS_Report("VA416XX: Disabling ROM protection");
return JLINK_MEM_WriteU32(0x40010010, 0x1); // ROM_PROT = 0x1
}
int DisableWatchdog(void) {
JLINK_MEM_WriteU32(0x400210C0, 0x1ACCE551); // WDOGLOCK = 0x1ACCE551
JLINK_MEM_WriteU32(0x40021008, 0x0); // WDOGCONTROL = 0x0 (diable)
}
int SetupTarget (void) {
JLINK_SYS_Report("SetupTarget()");
return DisableRomProt(); // ROM_PROT = 0x1
}
/********************************************************************* /*********************************************************************
* *
* AfterResetTarget * AfterResetTarget
*/ */
int AfterResetTarget (void) { int AfterResetTarget (void) {
JLINK_SYS_Report("AfterResetTarget()"); JLINK_SYS_Report("AfterResetTarget()");
// disable watchdog and unlock code RAM for write return JLINK_MEM_WriteU32(0x40010010, 0x1); // ROM_PROT = 0x1
DisableWatchdog();
return DisableRomProt(); // ROM_PROT = 0x1
} }
/********************************************************************* /*********************************************************************
@ -46,7 +29,7 @@ int AfterResetTarget (void) {
*/ */
int BeforeTargetDownload (void) { int BeforeTargetDownload (void) {
JLINK_SYS_Report("BeforeTargetDownload()"); JLINK_SYS_Report("BeforeTargetDownload()");
return DisableRomProt(); // ROM_PROT = 0x1 return JLINK_MEM_WriteU32(0x40010010, 0x1); // ROM_PROT = 0x1
} }
/********************************************************************* /*********************************************************************
@ -55,7 +38,7 @@ int BeforeTargetDownload (void) {
*/ */
int AfterTargetDownload (void) { int AfterTargetDownload (void) {
JLINK_SYS_Report("AfterTargetDownload()"); JLINK_SYS_Report("AfterTargetDownload()");
return DisableRomProt(); // ROM_PROT = 0x0 return JLINK_MEM_WriteU32(0x40010010, 0x0); // ROM_PROT = 0x0
} }
/********************************************************************* /*********************************************************************
@ -64,7 +47,7 @@ int AfterTargetDownload (void) {
*/ */
int HandleBeforeFlashProg(void) { int HandleBeforeFlashProg(void) {
JLINK_SYS_Report("HandleBeforeFlashProg()"); JLINK_SYS_Report("HandleBeforeFlashProg()");
return DisableRomProt(); // ROM_PROT = 0x1 return JLINK_MEM_WriteU32(0x40010010, 0x1); // ROM_PROT = 0x1
} }
/********************************************************************* /*********************************************************************
@ -73,5 +56,5 @@ int HandleBeforeFlashProg(void) {
*/ */
int HandleAfterFlashProg(void) { int HandleAfterFlashProg(void) {
JLINK_SYS_Report("HandleAfterFlashProg()"); JLINK_SYS_Report("HandleAfterFlashProg()");
return DisableRomProt(); // ROM_PROT = 0x0 return JLINK_MEM_WriteU32(0x40010010, 0x0); // ROM_PROT = 0x0
} }

99
scripts/VA416xx_Series.yaml Normal file
View File

@ -0,0 +1,99 @@
name: VA416xx Series
generated_from_pack: true
pack_file_release: 1.0.5
variants:
- name: VA416xx
cores:
- name: main
type: armv7em
core_access_options: !Arm
ap: 0
psel: 0x0
memory_map:
- !Ram
name: IRAM1
range:
start: 0x1fff8000
end: 0x20000000
cores:
- main
- !Nvm
name: IROM1
range:
start: 0x0
end: 0x40000
is_boot_memory: true
cores:
- main
- !Generic
name: IRAM2
range:
start: 0x20000000
end: 0x20008000
cores:
- main
flash_algorithms:
- va416_spi_fram_256kb
# - va416_ebiboot_fram_256kb
# - va416_ebi_fram_512kb
flash_algorithms:
- name: va416_spi_fram_256kb
description: VA416_SPI_FRAM_256KB
instructions: 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
pc_init: 0x49
pc_uninit: 0x1ad
pc_program_page: 0x40d
pc_erase_sector: 0x409
pc_erase_all: 0x27d
data_section_offset: 0x8d8
flash_properties:
address_range:
start: 0x0
end: 0x40000
page_size: 0x100
erased_byte_value: 0x0
program_page_timeout: 3000
erase_sector_timeout: 3000
sectors:
- size: 0x2000
address: 0x0
- name: va416_ebiboot_fram_256kb
description: VA416_EBIBOOT_256KB
instructions: QfKAAsTyAQJS+CAwI/TAQ0PqQTFC+CAQcEcAv0HywALE8gECUvggMCP0wEND6kExQvggEHBHAL9B8gASxPIBAlL4IDAj9MBDQ+pBMUL4IBBwRwC/QfJAEsTyAQJS+CAwI/TAQ0PqQTFC+CAQcEcAv0HyiADE8gEAAmgBIWHzTjICYEJoYfNOMkJggmhh804ygmDCaGHzTjLCYAJpYfNOMgJhQmlh804yQmGCaWHzTjKCYcJpYfNOMsJhAmph804yAmJCamHzTjJCYoJqYfNOMoJiwmph804ywmICa2HzTjICY0JrYfNOMkJjgmth804ygmPCa2HzTjLCYwJsYfNOMgJkQmxh804yQmSCbGHzTjKCZMJsYfNOMsJkAm1h804yAmVCbWHzTjJCZYJtYfNOMoJlwm1h804ywmUCbmHzTjICZkJuYfNOMkJmgm5h804ygmbCbmHzTjLCZgJvYfNOMgJnQm9h804yQmeCb2HzTjKCZ8JvYfNOMsJn0PiAIGHzTjLA+IAg0PiEIGHzTjLA+IQg0PiIIGHzTjLA+Igg0PiMIGHzTjLA+Iwg0PiQIGHzTjLA+JAg0PiUIGHzTjLA+JQg0PiYIGHzTjLA+Jgg0PicIGHzTjLA+Jwg0PioIGHzTjLA+Kgg0PisIGHzTjLA+Kwg0PiwIGHzTjLA+LAg0Pi0IGHzTjLA+LQg0Pi4IGHzTjLA+Lgg0Pi8IGHzTjLA+LwgcEcQtVgkACDE8gEEw/Y5QGBgIGhA9IAwIGD/9xj/T/YAccDytjEAIGFhEL0AvwAgcEeAtU/wwEBP9IAhAPA7+AAggL0AvwAgcEcB8AEDGURLCCnQWR4A8cBAAykD8AMME9Mj8AMDMvgIGwQ7IPgIGzL4Bhwg+AYcMvgEHCD4BBwy+AIcIPgCHO3RvPEADwvQEYi88QEPAYAG0FGIvPECD0GAHL+RiIGAACBwRwC/ACBwRwhEcEdP8AACALUTRpRGlkYgOSK/oOgMUKDoDFCx8SABv/T3rwkHKL+g6AxQSL8MwF34BOuJACi/QPgEKwi/cEdIvyD4AisR8IBPGL8A+AErcEcAAAAAAAA=
pc_init: 0x225
pc_uninit: 0x251
pc_program_page: 0x26d
pc_erase_sector: 0x269
pc_erase_all: 0x255
data_section_offset: 0x328
flash_properties:
address_range:
start: 0x0
end: 0x40000
page_size: 0x100
erased_byte_value: 0x0
program_page_timeout: 3000
erase_sector_timeout: 3000
sectors:
- size: 0x2000
address: 0x0
- name: va416_ebi_fram_512kb
description: VA416_EBI_512KB
instructions: QfKAAsTyAQJS+CAwI/TAQ0PqQTFC+CAQcEcAv0HywALE8gECUvggMCP0wEND6kExQvggEHBHAL9B8gASxPIBAlL4IDAj9MBDQ+pBMUL4IBBwRwC/QfJAEsTyAQJS+CAwI/TAQ0PqQTFC+CAQcEcAv0HyiADE8gEAAmgBIWHzTjICYEJoYfNOMkJggmhh804ygmDCaGHzTjLCYAJpYfNOMgJhQmlh804yQmGCaWHzTjKCYcJpYfNOMsJhAmph804yAmJCamHzTjJCYoJqYfNOMoJiwmph804ywmICa2HzTjICY0JrYfNOMkJjgmth804ygmPCa2HzTjLCYwJsYfNOMgJkQmxh804yQmSCbGHzTjKCZMJsYfNOMsJkAm1h804yAmVCbWHzTjJCZYJtYfNOMoJlwm1h804ywmUCbmHzTjICZkJuYfNOMkJmgm5h804ygmbCbmHzTjLCZgJvYfNOMgJnQm9h804yQmeCb2HzTjKCZ8JvYfNOMsJn0PiAIGHzTjLA+IAg0PiEIGHzTjLA+IQg0PiIIGHzTjLA+Igg0PiMIGHzTjLA+Iwg0PiQIGHzTjLA+JAg0PiUIGHzTjLA+JQg0PiYIGHzTjLA+Jgg0PicIGHzTjLA+Jwg0PioIGHzTjLA+Kgg0PisIGHzTjLA+Kwg0PiwIGHzTjLA+LAg0Pi0IGHzTjLA+LQg0Pi4IGHzTjLA+Lgg0Pi8IGHzTjLA+LwgcEcQtVgkxPIBBCBoQPSAMCBgACDD9jlAYGD/9xj/T/YAcMDytjBgYU7yhBDO8gAAT/QAUQFgRvIAAb/zT4/E8gABGCC/82+PiGAwIgAgCmAQvQAgcEeAtU/wgFBP9AAhAPB4+AAggL0AvwAgcEcB8AEDGURLCCfQWR4DKQPwAwwT0yPwAwMy+AgbBDsg+AgbMvgGHCD4Bhwy+AQcIPgEHDL4Ahwg+AIc7dG88QAPC9ARiLzxAQ8BgAbQUYi88QIPQYAcv5GIgYAAIHBHAL8AIHBHLenwRQHwAQMZRF/qUQwr0OJGvPEBD5i/T/ABCsrxAA6q8QEIACMw+BNQMvgTYLVCItGYRRjQAutDBQDrQwZ3iGyIp0IT0Q7rAwe8HAzQtIipiIxCDdH5HAbQ8YjsiKFCCdEEM5pF3tFgRL3o8IUBMwLgAjMA4AMzT+pDDGBEvejwhU/wAAIAtRNGlEaWRiA5Ir+g6AxQoOgMULHxIAG/9PevCQcov6DoDFBIvwzAXfgE64kAKL9A+AQrCL9wR0i/IPgCKxHwgE8YvwD4AStwRwAAAAA=
pc_init: 0x225
pc_uninit: 0x275
pc_program_page: 0x291
pc_erase_sector: 0x28d
pc_erase_all: 0x279
data_section_offset: 0x3c4
flash_properties:
address_range:
start: 0x10000000
end: 0x10080000
page_size: 0x100
erased_byte_value: 0x0
program_page_timeout: 3000
erase_sector_timeout: 3000
sectors:
- size: 0x2000
address: 0x0

15
va416xx-hal/Cargo.toml
View File

@ -12,7 +12,7 @@ categories = ["embedded", "no-std", "hardware-support"]
[dependencies] [dependencies]
cortex-m = "0.7" cortex-m = "0.7"
cortex-m-rt = "0.7.1" cortex-m-rt = "0.7"
nb = "1" nb = "1"
[dependencies.va416xx] [dependencies.va416xx]
@ -23,14 +23,7 @@ version = "0.1.0"
rt = ["va416xx/rt"] rt = ["va416xx/rt"]
[dev-dependencies] [dev-dependencies]
panic-rtt-target = { version = "0.1", features = ["cortex-m"] } panic-rtt-target = { version = "0.1.3" }
rtt-target = { version = "0.3", features = ["cortex-m"] } rtt-target = { version = "0.5" }
panic-halt = "0.2" panic-halt = "0.2"
cortex-m = { version = "0.7.6", features = ["critical-section-single-core"]}
[profile.dev]
debug = true
lto = false
[profile.release]
lto = true
debug = true

33
va416xx-hal/examples/blinky.rs
View File

@ -2,7 +2,7 @@
#![no_main] #![no_main]
#![no_std] #![no_std]
use cortex_m_rt::{entry}; use cortex_m_rt::entry;
use panic_halt as _; use panic_halt as _;
use va416xx_hal::pac; use va416xx_hal::pac;
@ -11,27 +11,24 @@ const LED_PG5: u32 = 1 << 5;
#[entry] #[entry]
fn main() -> ! { fn main() -> ! {
let dp = pac::Peripherals::take().unwrap(); // SAFETY: Peripherals are only stolen once here.
let dp = unsafe { pac::Peripherals::steal() };
// Enable all peripheral clocks // Enable all peripheral clocks
dp.SYSCONFIG dp.sysconfig
.peripheral_clk_enable .peripheral_clk_enable()
.modify(|_, w| unsafe { w.bits(0xffffffff) }); .modify(|_, w| unsafe { w.bits(0xffffffff) });
dp.PORTG.dir().modify(|_, w| unsafe { w.bits(LED_PG5) }); dp.portg.dir().modify(|_, w| unsafe { w.bits(LED_PG5) });
dp.PORTG.datamask().modify(|_, w| unsafe { w.bits(LED_PG5)}); dp.portg
.datamask()
.modify(|_, w| unsafe { w.bits(LED_PG5) });
for _ in 0..10 { for _ in 0..10 {
dp.PORTG dp.portg.clrout().write(|w| unsafe { w.bits(LED_PG5) });
.clrout() cortex_m::asm::delay(2_000_000);
.write(|w| unsafe { w.bits(LED_PG5) }); dp.portg.setout().write(|w| unsafe { w.bits(LED_PG5) });
cortex_m::asm::delay(5_000_000); cortex_m::asm::delay(2_000_000);
dp.PORTG
.setout()
.write(|w| unsafe { w.bits(LED_PG5) });
cortex_m::asm::delay(5_000_000);
} }
loop { loop {
dp.PORTG dp.portg.togout().write(|w| unsafe { w.bits(LED_PG5) });
.togout() cortex_m::asm::delay(2_000_000);
.write(|w| unsafe { w.bits(LED_PG5) });
cortex_m::asm::delay(25_000_000);
} }
} }

24
va416xx-hal/examples/rtt-log.rs
View File

@ -1,20 +1,38 @@
//! Code to test RTT logger functionality //! Code to test RTT logger functionality.
#![no_main] #![no_main]
#![no_std] #![no_std]
use cortex_m_rt::entry; use cortex_m_rt::entry;
use panic_halt as _; use panic_rtt_target as _;
use rtt_target::{rprintln, rtt_init_print}; use rtt_target::{rprintln, rtt_init_print};
use va416xx as _; use va416xx as _;
use va416xx_hal::pac;
// Mask for the LED
const LED_PG5: u32 = 1 << 5;
#[entry] #[entry]
fn main() -> ! { fn main() -> ! {
// SAFETY: Peripherals are only stolen once here.
let dp = unsafe { pac::Peripherals::steal() };
// Enable all peripheral clocks
dp.sysconfig
.peripheral_clk_enable()
.modify(|_, w| unsafe { w.bits(0xffffffff) });
dp.portg.dir().modify(|_, w| unsafe { w.bits(LED_PG5) });
dp.portg
.datamask()
.modify(|_, w| unsafe { w.bits(LED_PG5) });
rtt_init_print!(); rtt_init_print!();
rprintln!("-- RTT Demo --"); rprintln!("-- RTT Demo --");
let mut counter = 0; let mut counter = 0;
loop { loop {
rprintln!("{}: Hello, world!", counter); rprintln!("{}: Hello, world!", counter);
// Still toggle LED. If there are issues with the RTT log, the LED
// blinking ensures that the application is actually running.
dp.portg.togout().write(|w| unsafe { w.bits(LED_PG5) });
counter += 1; counter += 1;
cortex_m::asm::delay(75_000_000); cortex_m::asm::delay(10_000_000);
} }
} }

14
va416xx-hal/src/clock.rs
View File

@ -1,7 +1,5 @@
//! # API for clock related functionality
//!
//! This also includes functionality to enable the peripheral clocks //! This also includes functionality to enable the peripheral clocks
use va416xx::SYSCONFIG; use va416xx::Sysconfig;
#[derive(Copy, Clone, PartialEq)] #[derive(Copy, Clone, PartialEq)]
pub enum PeripheralSelect { pub enum PeripheralSelect {
@ -35,17 +33,17 @@ pub enum PeripheralSelect {
PortD = 27, PortD = 27,
PortE = 28, PortE = 28,
PortF = 29, PortF = 29,
PortG = 30 PortG = 30,
} }
pub fn enable_peripheral_clock(syscfg: &mut SYSCONFIG, clock: PeripheralSelect) { pub fn enable_peripheral_clock(syscfg: &mut Sysconfig, clock: PeripheralSelect) {
syscfg syscfg
.peripheral_clk_enable .peripheral_clk_enable()
.modify(|r, w| unsafe { w.bits(r.bits() | (1 << clock as u8)) }); .modify(|r, w| unsafe { w.bits(r.bits() | (1 << clock as u8)) });
} }
pub fn disable_peripheral_clock(syscfg: &mut SYSCONFIG, clock: PeripheralSelect) { pub fn disable_peripheral_clock(syscfg: &mut Sysconfig, clock: PeripheralSelect) {
syscfg syscfg
.peripheral_clk_enable .peripheral_clk_enable()
.modify(|r, w| unsafe { w.bits(r.bits() & !(1 << clock as u8)) }); .modify(|r, w| unsafe { w.bits(r.bits() & !(1 << clock as u8)) });
} }

36
va416xx/README.md
View File

@ -21,9 +21,39 @@ features = ["rt"]
The `rt` feature is optional and recommended. It brings in support for `cortex-m-rt`. The `rt` feature is optional and recommended. It brings in support for `cortex-m-rt`.
For full details on the autgenerated API, please see the For full details on the autgenerated API, you can read the
[svd2rust documentation](https://docs.rs/svd2rust/0.19.0/svd2rust/#peripheral-api). [svd2rust documentation](https://docs.rs/svd2rust/latest/svd2rust/).
## Regenerating the PAC ## Regenerating the PAC
You can regenerate the PAC by running the `gen-helper.sh` helper script. If you want to re-generate the PAC, for example if the register file `va416xx.svd` changes
or the `svd2rust` version is updated, you can do some using the following these steps:
1. Make sure all necessary tools are installed: [`svd2rust`](https://docs.rs/svd2rust/latest/svd2rust/),
[`svdtools`](https://github.com/rust-embedded/svdtools) and [`form`](https://crates.io/crates/form).
You can install all tools with `cargo`:
```sh
cargo install --locked svd2rust svdtools form
```
2. Patch the vendor-provided SVD file `svd/va41xx.svd`. This can be done using `svdtools` in
conjunction with the `svd/va416xx-patch.yml` file.
```sh
svdtools patch svd/va416xx-patch.yml
```
3. Use `svd2rust` to generate the Rust library
```sh
svd2rust -i svd/va416xx.svd.patched
```
4. Use the `form` tool to split the generated `lib.rs` into individual modules.
```sh
form -i lib.rs -o src/
```
The `gen-helper.sh` automates steps 2-4.

1
va416xx/build.rs
View File

@ -1,3 +1,4 @@
#![doc = r" Builder file for Peripheral access crate generated by svd2rust tool"]
use std::env; use std::env;
use std::fs::File; use std::fs::File;
use std::io::Write; use std::io::Write;

6
va416xx/device.x
View File

@ -34,16 +34,16 @@ PROVIDE(I2C1_MS = DefaultHandler);
PROVIDE(I2C1_SL = DefaultHandler); PROVIDE(I2C1_SL = DefaultHandler);
PROVIDE(I2C2_MS = DefaultHandler); PROVIDE(I2C2_MS = DefaultHandler);
PROVIDE(I2C2_SL = DefaultHandler); PROVIDE(I2C2_SL = DefaultHandler);
PROVIDE(ETHERNET = DefaultHandler); PROVIDE(Ethernet = DefaultHandler);
PROVIDE(U37 = DefaultHandler); PROVIDE(U37 = DefaultHandler);
PROVIDE(SPW = DefaultHandler); PROVIDE(SpW = DefaultHandler);
PROVIDE(U39 = DefaultHandler); PROVIDE(U39 = DefaultHandler);
PROVIDE(DAC0 = DefaultHandler); PROVIDE(DAC0 = DefaultHandler);
PROVIDE(DAC1 = DefaultHandler); PROVIDE(DAC1 = DefaultHandler);
PROVIDE(TRNG = DefaultHandler); PROVIDE(TRNG = DefaultHandler);
PROVIDE(DMA_ERROR = DefaultHandler); PROVIDE(DMA_ERROR = DefaultHandler);
PROVIDE(ADC = DefaultHandler); PROVIDE(ADC = DefaultHandler);
PROVIDE(LOCLK = DefaultHandler); PROVIDE(LoCLK = DefaultHandler);
PROVIDE(LVD = DefaultHandler); PROVIDE(LVD = DefaultHandler);
PROVIDE(WATCHDOG = DefaultHandler); PROVIDE(WATCHDOG = DefaultHandler);
PROVIDE(TIM0 = DefaultHandler); PROVIDE(TIM0 = DefaultHandler);

23
va416xx/gen-helper.sh
View File

@ -15,7 +15,28 @@ if [ -x "$(${svd2rust_bin} --version)" ]; then
"Install it with cargo install svd2rust" "Install it with cargo install svd2rust"
exit exit
fi fi
${svd2rust_bin} -i svd/va416xx-base.svd
if ! command -v form &> /dev/null
then
echo "form tool was not found"
exit 1
fi
if ! command -v svdtools &> /dev/null
then
echo "svdtools was not found"
exit 1
fi
svdtools patch svd/va416xx-patch.yml
${svd2rust_bin} -i svd/va416xx.svd.patched
result=$?
if [ $result -ne 0 ]; then
echo "svd2rust failed with code $result"
exit
fi
rm -rf src rm -rf src
form -i lib.rs -o src/ && rm lib.rs form -i lib.rs -o src/ && rm lib.rs
cargo fmt cargo fmt

144
va416xx/src/adc.rs
View File

@ -1,65 +1,127 @@
#[doc = r"Register block"]
#[repr(C)] #[repr(C)]
#[doc = "Register block"]
pub struct RegisterBlock { pub struct RegisterBlock {
#[doc = "0x00 - Control Register"] ctrl: Ctrl,
pub ctrl: crate::Reg<ctrl::CTRL_SPEC>, fifo_data: FifoData,
#[doc = "0x04 - FIFO data"] status: Status,
pub fifo_data: crate::Reg<fifo_data::FIFO_DATA_SPEC>, irq_enb: IrqEnb,
#[doc = "0x08 - Status"] irq_raw: IrqRaw,
pub status: crate::Reg<status::STATUS_SPEC>, irq_end: IrqEnd,
#[doc = "0x0c - Interrupt Enable"] irq_clr: IrqClr,
pub irq_enb: crate::Reg<irq_enb::IRQ_ENB_SPEC>, rxfifoirqtrg: Rxfifoirqtrg,
#[doc = "0x10 - Raw Interrupt Status"] fifo_clr: FifoClr,
pub irq_raw: crate::Reg<irq_raw::IRQ_RAW_SPEC>,
#[doc = "0x14 - Enabled Interrupt Status"]
pub irq_end: crate::Reg<irq_end::IRQ_END_SPEC>,
#[doc = "0x18 - Clear Interrupt"]
pub irq_clr: crate::Reg<irq_clr::IRQ_CLR_SPEC>,
#[doc = "0x1c - Receive FIFO Interrupt Trigger Value"]
pub rxfifoirqtrg: crate::Reg<rxfifoirqtrg::RXFIFOIRQTRG_SPEC>,
#[doc = "0x20 - FIFO Clear"]
pub fifo_clr: crate::Reg<fifo_clr::FIFO_CLR_SPEC>,
_reserved9: [u8; 0x0fd8], _reserved9: [u8; 0x0fd8],
#[doc = "0xffc - Peripheral ID Register"] perid: Perid,
pub perid: crate::Reg<perid::PERID_SPEC>,
} }
#[doc = "CTRL register accessor: an alias for `Reg<CTRL_SPEC>`"] impl RegisterBlock {
pub type CTRL = crate::Reg<ctrl::CTRL_SPEC>; #[doc = "0x00 - Control Register"]
#[inline(always)]
pub const fn ctrl(&self) -> &Ctrl {
&self.ctrl
}
#[doc = "0x04 - FIFO data"]
#[inline(always)]
pub const fn fifo_data(&self) -> &FifoData {
&self.fifo_data
}
#[doc = "0x08 - Status"]
#[inline(always)]
pub const fn status(&self) -> &Status {
&self.status
}
#[doc = "0x0c - Interrupt Enable"]
#[inline(always)]
pub const fn irq_enb(&self) -> &IrqEnb {
&self.irq_enb
}
#[doc = "0x10 - Raw Interrupt Status"]
#[inline(always)]
pub const fn irq_raw(&self) -> &IrqRaw {
&self.irq_raw
}
#[doc = "0x14 - Enabled Interrupt Status"]
#[inline(always)]
pub const fn irq_end(&self) -> &IrqEnd {
&self.irq_end
}
#[doc = "0x18 - Clear Interrupt"]
#[inline(always)]
pub const fn irq_clr(&self) -> &IrqClr {
&self.irq_clr
}
#[doc = "0x1c - Receive FIFO Interrupt Trigger Value"]
#[inline(always)]
pub const fn rxfifoirqtrg(&self) -> &Rxfifoirqtrg {
&self.rxfifoirqtrg
}
#[doc = "0x20 - FIFO Clear"]
#[inline(always)]
pub const fn fifo_clr(&self) -> &FifoClr {
&self.fifo_clr
}
#[doc = "0xffc - Peripheral ID Register"]
#[inline(always)]
pub const fn perid(&self) -> &Perid {
&self.perid
}
}
#[doc = "CTRL (rw) register accessor: Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctrl::R`]. You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctrl::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@ctrl`]
module"]
#[doc(alias = "CTRL")]
pub type Ctrl = crate::Reg<ctrl::CtrlSpec>;
#[doc = "Control Register"] #[doc = "Control Register"]
pub mod ctrl; pub mod ctrl;
#[doc = "FIFO_DATA register accessor: an alias for `Reg<FIFO_DATA_SPEC>`"] #[doc = "FIFO_DATA (r) register accessor: FIFO data\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_data::R`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@fifo_data`]
pub type FIFO_DATA = crate::Reg<fifo_data::FIFO_DATA_SPEC>; module"]
#[doc(alias = "FIFO_DATA")]
pub type FifoData = crate::Reg<fifo_data::FifoDataSpec>;
#[doc = "FIFO data"] #[doc = "FIFO data"]
pub mod fifo_data; pub mod fifo_data;
#[doc = "STATUS register accessor: an alias for `Reg<STATUS_SPEC>`"] #[doc = "STATUS (r) register accessor: Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`status::R`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@status`]
pub type STATUS = crate::Reg<status::STATUS_SPEC>; module"]
#[doc(alias = "STATUS")]
pub type Status = crate::Reg<status::StatusSpec>;
#[doc = "Status"] #[doc = "Status"]
pub mod status; pub mod status;
#[doc = "IRQ_ENB register accessor: an alias for `Reg<IRQ_ENB_SPEC>`"] #[doc = "IRQ_ENB (rw) register accessor: Interrupt Enable\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_enb::R`]. You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_enb::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_enb`]
pub type IRQ_ENB = crate::Reg<irq_enb::IRQ_ENB_SPEC>; module"]
#[doc(alias = "IRQ_ENB")]
pub type IrqEnb = crate::Reg<irq_enb::IrqEnbSpec>;
#[doc = "Interrupt Enable"] #[doc = "Interrupt Enable"]
pub mod irq_enb; pub mod irq_enb;
#[doc = "IRQ_RAW register accessor: an alias for `Reg<IRQ_RAW_SPEC>`"] #[doc = "IRQ_RAW (r) register accessor: Raw Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_raw::R`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_raw`]
pub type IRQ_RAW = crate::Reg<irq_raw::IRQ_RAW_SPEC>; module"]
#[doc(alias = "IRQ_RAW")]
pub type IrqRaw = crate::Reg<irq_raw::IrqRawSpec>;
#[doc = "Raw Interrupt Status"] #[doc = "Raw Interrupt Status"]
pub mod irq_raw; pub mod irq_raw;
#[doc = "IRQ_END register accessor: an alias for `Reg<IRQ_END_SPEC>`"] #[doc = "IRQ_END (r) register accessor: Enabled Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_end::R`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_end`]
pub type IRQ_END = crate::Reg<irq_end::IRQ_END_SPEC>; module"]
#[doc(alias = "IRQ_END")]
pub type IrqEnd = crate::Reg<irq_end::IrqEndSpec>;
#[doc = "Enabled Interrupt Status"] #[doc = "Enabled Interrupt Status"]
pub mod irq_end; pub mod irq_end;
#[doc = "IRQ_CLR register accessor: an alias for `Reg<IRQ_CLR_SPEC>`"] #[doc = "IRQ_CLR (w) register accessor: Clear Interrupt\n\nYou can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_clr::W`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@irq_clr`]
pub type IRQ_CLR = crate::Reg<irq_clr::IRQ_CLR_SPEC>; module"]
#[doc(alias = "IRQ_CLR")]
pub type IrqClr = crate::Reg<irq_clr::IrqClrSpec>;
#[doc = "Clear Interrupt"] #[doc = "Clear Interrupt"]
pub mod irq_clr; pub mod irq_clr;
#[doc = "RXFIFOIRQTRG register accessor: an alias for `Reg<RXFIFOIRQTRG_SPEC>`"] #[doc = "RXFIFOIRQTRG (rw) register accessor: Receive FIFO Interrupt Trigger Value\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`rxfifoirqtrg::R`]. You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`rxfifoirqtrg::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@rxfifoirqtrg`]
pub type RXFIFOIRQTRG = crate::Reg<rxfifoirqtrg::RXFIFOIRQTRG_SPEC>; module"]
#[doc(alias = "RXFIFOIRQTRG")]
pub type Rxfifoirqtrg = crate::Reg<rxfifoirqtrg::RxfifoirqtrgSpec>;
#[doc = "Receive FIFO Interrupt Trigger Value"] #[doc = "Receive FIFO Interrupt Trigger Value"]
pub mod rxfifoirqtrg; pub mod rxfifoirqtrg;
#[doc = "FIFO_CLR register accessor: an alias for `Reg<FIFO_CLR_SPEC>`"] #[doc = "FIFO_CLR (rw) register accessor: FIFO Clear\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_clr::R`]. You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`fifo_clr::W`]. You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@fifo_clr`]
pub type FIFO_CLR = crate::Reg<fifo_clr::FIFO_CLR_SPEC>; module"]
#[doc(alias = "FIFO_CLR")]
pub type FifoClr = crate::Reg<fifo_clr::FifoClrSpec>;
#[doc = "FIFO Clear"] #[doc = "FIFO Clear"]
pub mod fifo_clr; pub mod fifo_clr;
#[doc = "PERID register accessor: an alias for `Reg<PERID_SPEC>`"] #[doc = "PERID (r) register accessor: Peripheral ID Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`perid::R`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`mod@perid`]
pub type PERID = crate::Reg<perid::PERID_SPEC>; module"]
#[doc(alias = "PERID")]
pub type Perid = crate::Reg<perid::PeridSpec>;
#[doc = "Peripheral ID Register"] #[doc = "Peripheral ID Register"]
pub mod perid; pub mod perid;

385
va416xx/src/adc/ctrl.rs
View File

@ -1,328 +1,115 @@
#[doc = "Register `CTRL` reader"] #[doc = "Register `CTRL` reader"]
pub struct R(crate::R<CTRL_SPEC>); pub type R = crate::R<CtrlSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CTRL_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CTRL_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CTRL_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CTRL` writer"] #[doc = "Register `CTRL` writer"]
pub struct W(crate::W<CTRL_SPEC>); pub type W = crate::W<CtrlSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CTRL_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CTRL_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CTRL_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `CONV_CNT` reader - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
pub struct CONV_CNT_R(crate::FieldReader<u8, u8>);
impl CONV_CNT_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
CONV_CNT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CONV_CNT_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CONV_CNT` writer - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
pub struct CONV_CNT_W<'a> {
w: &'a mut W,
}
impl<'a> CONV_CNT_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 20)) | ((value as u32 & 0x0f) << 20);
self.w
}
}
#[doc = "Field `MANUAL_TRIG` reader - Starts analog acquisition"]
pub struct MANUAL_TRIG_R(crate::FieldReader<bool, bool>);
impl MANUAL_TRIG_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
MANUAL_TRIG_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for MANUAL_TRIG_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `MANUAL_TRIG` writer - Starts analog acquisition"]
pub struct MANUAL_TRIG_W<'a> {
w: &'a mut W,
}
impl<'a> MANUAL_TRIG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
self.w
}
}
#[doc = "Field `EXT_TRIG_EN` reader - Allows the external trigger to start analog acquisition"]
pub struct EXT_TRIG_EN_R(crate::FieldReader<bool, bool>);
impl EXT_TRIG_EN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
EXT_TRIG_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EXT_TRIG_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EXT_TRIG_EN` writer - Allows the external trigger to start analog acquisition"]
pub struct EXT_TRIG_EN_W<'a> {
w: &'a mut W,
}
impl<'a> EXT_TRIG_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
self.w
}
}
#[doc = "Field `SWEEP_EN` reader - ADC data acquisition for all enabled channel"]
pub struct SWEEP_EN_R(crate::FieldReader<bool, bool>);
impl SWEEP_EN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
SWEEP_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SWEEP_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SWEEP_EN` writer - ADC data acquisition for all enabled channel"]
pub struct SWEEP_EN_W<'a> {
w: &'a mut W,
}
impl<'a> SWEEP_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
self.w
}
}
#[doc = "Field `CHAN_TAG_EN` reader - Enables the channel tag to be saved with the ADC data"]
pub struct CHAN_TAG_EN_R(crate::FieldReader<bool, bool>);
impl CHAN_TAG_EN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
CHAN_TAG_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CHAN_TAG_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CHAN_TAG_EN` writer - Enables the channel tag to be saved with the ADC data"]
pub struct CHAN_TAG_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CHAN_TAG_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
self.w
}
}
#[doc = "Field `CHAN_EN` reader - Enables the channel for data collection"] #[doc = "Field `CHAN_EN` reader - Enables the channel for data collection"]
pub struct CHAN_EN_R(crate::FieldReader<u16, u16>); pub type ChanEnR = crate::FieldReader<u16>;
impl CHAN_EN_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
CHAN_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CHAN_EN_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CHAN_EN` writer - Enables the channel for data collection"] #[doc = "Field `CHAN_EN` writer - Enables the channel for data collection"]
pub struct CHAN_EN_W<'a> { pub type ChanEnW<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
w: &'a mut W, #[doc = "Field `CHAN_TAG_EN` reader - Enables the channel tag to be saved with the ADC data"]
} pub type ChanTagEnR = crate::BitReader;
impl<'a> CHAN_EN_W<'a> { #[doc = "Field `CHAN_TAG_EN` writer - Enables the channel tag to be saved with the ADC data"]
#[doc = r"Writes raw bits to the field"] pub type ChanTagEnW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)] #[doc = "Field `SWEEP_EN` reader - ADC data acquisition for all enabled channel"]
pub unsafe fn bits(self, value: u16) -> &'a mut W { pub type SweepEnR = crate::BitReader;
self.w.bits = (self.w.bits & !0xffff) | (value as u32 & 0xffff); #[doc = "Field `SWEEP_EN` writer - ADC data acquisition for all enabled channel"]
self.w pub type SweepEnW<'a, REG> = crate::BitWriter<'a, REG>;
} #[doc = "Field `EXT_TRIG_EN` reader - Allows the external trigger to start analog acquisition"]
} pub type ExtTrigEnR = crate::BitReader;
#[doc = "Field `EXT_TRIG_EN` writer - Allows the external trigger to start analog acquisition"]
pub type ExtTrigEnW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `MANUAL_TRIG` reader - Starts analog acquisition"]
pub type ManualTrigR = crate::BitReader;
#[doc = "Field `MANUAL_TRIG` writer - Starts analog acquisition"]
pub type ManualTrigW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `CONV_CNT` reader - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
pub type ConvCntR = crate::FieldReader;
#[doc = "Field `CONV_CNT` writer - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
pub type ConvCntW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R { impl R {
#[doc = "Bits 20:23 - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"] #[doc = "Bits 0:15 - Enables the channel for data collection"]
#[inline(always)] #[inline(always)]
pub fn conv_cnt(&self) -> CONV_CNT_R { pub fn chan_en(&self) -> ChanEnR {
CONV_CNT_R::new(((self.bits >> 20) & 0x0f) as u8) ChanEnR::new((self.bits & 0xffff) as u16)
}
#[doc = "Bit 19 - Starts analog acquisition"]
#[inline(always)]
pub fn manual_trig(&self) -> MANUAL_TRIG_R {
MANUAL_TRIG_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
#[inline(always)]
pub fn ext_trig_en(&self) -> EXT_TRIG_EN_R {
EXT_TRIG_EN_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
#[inline(always)]
pub fn sweep_en(&self) -> SWEEP_EN_R {
SWEEP_EN_R::new(((self.bits >> 17) & 0x01) != 0)
} }
#[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"] #[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
#[inline(always)] #[inline(always)]
pub fn chan_tag_en(&self) -> CHAN_TAG_EN_R { pub fn chan_tag_en(&self) -> ChanTagEnR {
CHAN_TAG_EN_R::new(((self.bits >> 16) & 0x01) != 0) ChanTagEnR::new(((self.bits >> 16) & 1) != 0)
} }
#[doc = "Bits 0:15 - Enables the channel for data collection"] #[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
#[inline(always)] #[inline(always)]
pub fn chan_en(&self) -> CHAN_EN_R { pub fn sweep_en(&self) -> SweepEnR {
CHAN_EN_R::new((self.bits & 0xffff) as u16) SweepEnR::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
#[inline(always)]
pub fn ext_trig_en(&self) -> ExtTrigEnR {
ExtTrigEnR::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - Starts analog acquisition"]
#[inline(always)]
pub fn manual_trig(&self) -> ManualTrigR {
ManualTrigR::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bits 20:23 - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
#[inline(always)]
pub fn conv_cnt(&self) -> ConvCntR {
ConvCntR::new(((self.bits >> 20) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 20:23 - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"] #[doc = "Bits 0:15 - Enables the channel for data collection"]
#[inline(always)] #[inline(always)]
pub fn conv_cnt(&mut self) -> CONV_CNT_W { #[must_use]
CONV_CNT_W { w: self } pub fn chan_en(&mut self) -> ChanEnW<CtrlSpec> {
} ChanEnW::new(self, 0)
#[doc = "Bit 19 - Starts analog acquisition"]
#[inline(always)]
pub fn manual_trig(&mut self) -> MANUAL_TRIG_W {
MANUAL_TRIG_W { w: self }
}
#[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
#[inline(always)]
pub fn ext_trig_en(&mut self) -> EXT_TRIG_EN_W {
EXT_TRIG_EN_W { w: self }
}
#[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
#[inline(always)]
pub fn sweep_en(&mut self) -> SWEEP_EN_W {
SWEEP_EN_W { w: self }
} }
#[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"] #[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
#[inline(always)] #[inline(always)]
pub fn chan_tag_en(&mut self) -> CHAN_TAG_EN_W { #[must_use]
CHAN_TAG_EN_W { w: self } pub fn chan_tag_en(&mut self) -> ChanTagEnW<CtrlSpec> {
ChanTagEnW::new(self, 16)
} }
#[doc = "Bits 0:15 - Enables the channel for data collection"] #[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
#[inline(always)] #[inline(always)]
pub fn chan_en(&mut self) -> CHAN_EN_W { #[must_use]
CHAN_EN_W { w: self } pub fn sweep_en(&mut self) -> SweepEnW<CtrlSpec> {
SweepEnW::new(self, 17)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn ext_trig_en(&mut self) -> ExtTrigEnW<CtrlSpec> {
self ExtTrigEnW::new(self, 18)
}
#[doc = "Bit 19 - Starts analog acquisition"]
#[inline(always)]
#[must_use]
pub fn manual_trig(&mut self) -> ManualTrigW<CtrlSpec> {
ManualTrigW::new(self, 19)
}
#[doc = "Bits 20:23 - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
#[inline(always)]
#[must_use]
pub fn conv_cnt(&mut self) -> ConvCntW<CtrlSpec> {
ConvCntW::new(self, 20)
} }
} }
#[doc = "Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ctrl](index.html) module"] #[doc = "Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctrl::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctrl::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CTRL_SPEC; pub struct CtrlSpec;
impl crate::RegisterSpec for CTRL_SPEC { impl crate::RegisterSpec for CtrlSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [ctrl::R](R) reader structure"] #[doc = "`read()` method returns [`ctrl::R`](R) reader structure"]
impl crate::Readable for CTRL_SPEC { impl crate::Readable for CtrlSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`ctrl::W`](W) writer structure"]
} impl crate::Writable for CtrlSpec {
#[doc = "`write(|w| ..)` method takes [ctrl::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CTRL_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CTRL to value 0"] #[doc = "`reset()` method sets CTRL to value 0"]
impl crate::Resettable for CTRL_SPEC { impl crate::Resettable for CtrlSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

96
va416xx/src/adc/fifo_clr.rs
View File

@ -1,91 +1,31 @@
#[doc = "Register `FIFO_CLR` reader"] #[doc = "Register `FIFO_CLR` reader"]
pub struct R(crate::R<FIFO_CLR_SPEC>); pub type R = crate::R<FifoClrSpec>;
impl core::ops::Deref for R {
type Target = crate::R<FIFO_CLR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<FIFO_CLR_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<FIFO_CLR_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `FIFO_CLR` writer"] #[doc = "Register `FIFO_CLR` writer"]
pub struct W(crate::W<FIFO_CLR_SPEC>); pub type W = crate::W<FifoClrSpec>;
impl core::ops::Deref for W {
type Target = crate::W<FIFO_CLR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<FIFO_CLR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<FIFO_CLR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `FIFO_CLR` writer - Clears the ADC FIFO. Always reads 0"] #[doc = "Field `FIFO_CLR` writer - Clears the ADC FIFO. Always reads 0"]
pub struct FIFO_CLR_W<'a> { pub type FifoClrW<'a, REG> = crate::BitWriter<'a, REG>;
w: &'a mut W,
}
impl<'a> FIFO_CLR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
self.w
}
}
impl W { impl W {
#[doc = "Bit 0 - Clears the ADC FIFO. Always reads 0"] #[doc = "Bit 0 - Clears the ADC FIFO. Always reads 0"]
#[inline(always)] #[inline(always)]
pub fn fifo_clr(&mut self) -> FIFO_CLR_W { #[must_use]
FIFO_CLR_W { w: self } pub fn fifo_clr(&mut self) -> FifoClrW<FifoClrSpec> {
} FifoClrW::new(self, 0)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "FIFO Clear\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [fifo_clr](index.html) module"] #[doc = "FIFO Clear\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_clr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`fifo_clr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct FIFO_CLR_SPEC; pub struct FifoClrSpec;
impl crate::RegisterSpec for FIFO_CLR_SPEC { impl crate::RegisterSpec for FifoClrSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [fifo_clr::R](R) reader structure"] #[doc = "`read()` method returns [`fifo_clr::R`](R) reader structure"]
impl crate::Readable for FIFO_CLR_SPEC { impl crate::Readable for FifoClrSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`fifo_clr::W`](W) writer structure"]
} impl crate::Writable for FifoClrSpec {
#[doc = "`write(|w| ..)` method takes [fifo_clr::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for FIFO_CLR_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets FIFO_CLR to value 0"] #[doc = "`reset()` method sets FIFO_CLR to value 0"]
impl crate::Resettable for FIFO_CLR_SPEC { impl crate::Resettable for FifoClrSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

80
va416xx/src/adc/fifo_data.rs
View File

@ -1,73 +1,29 @@
#[doc = "Register `FIFO_DATA` reader"] #[doc = "Register `FIFO_DATA` reader"]
pub struct R(crate::R<FIFO_DATA_SPEC>); pub type R = crate::R<FifoDataSpec>;
impl core::ops::Deref for R {
type Target = crate::R<FIFO_DATA_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<FIFO_DATA_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<FIFO_DATA_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Field `CHAN_TAG` reader - If enabled, this will include the number of the channel corresponding to the measurement"]
pub struct CHAN_TAG_R(crate::FieldReader<u8, u8>);
impl CHAN_TAG_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
CHAN_TAG_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CHAN_TAG_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADC_DATA` reader - ADC acquisition data from the FIFO"] #[doc = "Field `ADC_DATA` reader - ADC acquisition data from the FIFO"]
pub struct ADC_DATA_R(crate::FieldReader<u16, u16>); pub type AdcDataR = crate::FieldReader<u16>;
impl ADC_DATA_R { #[doc = "Field `CHAN_TAG` reader - If enabled, this will include the number of the channel corresponding to the measurement"]
#[inline(always)] pub type ChanTagR = crate::FieldReader;
pub(crate) fn new(bits: u16) -> Self {
ADC_DATA_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADC_DATA_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl R { impl R {
#[doc = "Bits 12:15 - If enabled, this will include the number of the channel corresponding to the measurement"]
#[inline(always)]
pub fn chan_tag(&self) -> CHAN_TAG_R {
CHAN_TAG_R::new(((self.bits >> 12) & 0x0f) as u8)
}
#[doc = "Bits 0:11 - ADC acquisition data from the FIFO"] #[doc = "Bits 0:11 - ADC acquisition data from the FIFO"]
#[inline(always)] #[inline(always)]
pub fn adc_data(&self) -> ADC_DATA_R { pub fn adc_data(&self) -> AdcDataR {
ADC_DATA_R::new((self.bits & 0x0fff) as u16) AdcDataR::new((self.bits & 0x0fff) as u16)
}
#[doc = "Bits 12:15 - If enabled, this will include the number of the channel corresponding to the measurement"]
#[inline(always)]
pub fn chan_tag(&self) -> ChanTagR {
ChanTagR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
#[doc = "FIFO data\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [fifo_data](index.html) module"] #[doc = "FIFO data\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`fifo_data::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct FIFO_DATA_SPEC; pub struct FifoDataSpec;
impl crate::RegisterSpec for FIFO_DATA_SPEC { impl crate::RegisterSpec for FifoDataSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [fifo_data::R](R) reader structure"] #[doc = "`read()` method returns [`fifo_data::R`](R) reader structure"]
impl crate::Readable for FIFO_DATA_SPEC { impl crate::Readable for FifoDataSpec {}
type Reader = R;
}
#[doc = "`reset()` method sets FIFO_DATA to value 0"] #[doc = "`reset()` method sets FIFO_DATA to value 0"]
impl crate::Resettable for FIFO_DATA_SPEC { impl crate::Resettable for FifoDataSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

168
va416xx/src/adc/irq_clr.rs
View File

@ -1,153 +1,51 @@
#[doc = "Register `IRQ_CLR` writer"] #[doc = "Register `IRQ_CLR` writer"]
pub struct W(crate::W<IRQ_CLR_SPEC>); pub type W = crate::W<IrqClrSpec>;
impl core::ops::Deref for W {
type Target = crate::W<IRQ_CLR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<IRQ_CLR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<IRQ_CLR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `TRIG_ERROR` writer - Clears the trigger error interrupt status. Always reads 0"]
pub struct TRIG_ERROR_W<'a> {
w: &'a mut W,
}
impl<'a> TRIG_ERROR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "Field `ADC_DONE` writer - Clears the ADC done interrupt status. Always reads 0"]
pub struct ADC_DONE_W<'a> {
w: &'a mut W,
}
impl<'a> ADC_DONE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
self.w
}
}
#[doc = "Field `FIFO_UFLOW` writer - Clears the FIFO underflow interrupt status. Always reads 0"]
pub struct FIFO_UFLOW_W<'a> {
w: &'a mut W,
}
impl<'a> FIFO_UFLOW_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "Field `FIFO_OFLOW` writer - Clears the FIFO overflow interrupt status. Always reads 0"] #[doc = "Field `FIFO_OFLOW` writer - Clears the FIFO overflow interrupt status. Always reads 0"]
pub struct FIFO_OFLOW_W<'a> { pub type FifoOflowW<'a, REG> = crate::BitWriter<'a, REG>;
w: &'a mut W, #[doc = "Field `FIFO_UFLOW` writer - Clears the FIFO underflow interrupt status. Always reads 0"]
} pub type FifoUflowW<'a, REG> = crate::BitWriter<'a, REG>;
impl<'a> FIFO_OFLOW_W<'a> { #[doc = "Field `ADC_DONE` writer - Clears the ADC done interrupt status. Always reads 0"]
#[doc = r"Sets the field bit"] pub type AdcDoneW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)] #[doc = "Field `TRIG_ERROR` writer - Clears the trigger error interrupt status. Always reads 0"]
pub fn set_bit(self) -> &'a mut W { pub type TrigErrorW<'a, REG> = crate::BitWriter<'a, REG>;
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
self.w
}
}
impl W { impl W {
#[doc = "Bit 3 - Clears the trigger error interrupt status. Always reads 0"] #[doc = "Bit 0 - Clears the FIFO overflow interrupt status. Always reads 0"]
#[inline(always)] #[inline(always)]
pub fn trig_error(&mut self) -> TRIG_ERROR_W { #[must_use]
TRIG_ERROR_W { w: self } pub fn fifo_oflow(&mut self) -> FifoOflowW<IrqClrSpec> {
} FifoOflowW::new(self, 0)
#[doc = "Bit 2 - Clears the ADC done interrupt status. Always reads 0"]
#[inline(always)]
pub fn adc_done(&mut self) -> ADC_DONE_W {
ADC_DONE_W { w: self }
} }
#[doc = "Bit 1 - Clears the FIFO underflow interrupt status. Always reads 0"] #[doc = "Bit 1 - Clears the FIFO underflow interrupt status. Always reads 0"]
#[inline(always)] #[inline(always)]
pub fn fifo_uflow(&mut self) -> FIFO_UFLOW_W { #[must_use]
FIFO_UFLOW_W { w: self } pub fn fifo_uflow(&mut self) -> FifoUflowW<IrqClrSpec> {
FifoUflowW::new(self, 1)
} }
#[doc = "Bit 0 - Clears the FIFO overflow interrupt status. Always reads 0"] #[doc = "Bit 2 - Clears the ADC done interrupt status. Always reads 0"]
#[inline(always)] #[inline(always)]
pub fn fifo_oflow(&mut self) -> FIFO_OFLOW_W { #[must_use]
FIFO_OFLOW_W { w: self } pub fn adc_done(&mut self) -> AdcDoneW<IrqClrSpec> {
AdcDoneW::new(self, 2)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 3 - Clears the trigger error interrupt status. Always reads 0"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn trig_error(&mut self) -> TrigErrorW<IrqClrSpec> {
self TrigErrorW::new(self, 3)
} }
} }
#[doc = "Clear Interrupt\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_clr](index.html) module"] #[doc = "Clear Interrupt\n\nYou can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_clr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct IRQ_CLR_SPEC; pub struct IrqClrSpec;
impl crate::RegisterSpec for IRQ_CLR_SPEC { impl crate::RegisterSpec for IrqClrSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`write(|w| ..)` method takes [irq_clr::W](W) writer structure"] #[doc = "`write(|w| ..)` method takes [`irq_clr::W`](W) writer structure"]
impl crate::Writable for IRQ_CLR_SPEC { impl crate::Writable for IrqClrSpec {
type Writer = W; type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets IRQ_CLR to value 0"] #[doc = "`reset()` method sets IRQ_CLR to value 0"]
impl crate::Resettable for IRQ_CLR_SPEC { impl crate::Resettable for IrqClrSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

467
va416xx/src/adc/irq_enb.rs
View File

@ -1,395 +1,130 @@
#[doc = "Register `IRQ_ENB` reader"] #[doc = "Register `IRQ_ENB` reader"]
pub struct R(crate::R<IRQ_ENB_SPEC>); pub type R = crate::R<IrqEnbSpec>;
impl core::ops::Deref for R {
type Target = crate::R<IRQ_ENB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<IRQ_ENB_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<IRQ_ENB_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `IRQ_ENB` writer"] #[doc = "Register `IRQ_ENB` writer"]
pub struct W(crate::W<IRQ_ENB_SPEC>); pub type W = crate::W<IrqEnbSpec>;
impl core::ops::Deref for W {
type Target = crate::W<IRQ_ENB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<IRQ_ENB_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<IRQ_ENB_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
pub struct FIFO_DEPTH_TRIG_R(crate::FieldReader<bool, bool>);
impl FIFO_DEPTH_TRIG_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_DEPTH_TRIG_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_DEPTH_TRIG_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_DEPTH_TRIG` writer - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
pub struct FIFO_DEPTH_TRIG_W<'a> {
w: &'a mut W,
}
impl<'a> FIFO_DEPTH_TRIG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
self.w
}
}
#[doc = "Field `TRIG_ERROR` reader - Enables the interrupt for a trigger error"]
pub struct TRIG_ERROR_R(crate::FieldReader<bool, bool>);
impl TRIG_ERROR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
TRIG_ERROR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TRIG_ERROR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TRIG_ERROR` writer - Enables the interrupt for a trigger error"]
pub struct TRIG_ERROR_W<'a> {
w: &'a mut W,
}
impl<'a> TRIG_ERROR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
self.w
}
}
#[doc = "Field `ADC_DONE` reader - Enables the interrupt for an ADC data acquisition completion"]
pub struct ADC_DONE_R(crate::FieldReader<bool, bool>);
impl ADC_DONE_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
ADC_DONE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADC_DONE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADC_DONE` writer - Enables the interrupt for an ADC data acquisition completion"]
pub struct ADC_DONE_W<'a> {
w: &'a mut W,
}
impl<'a> ADC_DONE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
self.w
}
}
#[doc = "Field `FIFO_UFLOW` reader - Enables the interrupt for a FIFO underflow"]
pub struct FIFO_UFLOW_R(crate::FieldReader<bool, bool>);
impl FIFO_UFLOW_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_UFLOW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_UFLOW_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_UFLOW` writer - Enables the interrupt for a FIFO underflow"]
pub struct FIFO_UFLOW_W<'a> {
w: &'a mut W,
}
impl<'a> FIFO_UFLOW_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "Field `FIFO_OFLOW` reader - Enables the interrupt for a FIFO overflow"]
pub struct FIFO_OFLOW_R(crate::FieldReader<bool, bool>);
impl FIFO_OFLOW_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_OFLOW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_OFLOW_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_OFLOW` writer - Enables the interrupt for a FIFO overflow"]
pub struct FIFO_OFLOW_W<'a> {
w: &'a mut W,
}
impl<'a> FIFO_OFLOW_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
self.w
}
}
#[doc = "Field `FIFO_FULL` reader - Enables the interrupt for FIFO full"]
pub struct FIFO_FULL_R(crate::FieldReader<bool, bool>);
impl FIFO_FULL_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_FULL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_FULL_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_FULL` writer - Enables the interrupt for FIFO full"]
pub struct FIFO_FULL_W<'a> {
w: &'a mut W,
}
impl<'a> FIFO_FULL_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "Field `FIFO_EMPTY` reader - Enables the interrupt for FIFO empty"] #[doc = "Field `FIFO_EMPTY` reader - Enables the interrupt for FIFO empty"]
pub struct FIFO_EMPTY_R(crate::FieldReader<bool, bool>); pub type FifoEmptyR = crate::BitReader;
impl FIFO_EMPTY_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_EMPTY_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_EMPTY_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_EMPTY` writer - Enables the interrupt for FIFO empty"] #[doc = "Field `FIFO_EMPTY` writer - Enables the interrupt for FIFO empty"]
pub struct FIFO_EMPTY_W<'a> { pub type FifoEmptyW<'a, REG> = crate::BitWriter<'a, REG>;
w: &'a mut W, #[doc = "Field `FIFO_FULL` reader - Enables the interrupt for FIFO full"]
} pub type FifoFullR = crate::BitReader;
impl<'a> FIFO_EMPTY_W<'a> { #[doc = "Field `FIFO_FULL` writer - Enables the interrupt for FIFO full"]
#[doc = r"Sets the field bit"] pub type FifoFullW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)] #[doc = "Field `FIFO_OFLOW` reader - Enables the interrupt for a FIFO overflow"]
pub fn set_bit(self) -> &'a mut W { pub type FifoOflowR = crate::BitReader;
self.bit(true) #[doc = "Field `FIFO_OFLOW` writer - Enables the interrupt for a FIFO overflow"]
} pub type FifoOflowW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = r"Clears the field bit"] #[doc = "Field `FIFO_UFLOW` reader - Enables the interrupt for a FIFO underflow"]
#[inline(always)] pub type FifoUflowR = crate::BitReader;
pub fn clear_bit(self) -> &'a mut W { #[doc = "Field `FIFO_UFLOW` writer - Enables the interrupt for a FIFO underflow"]
self.bit(false) pub type FifoUflowW<'a, REG> = crate::BitWriter<'a, REG>;
} #[doc = "Field `ADC_DONE` reader - Enables the interrupt for an ADC data acquisition completion"]
#[doc = r"Writes raw bits to the field"] pub type AdcDoneR = crate::BitReader;
#[inline(always)] #[doc = "Field `ADC_DONE` writer - Enables the interrupt for an ADC data acquisition completion"]
pub fn bit(self, value: bool) -> &'a mut W { pub type AdcDoneW<'a, REG> = crate::BitWriter<'a, REG>;
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01); #[doc = "Field `TRIG_ERROR` reader - Enables the interrupt for a trigger error"]
self.w pub type TrigErrorR = crate::BitReader;
} #[doc = "Field `TRIG_ERROR` writer - Enables the interrupt for a trigger error"]
} pub type TrigErrorW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
pub type FifoDepthTrigR = crate::BitReader;
#[doc = "Field `FIFO_DEPTH_TRIG` writer - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
pub type FifoDepthTrigW<'a, REG> = crate::BitWriter<'a, REG>;
impl R { impl R {
#[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"] #[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
#[inline(always)] #[inline(always)]
pub fn fifo_depth_trig(&self) -> FIFO_DEPTH_TRIG_R { pub fn fifo_empty(&self) -> FifoEmptyR {
FIFO_DEPTH_TRIG_R::new(((self.bits >> 6) & 0x01) != 0) FifoEmptyR::new((self.bits & 1) != 0)
}
#[doc = "Bit 5 - Enables the interrupt for a trigger error"]
#[inline(always)]
pub fn trig_error(&self) -> TRIG_ERROR_R {
TRIG_ERROR_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
#[inline(always)]
pub fn adc_done(&self) -> ADC_DONE_R {
ADC_DONE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
#[inline(always)]
pub fn fifo_uflow(&self) -> FIFO_UFLOW_R {
FIFO_UFLOW_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
#[inline(always)]
pub fn fifo_oflow(&self) -> FIFO_OFLOW_R {
FIFO_OFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
} }
#[doc = "Bit 1 - Enables the interrupt for FIFO full"] #[doc = "Bit 1 - Enables the interrupt for FIFO full"]
#[inline(always)] #[inline(always)]
pub fn fifo_full(&self) -> FIFO_FULL_R { pub fn fifo_full(&self) -> FifoFullR {
FIFO_FULL_R::new(((self.bits >> 1) & 0x01) != 0) FifoFullR::new(((self.bits >> 1) & 1) != 0)
} }
#[doc = "Bit 0 - Enables the interrupt for FIFO empty"] #[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
#[inline(always)] #[inline(always)]
pub fn fifo_empty(&self) -> FIFO_EMPTY_R { pub fn fifo_oflow(&self) -> FifoOflowR {
FIFO_EMPTY_R::new((self.bits & 0x01) != 0) FifoOflowR::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
#[inline(always)]
pub fn fifo_uflow(&self) -> FifoUflowR {
FifoUflowR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
#[inline(always)]
pub fn adc_done(&self) -> AdcDoneR {
AdcDoneR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - Enables the interrupt for a trigger error"]
#[inline(always)]
pub fn trig_error(&self) -> TrigErrorR {
TrigErrorR::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
#[inline(always)]
pub fn fifo_depth_trig(&self) -> FifoDepthTrigR {
FifoDepthTrigR::new(((self.bits >> 6) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"] #[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
#[inline(always)] #[inline(always)]
pub fn fifo_depth_trig(&mut self) -> FIFO_DEPTH_TRIG_W { #[must_use]
FIFO_DEPTH_TRIG_W { w: self } pub fn fifo_empty(&mut self) -> FifoEmptyW<IrqEnbSpec> {
} FifoEmptyW::new(self, 0)
#[doc = "Bit 5 - Enables the interrupt for a trigger error"]
#[inline(always)]
pub fn trig_error(&mut self) -> TRIG_ERROR_W {
TRIG_ERROR_W { w: self }
}
#[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
#[inline(always)]
pub fn adc_done(&mut self) -> ADC_DONE_W {
ADC_DONE_W { w: self }
}
#[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
#[inline(always)]
pub fn fifo_uflow(&mut self) -> FIFO_UFLOW_W {
FIFO_UFLOW_W { w: self }
}
#[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
#[inline(always)]
pub fn fifo_oflow(&mut self) -> FIFO_OFLOW_W {
FIFO_OFLOW_W { w: self }
} }
#[doc = "Bit 1 - Enables the interrupt for FIFO full"] #[doc = "Bit 1 - Enables the interrupt for FIFO full"]
#[inline(always)] #[inline(always)]
pub fn fifo_full(&mut self) -> FIFO_FULL_W { #[must_use]
FIFO_FULL_W { w: self } pub fn fifo_full(&mut self) -> FifoFullW<IrqEnbSpec> {
FifoFullW::new(self, 1)
} }
#[doc = "Bit 0 - Enables the interrupt for FIFO empty"] #[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
#[inline(always)] #[inline(always)]
pub fn fifo_empty(&mut self) -> FIFO_EMPTY_W { #[must_use]
FIFO_EMPTY_W { w: self } pub fn fifo_oflow(&mut self) -> FifoOflowW<IrqEnbSpec> {
FifoOflowW::new(self, 2)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn fifo_uflow(&mut self) -> FifoUflowW<IrqEnbSpec> {
self FifoUflowW::new(self, 3)
}
#[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
#[inline(always)]
#[must_use]
pub fn adc_done(&mut self) -> AdcDoneW<IrqEnbSpec> {
AdcDoneW::new(self, 4)
}
#[doc = "Bit 5 - Enables the interrupt for a trigger error"]
#[inline(always)]
#[must_use]
pub fn trig_error(&mut self) -> TrigErrorW<IrqEnbSpec> {
TrigErrorW::new(self, 5)
}
#[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
#[inline(always)]
#[must_use]
pub fn fifo_depth_trig(&mut self) -> FifoDepthTrigW<IrqEnbSpec> {
FifoDepthTrigW::new(self, 6)
} }
} }
#[doc = "Interrupt Enable\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_enb](index.html) module"] #[doc = "Interrupt Enable\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_enb::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`irq_enb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct IRQ_ENB_SPEC; pub struct IrqEnbSpec;
impl crate::RegisterSpec for IRQ_ENB_SPEC { impl crate::RegisterSpec for IrqEnbSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [irq_enb::R](R) reader structure"] #[doc = "`read()` method returns [`irq_enb::R`](R) reader structure"]
impl crate::Readable for IRQ_ENB_SPEC { impl crate::Readable for IrqEnbSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`irq_enb::W`](W) writer structure"]
} impl crate::Writable for IrqEnbSpec {
#[doc = "`write(|w| ..)` method takes [irq_enb::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for IRQ_ENB_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets IRQ_ENB to value 0"] #[doc = "`reset()` method sets IRQ_ENB to value 0"]
impl crate::Resettable for IRQ_ENB_SPEC { impl crate::Resettable for IrqEnbSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

207
va416xx/src/adc/irq_end.rs
View File

@ -1,173 +1,64 @@
#[doc = "Register `IRQ_END` reader"] #[doc = "Register `IRQ_END` reader"]
pub struct R(crate::R<IRQ_END_SPEC>); pub type R = crate::R<IrqEndSpec>;
impl core::ops::Deref for R {
type Target = crate::R<IRQ_END_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<IRQ_END_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<IRQ_END_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
pub struct FIFO_DEPTH_TRIG_R(crate::FieldReader<bool, bool>);
impl FIFO_DEPTH_TRIG_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_DEPTH_TRIG_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_DEPTH_TRIG_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
pub struct TRIG_ERROR_R(crate::FieldReader<bool, bool>);
impl TRIG_ERROR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
TRIG_ERROR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TRIG_ERROR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done and the interrupt is enabled"]
pub struct ADC_DONE_R(crate::FieldReader<bool, bool>);
impl ADC_DONE_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
ADC_DONE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADC_DONE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_UFLOW` reader - Indicates a FIFO underflow occurred and the interrupt is enabled"]
pub struct FIFO_UFLOW_R(crate::FieldReader<bool, bool>);
impl FIFO_UFLOW_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_UFLOW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_UFLOW_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred and the interrupt is enabled"]
pub struct FIFO_OFLOW_R(crate::FieldReader<bool, bool>);
impl FIFO_OFLOW_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_OFLOW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_OFLOW_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full and the interrupt is enabled"]
pub struct FIFO_FULL_R(crate::FieldReader<bool, bool>);
impl FIFO_FULL_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_FULL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_FULL_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty and the interrupt is enabled"] #[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty and the interrupt is enabled"]
pub struct FIFO_EMPTY_R(crate::FieldReader<bool, bool>); pub type FifoEmptyR = crate::BitReader;
impl FIFO_EMPTY_R { #[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full and the interrupt is enabled"]
#[inline(always)] pub type FifoFullR = crate::BitReader;
pub(crate) fn new(bits: bool) -> Self { #[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred and the interrupt is enabled"]
FIFO_EMPTY_R(crate::FieldReader::new(bits)) pub type FifoOflowR = crate::BitReader;
} #[doc = "Field `FIFO_UFLOW` reader - Indicates a FIFO underflow occurred and the interrupt is enabled"]
} pub type FifoUflowR = crate::BitReader;
impl core::ops::Deref for FIFO_EMPTY_R { #[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done and the interrupt is enabled"]
type Target = crate::FieldReader<bool, bool>; pub type AdcDoneR = crate::BitReader;
#[inline(always)] #[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
fn deref(&self) -> &Self::Target { pub type TrigErrorR = crate::BitReader;
&self.0 #[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
} pub type FifoDepthTrigR = crate::BitReader;
}
impl R { impl R {
#[doc = "Bit 6 - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"] #[doc = "Bit 0 - Indicates the FIFO is empty and the interrupt is enabled"]
#[inline(always)] #[inline(always)]
pub fn fifo_depth_trig(&self) -> FIFO_DEPTH_TRIG_R { pub fn fifo_empty(&self) -> FifoEmptyR {
FIFO_DEPTH_TRIG_R::new(((self.bits >> 6) & 0x01) != 0) FifoEmptyR::new((self.bits & 1) != 0)
}
#[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
#[inline(always)]
pub fn trig_error(&self) -> TRIG_ERROR_R {
TRIG_ERROR_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Indicates that a ADC conversion is done and the interrupt is enabled"]
#[inline(always)]
pub fn adc_done(&self) -> ADC_DONE_R {
ADC_DONE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Indicates a FIFO underflow occurred and the interrupt is enabled"]
#[inline(always)]
pub fn fifo_uflow(&self) -> FIFO_UFLOW_R {
FIFO_UFLOW_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Indicates a FIFO overflow occurred and the interrupt is enabled"]
#[inline(always)]
pub fn fifo_oflow(&self) -> FIFO_OFLOW_R {
FIFO_OFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
} }
#[doc = "Bit 1 - Indicates the FIFO is full and the interrupt is enabled"] #[doc = "Bit 1 - Indicates the FIFO is full and the interrupt is enabled"]
#[inline(always)] #[inline(always)]
pub fn fifo_full(&self) -> FIFO_FULL_R { pub fn fifo_full(&self) -> FifoFullR {
FIFO_FULL_R::new(((self.bits >> 1) & 0x01) != 0) FifoFullR::new(((self.bits >> 1) & 1) != 0)
} }
#[doc = "Bit 0 - Indicates the FIFO is empty and the interrupt is enabled"] #[doc = "Bit 2 - Indicates a FIFO overflow occurred and the interrupt is enabled"]
#[inline(always)] #[inline(always)]
pub fn fifo_empty(&self) -> FIFO_EMPTY_R { pub fn fifo_oflow(&self) -> FifoOflowR {
FIFO_EMPTY_R::new((self.bits & 0x01) != 0) FifoOflowR::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - Indicates a FIFO underflow occurred and the interrupt is enabled"]
#[inline(always)]
pub fn fifo_uflow(&self) -> FifoUflowR {
FifoUflowR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Indicates that a ADC conversion is done and the interrupt is enabled"]
#[inline(always)]
pub fn adc_done(&self) -> AdcDoneR {
AdcDoneR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
#[inline(always)]
pub fn trig_error(&self) -> TrigErrorR {
TrigErrorR::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
#[inline(always)]
pub fn fifo_depth_trig(&self) -> FifoDepthTrigR {
FifoDepthTrigR::new(((self.bits >> 6) & 1) != 0)
} }
} }
#[doc = "Enabled Interrupt Status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_end](index.html) module"] #[doc = "Enabled Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_end::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct IRQ_END_SPEC; pub struct IrqEndSpec;
impl crate::RegisterSpec for IRQ_END_SPEC { impl crate::RegisterSpec for IrqEndSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [irq_end::R](R) reader structure"] #[doc = "`read()` method returns [`irq_end::R`](R) reader structure"]
impl crate::Readable for IRQ_END_SPEC { impl crate::Readable for IrqEndSpec {}
type Reader = R;
}
#[doc = "`reset()` method sets IRQ_END to value 0"] #[doc = "`reset()` method sets IRQ_END to value 0"]
impl crate::Resettable for IRQ_END_SPEC { impl crate::Resettable for IrqEndSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

207
va416xx/src/adc/irq_raw.rs
View File

@ -1,173 +1,64 @@
#[doc = "Register `IRQ_RAW` reader"] #[doc = "Register `IRQ_RAW` reader"]
pub struct R(crate::R<IRQ_RAW_SPEC>); pub type R = crate::R<IrqRawSpec>;
impl core::ops::Deref for R {
type Target = crate::R<IRQ_RAW_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<IRQ_RAW_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<IRQ_RAW_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
pub struct FIFO_DEPTH_TRIG_R(crate::FieldReader<bool, bool>);
impl FIFO_DEPTH_TRIG_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_DEPTH_TRIG_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_DEPTH_TRIG_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
pub struct TRIG_ERROR_R(crate::FieldReader<bool, bool>);
impl TRIG_ERROR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
TRIG_ERROR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TRIG_ERROR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done"]
pub struct ADC_DONE_R(crate::FieldReader<bool, bool>);
impl ADC_DONE_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
ADC_DONE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADC_DONE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_UFLOW` reader - Indicates data was unavailable when a new trigger for ADC update is received"]
pub struct FIFO_UFLOW_R(crate::FieldReader<bool, bool>);
impl FIFO_UFLOW_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_UFLOW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_UFLOW_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
pub struct FIFO_OFLOW_R(crate::FieldReader<bool, bool>);
impl FIFO_OFLOW_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_OFLOW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_OFLOW_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full"]
pub struct FIFO_FULL_R(crate::FieldReader<bool, bool>);
impl FIFO_FULL_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
FIFO_FULL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_FULL_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty"] #[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty"]
pub struct FIFO_EMPTY_R(crate::FieldReader<bool, bool>); pub type FifoEmptyR = crate::BitReader;
impl FIFO_EMPTY_R { #[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full"]
#[inline(always)] pub type FifoFullR = crate::BitReader;
pub(crate) fn new(bits: bool) -> Self { #[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
FIFO_EMPTY_R(crate::FieldReader::new(bits)) pub type FifoOflowR = crate::BitReader;
} #[doc = "Field `FIFO_UFLOW` reader - Indicates data was unavailable when a new trigger for ADC update is received"]
} pub type FifoUflowR = crate::BitReader;
impl core::ops::Deref for FIFO_EMPTY_R { #[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done"]
type Target = crate::FieldReader<bool, bool>; pub type AdcDoneR = crate::BitReader;
#[inline(always)] #[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
fn deref(&self) -> &Self::Target { pub type TrigErrorR = crate::BitReader;
&self.0 #[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
} pub type FifoDepthTrigR = crate::BitReader;
}
impl R { impl R {
#[doc = "Bit 6 - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"] #[doc = "Bit 0 - Indicates the FIFO is empty"]
#[inline(always)] #[inline(always)]
pub fn fifo_depth_trig(&self) -> FIFO_DEPTH_TRIG_R { pub fn fifo_empty(&self) -> FifoEmptyR {
FIFO_DEPTH_TRIG_R::new(((self.bits >> 6) & 0x01) != 0) FifoEmptyR::new((self.bits & 1) != 0)
}
#[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
#[inline(always)]
pub fn trig_error(&self) -> TRIG_ERROR_R {
TRIG_ERROR_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Indicates that a ADC conversion is done"]
#[inline(always)]
pub fn adc_done(&self) -> ADC_DONE_R {
ADC_DONE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Indicates data was unavailable when a new trigger for ADC update is received"]
#[inline(always)]
pub fn fifo_uflow(&self) -> FIFO_UFLOW_R {
FIFO_UFLOW_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
#[inline(always)]
pub fn fifo_oflow(&self) -> FIFO_OFLOW_R {
FIFO_OFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
} }
#[doc = "Bit 1 - Indicates the FIFO is full"] #[doc = "Bit 1 - Indicates the FIFO is full"]
#[inline(always)] #[inline(always)]
pub fn fifo_full(&self) -> FIFO_FULL_R { pub fn fifo_full(&self) -> FifoFullR {
FIFO_FULL_R::new(((self.bits >> 1) & 0x01) != 0) FifoFullR::new(((self.bits >> 1) & 1) != 0)
} }
#[doc = "Bit 0 - Indicates the FIFO is empty"] #[doc = "Bit 2 - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
#[inline(always)] #[inline(always)]
pub fn fifo_empty(&self) -> FIFO_EMPTY_R { pub fn fifo_oflow(&self) -> FifoOflowR {
FIFO_EMPTY_R::new((self.bits & 0x01) != 0) FifoOflowR::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - Indicates data was unavailable when a new trigger for ADC update is received"]
#[inline(always)]
pub fn fifo_uflow(&self) -> FifoUflowR {
FifoUflowR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Indicates that a ADC conversion is done"]
#[inline(always)]
pub fn adc_done(&self) -> AdcDoneR {
AdcDoneR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
#[inline(always)]
pub fn trig_error(&self) -> TrigErrorR {
TrigErrorR::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
#[inline(always)]
pub fn fifo_depth_trig(&self) -> FifoDepthTrigR {
FifoDepthTrigR::new(((self.bits >> 6) & 1) != 0)
} }
} }
#[doc = "Raw Interrupt Status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_raw](index.html) module"] #[doc = "Raw Interrupt Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`irq_raw::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct IRQ_RAW_SPEC; pub struct IrqRawSpec;
impl crate::RegisterSpec for IRQ_RAW_SPEC { impl crate::RegisterSpec for IrqRawSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [irq_raw::R](R) reader structure"] #[doc = "`read()` method returns [`irq_raw::R`](R) reader structure"]
impl crate::Readable for IRQ_RAW_SPEC { impl crate::Readable for IrqRawSpec {}
type Reader = R;
}
#[doc = "`reset()` method sets IRQ_RAW to value 0x01"] #[doc = "`reset()` method sets IRQ_RAW to value 0x01"]
impl crate::Resettable for IRQ_RAW_SPEC { impl crate::Resettable for IrqRawSpec {
#[inline(always)] const RESET_VALUE: u32 = 0x01;
fn reset_value() -> Self::Ux {
0x01
}
} }

35
va416xx/src/adc/perid.rs
View File

@ -1,31 +1,18 @@
#[doc = "Register `PERID` reader"] #[doc = "Register `PERID` reader"]
pub struct R(crate::R<PERID_SPEC>); pub type R = crate::R<PeridSpec>;
impl core::ops::Deref for R { impl core::fmt::Debug for R {
type Target = crate::R<PERID_SPEC>; fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
#[inline(always)] write!(f, "{}", self.bits())
fn deref(&self) -> &Self::Target {
&self.0
} }
} }
impl From<crate::R<PERID_SPEC>> for R { #[doc = "Peripheral ID Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`perid::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
#[inline(always)] pub struct PeridSpec;
fn from(reader: crate::R<PERID_SPEC>) -> Self { impl crate::RegisterSpec for PeridSpec {
R(reader)
}
}
#[doc = "Peripheral ID Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [perid](index.html) module"]
pub struct PERID_SPEC;
impl crate::RegisterSpec for PERID_SPEC {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [perid::R](R) reader structure"] #[doc = "`read()` method returns [`perid::R`](R) reader structure"]
impl crate::Readable for PERID_SPEC { impl crate::Readable for PeridSpec {}
type Reader = R;
}
#[doc = "`reset()` method sets PERID to value 0x0019_07e9"] #[doc = "`reset()` method sets PERID to value 0x0019_07e9"]
impl crate::Resettable for PERID_SPEC { impl crate::Resettable for PeridSpec {
#[inline(always)] const RESET_VALUE: u32 = 0x0019_07e9;
fn reset_value() -> Self::Ux {
0x0019_07e9
}
} }

105
va416xx/src/adc/rxfifoirqtrg.rs
View File

@ -1,103 +1,40 @@
#[doc = "Register `RXFIFOIRQTRG` reader"] #[doc = "Register `RXFIFOIRQTRG` reader"]
pub struct R(crate::R<RXFIFOIRQTRG_SPEC>); pub type R = crate::R<RxfifoirqtrgSpec>;
impl core::ops::Deref for R {
type Target = crate::R<RXFIFOIRQTRG_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<RXFIFOIRQTRG_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<RXFIFOIRQTRG_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `RXFIFOIRQTRG` writer"] #[doc = "Register `RXFIFOIRQTRG` writer"]
pub struct W(crate::W<RXFIFOIRQTRG_SPEC>); pub type W = crate::W<RxfifoirqtrgSpec>;
impl core::ops::Deref for W {
type Target = crate::W<RXFIFOIRQTRG_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<RXFIFOIRQTRG_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<RXFIFOIRQTRG_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `LEVEL` reader - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"] #[doc = "Field `LEVEL` reader - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
pub struct LEVEL_R(crate::FieldReader<u8, u8>); pub type LevelR = crate::FieldReader;
impl LEVEL_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
LEVEL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LEVEL_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LEVEL` writer - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"] #[doc = "Field `LEVEL` writer - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
pub struct LEVEL_W<'a> { pub type LevelW<'a, REG> = crate::FieldWriter<'a, REG, 5>;
w: &'a mut W,
}
impl<'a> LEVEL_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0x1f) | (value as u32 & 0x1f);
self.w
}
}
impl R { impl R {
#[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"] #[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
#[inline(always)] #[inline(always)]
pub fn level(&self) -> LEVEL_R { pub fn level(&self) -> LevelR {
LEVEL_R::new((self.bits & 0x1f) as u8) LevelR::new((self.bits & 0x1f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"] #[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
#[inline(always)] #[inline(always)]
pub fn level(&mut self) -> LEVEL_W { #[must_use]
LEVEL_W { w: self } pub fn level(&mut self) -> LevelW<RxfifoirqtrgSpec> {
} LevelW::new(self, 0)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Receive FIFO Interrupt Trigger Value\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxfifoirqtrg](index.html) module"] #[doc = "Receive FIFO Interrupt Trigger Value\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`rxfifoirqtrg::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`rxfifoirqtrg::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct RXFIFOIRQTRG_SPEC; pub struct RxfifoirqtrgSpec;
impl crate::RegisterSpec for RXFIFOIRQTRG_SPEC { impl crate::RegisterSpec for RxfifoirqtrgSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [rxfifoirqtrg::R](R) reader structure"] #[doc = "`read()` method returns [`rxfifoirqtrg::R`](R) reader structure"]
impl crate::Readable for RXFIFOIRQTRG_SPEC { impl crate::Readable for RxfifoirqtrgSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`rxfifoirqtrg::W`](W) writer structure"]
} impl crate::Writable for RxfifoirqtrgSpec {
#[doc = "`write(|w| ..)` method takes [rxfifoirqtrg::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for RXFIFOIRQTRG_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets RXFIFOIRQTRG to value 0x10"] #[doc = "`reset()` method sets RXFIFOIRQTRG to value 0x10"]
impl crate::Resettable for RXFIFOIRQTRG_SPEC { impl crate::Resettable for RxfifoirqtrgSpec {
#[inline(always)] const RESET_VALUE: u32 = 0x10;
fn reset_value() -> Self::Ux {
0x10
}
} }

80
va416xx/src/adc/status.rs
View File

@ -1,73 +1,29 @@
#[doc = "Register `STATUS` reader"] #[doc = "Register `STATUS` reader"]
pub struct R(crate::R<STATUS_SPEC>); pub type R = crate::R<StatusSpec>;
impl core::ops::Deref for R {
type Target = crate::R<STATUS_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<STATUS_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<STATUS_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Field `ADC_BUSY` reader - Indicates an ADC data acquisition is in process"]
pub struct ADC_BUSY_R(crate::FieldReader<bool, bool>);
impl ADC_BUSY_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
ADC_BUSY_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADC_BUSY_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `FIFO_ENTRY_CNT` reader - Indicates the number of entries in the FIFO"] #[doc = "Field `FIFO_ENTRY_CNT` reader - Indicates the number of entries in the FIFO"]
pub struct FIFO_ENTRY_CNT_R(crate::FieldReader<u8, u8>); pub type FifoEntryCntR = crate::FieldReader;
impl FIFO_ENTRY_CNT_R { #[doc = "Field `ADC_BUSY` reader - Indicates an ADC data acquisition is in process"]
#[inline(always)] pub type AdcBusyR = crate::BitReader;
pub(crate) fn new(bits: u8) -> Self {
FIFO_ENTRY_CNT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for FIFO_ENTRY_CNT_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl R { impl R {
#[doc = "Bit 7 - Indicates an ADC data acquisition is in process"]
#[inline(always)]
pub fn adc_busy(&self) -> ADC_BUSY_R {
ADC_BUSY_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bits 0:5 - Indicates the number of entries in the FIFO"] #[doc = "Bits 0:5 - Indicates the number of entries in the FIFO"]
#[inline(always)] #[inline(always)]
pub fn fifo_entry_cnt(&self) -> FIFO_ENTRY_CNT_R { pub fn fifo_entry_cnt(&self) -> FifoEntryCntR {
FIFO_ENTRY_CNT_R::new((self.bits & 0x3f) as u8) FifoEntryCntR::new((self.bits & 0x3f) as u8)
}
#[doc = "Bit 7 - Indicates an ADC data acquisition is in process"]
#[inline(always)]
pub fn adc_busy(&self) -> AdcBusyR {
AdcBusyR::new(((self.bits >> 7) & 1) != 0)
} }
} }
#[doc = "Status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [status](index.html) module"] #[doc = "Status\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`status::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct STATUS_SPEC; pub struct StatusSpec;
impl crate::RegisterSpec for STATUS_SPEC { impl crate::RegisterSpec for StatusSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [status::R](R) reader structure"] #[doc = "`read()` method returns [`status::R`](R) reader structure"]
impl crate::Readable for STATUS_SPEC { impl crate::Readable for StatusSpec {}
type Reader = R;
}
#[doc = "`reset()` method sets STATUS to value 0"] #[doc = "`reset()` method sets STATUS to value 0"]
impl crate::Resettable for STATUS_SPEC { impl crate::Resettable for StatusSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

1992
va416xx/src/can0.rs
View File

File diff suppressed because it is too large Load Diff

297
va416xx/src/can0/bmskb.rs
View File

@ -1,254 +1,105 @@
#[doc = "Register `BMSKB` reader"] #[doc = "Register `BMSKB` reader"]
pub struct R(crate::R<BMSKB_SPEC>); pub type R = crate::R<BmskbSpec>;
impl core::ops::Deref for R {
type Target = crate::R<BMSKB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<BMSKB_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<BMSKB_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `BMSKB` writer"] #[doc = "Register `BMSKB` writer"]
pub struct W(crate::W<BMSKB_SPEC>); pub type W = crate::W<BmskbSpec>;
impl core::ops::Deref for W { #[doc = "Field `BM0` reader - BM\\[17:15\\]
type Target = crate::W<BMSKB_SPEC>; - Unused in standard, ID\\[17:15\\]
#[inline(always)] in extended"]
fn deref(&self) -> &Self::Target { pub type Bm0R = crate::FieldReader;
&self.0 #[doc = "Field `BM0` writer - BM\\[17:15\\]
} - Unused in standard, ID\\[17:15\\]
} in extended"]
impl core::ops::DerefMut for W { pub type Bm0W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
#[inline(always)] #[doc = "Field `IDE` reader - Identifier Extension Bit"]
fn deref_mut(&mut self) -> &mut Self::Target { pub type IdeR = crate::BitReader;
&mut self.0 #[doc = "Field `IDE` writer - Identifier Extension Bit"]
} pub type IdeW<'a, REG> = crate::BitWriter<'a, REG>;
} #[doc = "Field `RTR` reader - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
impl From<crate::W<BMSKB_SPEC>> for W { pub type RtrR = crate::BitReader;
#[inline(always)] #[doc = "Field `RTR` writer - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
fn from(writer: crate::W<BMSKB_SPEC>) -> Self { pub type RtrW<'a, REG> = crate::BitWriter<'a, REG>;
W(writer)
}
}
#[doc = "Field `BM1` reader - BM\\[28:18\\] #[doc = "Field `BM1` reader - BM\\[28:18\\]
- ID\\[10:0\\] - ID\\[10:0\\]
in standard, ID\\[28:18\\] in standard, ID\\[28:18\\]
in extended"] in extended"]
pub struct BM1_R(crate::FieldReader<u16, u16>); pub type Bm1R = crate::FieldReader<u16>;
impl BM1_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
BM1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BM1_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BM1` writer - BM\\[28:18\\] #[doc = "Field `BM1` writer - BM\\[28:18\\]
- ID\\[10:0\\] - ID\\[10:0\\]
in standard, ID\\[28:18\\] in standard, ID\\[28:18\\]
in extended"] in extended"]
pub struct BM1_W<'a> { pub type Bm1W<'a, REG> = crate::FieldWriter<'a, REG, 11, u16>;
w: &'a mut W,
}
impl<'a> BM1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x07ff << 5)) | ((value as u32 & 0x07ff) << 5);
self.w
}
}
#[doc = "Field `RTR` reader - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
pub struct RTR_R(crate::FieldReader<bool, bool>);
impl RTR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
RTR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RTR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `RTR` writer - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
pub struct RTR_W<'a> {
w: &'a mut W,
}
impl<'a> RTR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
self.w
}
}
#[doc = "Field `IDE` reader - Identifier Extension Bit"]
pub struct IDE_R(crate::FieldReader<bool, bool>);
impl IDE_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
IDE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for IDE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `IDE` writer - Identifier Extension Bit"]
pub struct IDE_W<'a> {
w: &'a mut W,
}
impl<'a> IDE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "Field `BM0` reader - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
pub struct BM0_R(crate::FieldReader<u8, u8>);
impl BM0_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BM0_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BM0_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BM0` writer - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
pub struct BM0_W<'a> {
w: &'a mut W,
}
impl<'a> BM0_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0x07) | (value as u32 & 0x07);
self.w
}
}
impl R { impl R {
#[doc = "Bits 0:2 - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
#[inline(always)]
pub fn bm0(&self) -> Bm0R {
Bm0R::new((self.bits & 7) as u8)
}
#[doc = "Bit 3 - Identifier Extension Bit"]
#[inline(always)]
pub fn ide(&self) -> IdeR {
IdeR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
#[inline(always)]
pub fn rtr(&self) -> RtrR {
RtrR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bits 5:15 - BM\\[28:18\\] #[doc = "Bits 5:15 - BM\\[28:18\\]
- ID\\[10:0\\] - ID\\[10:0\\]
in standard, ID\\[28:18\\] in standard, ID\\[28:18\\]
in extended"] in extended"]
#[inline(always)] #[inline(always)]
pub fn bm1(&self) -> BM1_R { pub fn bm1(&self) -> Bm1R {
BM1_R::new(((self.bits >> 5) & 0x07ff) as u16) Bm1R::new(((self.bits >> 5) & 0x07ff) as u16)
}
#[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
#[inline(always)]
pub fn rtr(&self) -> RTR_R {
RTR_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Identifier Extension Bit"]
#[inline(always)]
pub fn ide(&self) -> IDE_R {
IDE_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bits 0:2 - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
#[inline(always)]
pub fn bm0(&self) -> BM0_R {
BM0_R::new((self.bits & 0x07) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 0:2 - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
#[inline(always)]
#[must_use]
pub fn bm0(&mut self) -> Bm0W<BmskbSpec> {
Bm0W::new(self, 0)
}
#[doc = "Bit 3 - Identifier Extension Bit"]
#[inline(always)]
#[must_use]
pub fn ide(&mut self) -> IdeW<BmskbSpec> {
IdeW::new(self, 3)
}
#[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
#[inline(always)]
#[must_use]
pub fn rtr(&mut self) -> RtrW<BmskbSpec> {
RtrW::new(self, 4)
}
#[doc = "Bits 5:15 - BM\\[28:18\\] #[doc = "Bits 5:15 - BM\\[28:18\\]
- ID\\[10:0\\] - ID\\[10:0\\]
in standard, ID\\[28:18\\] in standard, ID\\[28:18\\]
in extended"] in extended"]
#[inline(always)] #[inline(always)]
pub fn bm1(&mut self) -> BM1_W { #[must_use]
BM1_W { w: self } pub fn bm1(&mut self) -> Bm1W<BmskbSpec> {
} Bm1W::new(self, 5)
#[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
#[inline(always)]
pub fn rtr(&mut self) -> RTR_W {
RTR_W { w: self }
}
#[doc = "Bit 3 - Identifier Extension Bit"]
#[inline(always)]
pub fn ide(&mut self) -> IDE_W {
IDE_W { w: self }
}
#[doc = "Bits 0:2 - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
#[inline(always)]
pub fn bm0(&mut self) -> BM0_W {
BM0_W { w: self }
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "CAN Basic Mask Base\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [bmskb](index.html) module"] #[doc = "CAN Basic Mask Base\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`bmskb::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`bmskb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct BMSKB_SPEC; pub struct BmskbSpec;
impl crate::RegisterSpec for BMSKB_SPEC { impl crate::RegisterSpec for BmskbSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [bmskb::R](R) reader structure"] #[doc = "`read()` method returns [`bmskb::R`](R) reader structure"]
impl crate::Readable for BMSKB_SPEC { impl crate::Readable for BmskbSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`bmskb::W`](W) writer structure"]
} impl crate::Writable for BmskbSpec {
#[doc = "`write(|w| ..)` method takes [bmskb::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for BMSKB_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets BMSKB to value 0"] #[doc = "`reset()` method sets BMSKB to value 0"]
impl crate::Resettable for BMSKB_SPEC { impl crate::Resettable for BmskbSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

167
va416xx/src/can0/bmskx.rs
View File

@ -1,158 +1,63 @@
#[doc = "Register `BMSKX` reader"] #[doc = "Register `BMSKX` reader"]
pub struct R(crate::R<BMSKX_SPEC>); pub type R = crate::R<BmskxSpec>;
impl core::ops::Deref for R {
type Target = crate::R<BMSKX_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<BMSKX_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<BMSKX_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `BMSKX` writer"] #[doc = "Register `BMSKX` writer"]
pub struct W(crate::W<BMSKX_SPEC>); pub type W = crate::W<BmskxSpec>;
impl core::ops::Deref for W { #[doc = "Field `XRTR` reader - Extended Remote transmission Request Bit"]
type Target = crate::W<BMSKX_SPEC>; pub type XrtrR = crate::BitReader;
#[inline(always)] #[doc = "Field `XRTR` writer - Extended Remote transmission Request Bit"]
fn deref(&self) -> &Self::Target { pub type XrtrW<'a, REG> = crate::BitWriter<'a, REG>;
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<BMSKX_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<BMSKX_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BM` reader - BM\\[14:0\\] #[doc = "Field `BM` reader - BM\\[14:0\\]
used when an extended frame is received. ID\\[14:0\\] used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"] in extended, unused standard"]
pub struct BM_R(crate::FieldReader<u16, u16>); pub type BmR = crate::FieldReader<u16>;
impl BM_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
BM_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BM_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BM` writer - BM\\[14:0\\] #[doc = "Field `BM` writer - BM\\[14:0\\]
used when an extended frame is received. ID\\[14:0\\] used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"] in extended, unused standard"]
pub struct BM_W<'a> { pub type BmW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
w: &'a mut W,
}
impl<'a> BM_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x7fff << 1)) | ((value as u32 & 0x7fff) << 1);
self.w
}
}
#[doc = "Field `XRTR` reader - Extended Remote transmission Request Bit"]
pub struct XRTR_R(crate::FieldReader<bool, bool>);
impl XRTR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
XRTR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for XRTR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `XRTR` writer - Extended Remote transmission Request Bit"]
pub struct XRTR_W<'a> {
w: &'a mut W,
}
impl<'a> XRTR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
self.w
}
}
impl R { impl R {
#[doc = "Bit 0 - Extended Remote transmission Request Bit"]
#[inline(always)]
pub fn xrtr(&self) -> XrtrR {
XrtrR::new((self.bits & 1) != 0)
}
#[doc = "Bits 1:15 - BM\\[14:0\\] #[doc = "Bits 1:15 - BM\\[14:0\\]
used when an extended frame is received. ID\\[14:0\\] used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"] in extended, unused standard"]
#[inline(always)] #[inline(always)]
pub fn bm(&self) -> BM_R { pub fn bm(&self) -> BmR {
BM_R::new(((self.bits >> 1) & 0x7fff) as u16) BmR::new(((self.bits >> 1) & 0x7fff) as u16)
}
#[doc = "Bit 0 - Extended Remote transmission Request Bit"]
#[inline(always)]
pub fn xrtr(&self) -> XRTR_R {
XRTR_R::new((self.bits & 0x01) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 0 - Extended Remote transmission Request Bit"]
#[inline(always)]
#[must_use]
pub fn xrtr(&mut self) -> XrtrW<BmskxSpec> {
XrtrW::new(self, 0)
}
#[doc = "Bits 1:15 - BM\\[14:0\\] #[doc = "Bits 1:15 - BM\\[14:0\\]
used when an extended frame is received. ID\\[14:0\\] used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"] in extended, unused standard"]
#[inline(always)] #[inline(always)]
pub fn bm(&mut self) -> BM_W { #[must_use]
BM_W { w: self } pub fn bm(&mut self) -> BmW<BmskxSpec> {
} BmW::new(self, 1)
#[doc = "Bit 0 - Extended Remote transmission Request Bit"]
#[inline(always)]
pub fn xrtr(&mut self) -> XRTR_W {
XRTR_W { w: self }
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "CAN Basic Mask Extension\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [bmskx](index.html) module"] #[doc = "CAN Basic Mask Extension\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`bmskx::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`bmskx::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct BMSKX_SPEC; pub struct BmskxSpec;
impl crate::RegisterSpec for BMSKX_SPEC { impl crate::RegisterSpec for BmskxSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [bmskx::R](R) reader structure"] #[doc = "`read()` method returns [`bmskx::R`](R) reader structure"]
impl crate::Readable for BMSKX_SPEC { impl crate::Readable for BmskxSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`bmskx::W`](W) writer structure"]
} impl crate::Writable for BmskxSpec {
#[doc = "`write(|w| ..)` method takes [bmskx::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for BMSKX_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets BMSKX to value 0"] #[doc = "`reset()` method sets BMSKX to value 0"]
impl crate::Resettable for BMSKX_SPEC { impl crate::Resettable for BmskxSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/canec.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `CANEC` reader"] #[doc = "Register `CANEC` reader"]
pub struct R(crate::R<CANEC_SPEC>); pub type R = crate::R<CanecSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CANEC_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CANEC_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CANEC_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CANEC` writer"] #[doc = "Register `CANEC` writer"]
pub struct W(crate::W<CANEC_SPEC>); pub type W = crate::W<CanecSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CANEC_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CANEC_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CANEC_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `REC` reader - Receive Error Counter"]
pub struct REC_R(crate::FieldReader<u8, u8>);
impl REC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
REC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for REC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `REC` writer - Receive Error Counter"]
pub struct REC_W<'a> {
w: &'a mut W,
}
impl<'a> REC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `TEC` reader - Transmit Error Counter"] #[doc = "Field `TEC` reader - Transmit Error Counter"]
pub struct TEC_R(crate::FieldReader<u8, u8>); pub type TecR = crate::FieldReader;
impl TEC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
TEC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TEC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TEC` writer - Transmit Error Counter"] #[doc = "Field `TEC` writer - Transmit Error Counter"]
pub struct TEC_W<'a> { pub type TecW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `REC` reader - Receive Error Counter"]
} pub type RecR = crate::FieldReader;
impl<'a> TEC_W<'a> { #[doc = "Field `REC` writer - Receive Error Counter"]
#[doc = r"Writes raw bits to the field"] pub type RecW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Receive Error Counter"]
#[inline(always)]
pub fn rec(&self) -> REC_R {
REC_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Transmit Error Counter"] #[doc = "Bits 0:7 - Transmit Error Counter"]
#[inline(always)] #[inline(always)]
pub fn tec(&self) -> TEC_R { pub fn tec(&self) -> TecR {
TEC_R::new((self.bits & 0xff) as u8) TecR::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Receive Error Counter"]
#[inline(always)]
pub fn rec(&self) -> RecR {
RecR::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Receive Error Counter"]
#[inline(always)]
pub fn rec(&mut self) -> REC_W {
REC_W { w: self }
}
#[doc = "Bits 0:7 - Transmit Error Counter"] #[doc = "Bits 0:7 - Transmit Error Counter"]
#[inline(always)] #[inline(always)]
pub fn tec(&mut self) -> TEC_W { #[must_use]
TEC_W { w: self } pub fn tec(&mut self) -> TecW<CanecSpec> {
TecW::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Receive Error Counter"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn rec(&mut self) -> RecW<CanecSpec> {
self RecW::new(self, 8)
} }
} }
#[doc = "CAN Error Counter Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [canec](index.html) module"] #[doc = "CAN Error Counter Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`canec::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`canec::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CANEC_SPEC; pub struct CanecSpec;
impl crate::RegisterSpec for CANEC_SPEC { impl crate::RegisterSpec for CanecSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [canec::R](R) reader structure"] #[doc = "`read()` method returns [`canec::R`](R) reader structure"]
impl crate::Readable for CANEC_SPEC { impl crate::Readable for CanecSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`canec::W`](W) writer structure"]
} impl crate::Writable for CanecSpec {
#[doc = "`write(|w| ..)` method takes [canec::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CANEC_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CANEC to value 0"] #[doc = "`reset()` method sets CANEC to value 0"]
impl crate::Resettable for CANEC_SPEC { impl crate::Resettable for CanecSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

447
va416xx/src/can0/cediag.rs
View File

@ -1,375 +1,130 @@
#[doc = "Register `CEDIAG` reader"] #[doc = "Register `CEDIAG` reader"]
pub struct R(crate::R<CEDIAG_SPEC>); pub type R = crate::R<CediagSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CEDIAG_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CEDIAG_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CEDIAG_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CEDIAG` writer"] #[doc = "Register `CEDIAG` writer"]
pub struct W(crate::W<CEDIAG_SPEC>); pub type W = crate::W<CediagSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CEDIAG_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CEDIAG_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CEDIAG_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DRIVE` reader - Drive"]
pub struct DRIVE_R(crate::FieldReader<bool, bool>);
impl DRIVE_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
DRIVE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DRIVE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DRIVE` writer - Drive"]
pub struct DRIVE_W<'a> {
w: &'a mut W,
}
impl<'a> DRIVE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
self.w
}
}
#[doc = "Field `MON` reader - Monitor"]
pub struct MON_R(crate::FieldReader<bool, bool>);
impl MON_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
MON_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for MON_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `MON` writer - Monitor"]
pub struct MON_W<'a> {
w: &'a mut W,
}
impl<'a> MON_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
self.w
}
}
#[doc = "Field `CRC` reader - CRC"]
pub struct CRC_R(crate::FieldReader<bool, bool>);
impl CRC_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
CRC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CRC_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CRC` writer - CRC"]
pub struct CRC_W<'a> {
w: &'a mut W,
}
impl<'a> CRC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
self.w
}
}
#[doc = "Field `STUFF` reader - Stuff Error"]
pub struct STUFF_R(crate::FieldReader<bool, bool>);
impl STUFF_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
STUFF_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for STUFF_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `STUFF` writer - Stuff Error"]
pub struct STUFF_W<'a> {
w: &'a mut W,
}
impl<'a> STUFF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
self.w
}
}
#[doc = "Field `TXE` reader - Transmit Error"]
pub struct TXE_R(crate::FieldReader<bool, bool>);
impl TXE_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
TXE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TXE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TXE` writer - Transmit Error"]
pub struct TXE_W<'a> {
w: &'a mut W,
}
impl<'a> TXE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
self.w
}
}
#[doc = "Field `EBID` reader - Error Bit Identifier"]
pub struct EBID_R(crate::FieldReader<u8, u8>);
impl EBID_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
EBID_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EBID_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EBID` writer - Error Bit Identifier"]
pub struct EBID_W<'a> {
w: &'a mut W,
}
impl<'a> EBID_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x3f << 4)) | ((value as u32 & 0x3f) << 4);
self.w
}
}
#[doc = "Field `EFID` reader - Error Field Identifier"] #[doc = "Field `EFID` reader - Error Field Identifier"]
pub struct EFID_R(crate::FieldReader<u8, u8>); pub type EfidR = crate::FieldReader;
impl EFID_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
EFID_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EFID_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EFID` writer - Error Field Identifier"] #[doc = "Field `EFID` writer - Error Field Identifier"]
pub struct EFID_W<'a> { pub type EfidW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `EBID` reader - Error Bit Identifier"]
} pub type EbidR = crate::FieldReader;
impl<'a> EFID_W<'a> { #[doc = "Field `EBID` writer - Error Bit Identifier"]
#[doc = r"Writes raw bits to the field"] pub type EbidW<'a, REG> = crate::FieldWriter<'a, REG, 6>;
#[inline(always)] #[doc = "Field `TXE` reader - Transmit Error"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type TxeR = crate::BitReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `TXE` writer - Transmit Error"]
self.w pub type TxeW<'a, REG> = crate::BitWriter<'a, REG>;
} #[doc = "Field `STUFF` reader - Stuff Error"]
} pub type StuffR = crate::BitReader;
#[doc = "Field `STUFF` writer - Stuff Error"]
pub type StuffW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `CRC` reader - CRC"]
pub type CrcR = crate::BitReader;
#[doc = "Field `CRC` writer - CRC"]
pub type CrcW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `MON` reader - Monitor"]
pub type MonR = crate::BitReader;
#[doc = "Field `MON` writer - Monitor"]
pub type MonW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `DRIVE` reader - Drive"]
pub type DriveR = crate::BitReader;
#[doc = "Field `DRIVE` writer - Drive"]
pub type DriveW<'a, REG> = crate::BitWriter<'a, REG>;
impl R { impl R {
#[doc = "Bit 14 - Drive"] #[doc = "Bits 0:3 - Error Field Identifier"]
#[inline(always)] #[inline(always)]
pub fn drive(&self) -> DRIVE_R { pub fn efid(&self) -> EfidR {
DRIVE_R::new(((self.bits >> 14) & 0x01) != 0) EfidR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bit 13 - Monitor"]
#[inline(always)]
pub fn mon(&self) -> MON_R {
MON_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 12 - CRC"]
#[inline(always)]
pub fn crc(&self) -> CRC_R {
CRC_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 11 - Stuff Error"]
#[inline(always)]
pub fn stuff(&self) -> STUFF_R {
STUFF_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - Transmit Error"]
#[inline(always)]
pub fn txe(&self) -> TXE_R {
TXE_R::new(((self.bits >> 10) & 0x01) != 0)
} }
#[doc = "Bits 4:9 - Error Bit Identifier"] #[doc = "Bits 4:9 - Error Bit Identifier"]
#[inline(always)] #[inline(always)]
pub fn ebid(&self) -> EBID_R { pub fn ebid(&self) -> EbidR {
EBID_R::new(((self.bits >> 4) & 0x3f) as u8) EbidR::new(((self.bits >> 4) & 0x3f) as u8)
} }
#[doc = "Bits 0:3 - Error Field Identifier"] #[doc = "Bit 10 - Transmit Error"]
#[inline(always)] #[inline(always)]
pub fn efid(&self) -> EFID_R { pub fn txe(&self) -> TxeR {
EFID_R::new((self.bits & 0x0f) as u8) TxeR::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - Stuff Error"]
#[inline(always)]
pub fn stuff(&self) -> StuffR {
StuffR::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - CRC"]
#[inline(always)]
pub fn crc(&self) -> CrcR {
CrcR::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - Monitor"]
#[inline(always)]
pub fn mon(&self) -> MonR {
MonR::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - Drive"]
#[inline(always)]
pub fn drive(&self) -> DriveR {
DriveR::new(((self.bits >> 14) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 14 - Drive"] #[doc = "Bits 0:3 - Error Field Identifier"]
#[inline(always)] #[inline(always)]
pub fn drive(&mut self) -> DRIVE_W { #[must_use]
DRIVE_W { w: self } pub fn efid(&mut self) -> EfidW<CediagSpec> {
} EfidW::new(self, 0)
#[doc = "Bit 13 - Monitor"]
#[inline(always)]
pub fn mon(&mut self) -> MON_W {
MON_W { w: self }
}
#[doc = "Bit 12 - CRC"]
#[inline(always)]
pub fn crc(&mut self) -> CRC_W {
CRC_W { w: self }
}
#[doc = "Bit 11 - Stuff Error"]
#[inline(always)]
pub fn stuff(&mut self) -> STUFF_W {
STUFF_W { w: self }
}
#[doc = "Bit 10 - Transmit Error"]
#[inline(always)]
pub fn txe(&mut self) -> TXE_W {
TXE_W { w: self }
} }
#[doc = "Bits 4:9 - Error Bit Identifier"] #[doc = "Bits 4:9 - Error Bit Identifier"]
#[inline(always)] #[inline(always)]
pub fn ebid(&mut self) -> EBID_W { #[must_use]
EBID_W { w: self } pub fn ebid(&mut self) -> EbidW<CediagSpec> {
EbidW::new(self, 4)
} }
#[doc = "Bits 0:3 - Error Field Identifier"] #[doc = "Bit 10 - Transmit Error"]
#[inline(always)] #[inline(always)]
pub fn efid(&mut self) -> EFID_W { #[must_use]
EFID_W { w: self } pub fn txe(&mut self) -> TxeW<CediagSpec> {
TxeW::new(self, 10)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 11 - Stuff Error"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn stuff(&mut self) -> StuffW<CediagSpec> {
self StuffW::new(self, 11)
}
#[doc = "Bit 12 - CRC"]
#[inline(always)]
#[must_use]
pub fn crc(&mut self) -> CrcW<CediagSpec> {
CrcW::new(self, 12)
}
#[doc = "Bit 13 - Monitor"]
#[inline(always)]
#[must_use]
pub fn mon(&mut self) -> MonW<CediagSpec> {
MonW::new(self, 13)
}
#[doc = "Bit 14 - Drive"]
#[inline(always)]
#[must_use]
pub fn drive(&mut self) -> DriveW<CediagSpec> {
DriveW::new(self, 14)
} }
} }
#[doc = "CAN Error Diagnostic Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cediag](index.html) module"] #[doc = "CAN Error Diagnostic Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cediag::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cediag::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CEDIAG_SPEC; pub struct CediagSpec;
impl crate::RegisterSpec for CEDIAG_SPEC { impl crate::RegisterSpec for CediagSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cediag::R](R) reader structure"] #[doc = "`read()` method returns [`cediag::R`](R) reader structure"]
impl crate::Readable for CEDIAG_SPEC { impl crate::Readable for CediagSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cediag::W`](W) writer structure"]
} impl crate::Writable for CediagSpec {
#[doc = "`write(|w| ..)` method takes [cediag::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CEDIAG_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CEDIAG to value 0"] #[doc = "`reset()` method sets CEDIAG to value 0"]
impl crate::Resettable for CEDIAG_SPEC { impl crate::Resettable for CediagSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

777
va416xx/src/can0/cgcr.rs
View File

@ -1,630 +1,205 @@
#[doc = "Register `CGCR` reader"] #[doc = "Register `CGCR` reader"]
pub struct R(crate::R<CGCR_SPEC>); pub type R = crate::R<CgcrSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CGCR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CGCR_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CGCR_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CGCR` writer"] #[doc = "Register `CGCR` writer"]
pub struct W(crate::W<CGCR_SPEC>); pub type W = crate::W<CgcrSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CGCR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CGCR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CGCR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `EIT` reader - Error Interrupt Type"]
pub struct EIT_R(crate::FieldReader<bool, bool>);
impl EIT_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
EIT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EIT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EIT` writer - Error Interrupt Type"]
pub struct EIT_W<'a> {
w: &'a mut W,
}
impl<'a> EIT_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
self.w
}
}
#[doc = "Field `DIAGEN` reader - Diagnostic Enable"]
pub struct DIAGEN_R(crate::FieldReader<bool, bool>);
impl DIAGEN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
DIAGEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DIAGEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DIAGEN` writer - Diagnostic Enable"]
pub struct DIAGEN_W<'a> {
w: &'a mut W,
}
impl<'a> DIAGEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
self.w
}
}
#[doc = "Field `INTERNAL` reader - Internal"]
pub struct INTERNAL_R(crate::FieldReader<bool, bool>);
impl INTERNAL_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
INTERNAL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for INTERNAL_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `INTERNAL` writer - Internal"]
pub struct INTERNAL_W<'a> {
w: &'a mut W,
}
impl<'a> INTERNAL_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
self.w
}
}
#[doc = "Field `LOOPBACK` reader - Loopback"]
pub struct LOOPBACK_R(crate::FieldReader<bool, bool>);
impl LOOPBACK_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
LOOPBACK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LOOPBACK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LOOPBACK` writer - Loopback"]
pub struct LOOPBACK_W<'a> {
w: &'a mut W,
}
impl<'a> LOOPBACK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
self.w
}
}
#[doc = "Field `IGNACK` reader - Ignore Acknowledge"]
pub struct IGNACK_R(crate::FieldReader<bool, bool>);
impl IGNACK_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
IGNACK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for IGNACK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `IGNACK` writer - Ignore Acknowledge"]
pub struct IGNACK_W<'a> {
w: &'a mut W,
}
impl<'a> IGNACK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
self.w
}
}
#[doc = "Field `LO` reader - Listen Only"]
pub struct LO_R(crate::FieldReader<bool, bool>);
impl LO_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
LO_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LO_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LO` writer - Listen Only"]
pub struct LO_W<'a> {
w: &'a mut W,
}
impl<'a> LO_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
self.w
}
}
#[doc = "Field `DDIR` reader - Data Direction"]
pub struct DDIR_R(crate::FieldReader<bool, bool>);
impl DDIR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
DDIR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DDIR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DDIR` writer - Data Direction"]
pub struct DDIR_W<'a> {
w: &'a mut W,
}
impl<'a> DDIR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
self.w
}
}
#[doc = "Field `TSTPEN` reader - Time Sync Enable"]
pub struct TSTPEN_R(crate::FieldReader<bool, bool>);
impl TSTPEN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
TSTPEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TSTPEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TSTPEN` writer - Time Sync Enable"]
pub struct TSTPEN_W<'a> {
w: &'a mut W,
}
impl<'a> TSTPEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
self.w
}
}
#[doc = "Field `BUFFLOCK` reader - Buffer Lock"]
pub struct BUFFLOCK_R(crate::FieldReader<bool, bool>);
impl BUFFLOCK_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
BUFFLOCK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BUFFLOCK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BUFFLOCK` writer - Buffer Lock"]
pub struct BUFFLOCK_W<'a> {
w: &'a mut W,
}
impl<'a> BUFFLOCK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "Field `CTX` reader - RW,Control Transmit"]
pub struct CTX_R(crate::FieldReader<bool, bool>);
impl CTX_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
CTX_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CTX_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CTX` writer - RW,Control Transmit"]
pub struct CTX_W<'a> {
w: &'a mut W,
}
impl<'a> CTX_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
self.w
}
}
#[doc = "Field `CRX` reader - RW,Control Receive"]
pub struct CRX_R(crate::FieldReader<bool, bool>);
impl CRX_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
CRX_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CRX_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CRX` writer - RW,Control Receive"]
pub struct CRX_W<'a> {
w: &'a mut W,
}
impl<'a> CRX_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "Field `CANEN` reader - CAN Enable"] #[doc = "Field `CANEN` reader - CAN Enable"]
pub struct CANEN_R(crate::FieldReader<bool, bool>); pub type CanenR = crate::BitReader;
impl CANEN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
CANEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CANEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CANEN` writer - CAN Enable"] #[doc = "Field `CANEN` writer - CAN Enable"]
pub struct CANEN_W<'a> { pub type CanenW<'a, REG> = crate::BitWriter<'a, REG>;
w: &'a mut W, #[doc = "Field `CRX` reader - RW,Control Receive"]
} pub type CrxR = crate::BitReader;
impl<'a> CANEN_W<'a> { #[doc = "Field `CRX` writer - RW,Control Receive"]
#[doc = r"Sets the field bit"] pub type CrxW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)] #[doc = "Field `CTX` reader - RW,Control Transmit"]
pub fn set_bit(self) -> &'a mut W { pub type CtxR = crate::BitReader;
self.bit(true) #[doc = "Field `CTX` writer - RW,Control Transmit"]
} pub type CtxW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = r"Clears the field bit"] #[doc = "Field `BUFFLOCK` reader - Buffer Lock"]
#[inline(always)] pub type BufflockR = crate::BitReader;
pub fn clear_bit(self) -> &'a mut W { #[doc = "Field `BUFFLOCK` writer - Buffer Lock"]
self.bit(false) pub type BufflockW<'a, REG> = crate::BitWriter<'a, REG>;
} #[doc = "Field `TSTPEN` reader - Time Sync Enable"]
#[doc = r"Writes raw bits to the field"] pub type TstpenR = crate::BitReader;
#[inline(always)] #[doc = "Field `TSTPEN` writer - Time Sync Enable"]
pub fn bit(self, value: bool) -> &'a mut W { pub type TstpenW<'a, REG> = crate::BitWriter<'a, REG>;
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01); #[doc = "Field `DDIR` reader - Data Direction"]
self.w pub type DdirR = crate::BitReader;
} #[doc = "Field `DDIR` writer - Data Direction"]
} pub type DdirW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `LO` reader - Listen Only"]
pub type LoR = crate::BitReader;
#[doc = "Field `LO` writer - Listen Only"]
pub type LoW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `IGNACK` reader - Ignore Acknowledge"]
pub type IgnackR = crate::BitReader;
#[doc = "Field `IGNACK` writer - Ignore Acknowledge"]
pub type IgnackW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `LOOPBACK` reader - Loopback"]
pub type LoopbackR = crate::BitReader;
#[doc = "Field `LOOPBACK` writer - Loopback"]
pub type LoopbackW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `INTERNAL` reader - Internal"]
pub type InternalR = crate::BitReader;
#[doc = "Field `INTERNAL` writer - Internal"]
pub type InternalW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `DIAGEN` reader - Diagnostic Enable"]
pub type DiagenR = crate::BitReader;
#[doc = "Field `DIAGEN` writer - Diagnostic Enable"]
pub type DiagenW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `EIT` reader - Error Interrupt Type"]
pub type EitR = crate::BitReader;
#[doc = "Field `EIT` writer - Error Interrupt Type"]
pub type EitW<'a, REG> = crate::BitWriter<'a, REG>;
impl R { impl R {
#[doc = "Bit 11 - Error Interrupt Type"] #[doc = "Bit 0 - CAN Enable"]
#[inline(always)] #[inline(always)]
pub fn eit(&self) -> EIT_R { pub fn canen(&self) -> CanenR {
EIT_R::new(((self.bits >> 11) & 0x01) != 0) CanenR::new((self.bits & 1) != 0)
}
#[doc = "Bit 10 - Diagnostic Enable"]
#[inline(always)]
pub fn diagen(&self) -> DIAGEN_R {
DIAGEN_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Internal"]
#[inline(always)]
pub fn internal(&self) -> INTERNAL_R {
INTERNAL_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - Loopback"]
#[inline(always)]
pub fn loopback(&self) -> LOOPBACK_R {
LOOPBACK_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - Ignore Acknowledge"]
#[inline(always)]
pub fn ignack(&self) -> IGNACK_R {
IGNACK_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - Listen Only"]
#[inline(always)]
pub fn lo(&self) -> LO_R {
LO_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - Data Direction"]
#[inline(always)]
pub fn ddir(&self) -> DDIR_R {
DDIR_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Time Sync Enable"]
#[inline(always)]
pub fn tstpen(&self) -> TSTPEN_R {
TSTPEN_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Buffer Lock"]
#[inline(always)]
pub fn bufflock(&self) -> BUFFLOCK_R {
BUFFLOCK_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - RW,Control Transmit"]
#[inline(always)]
pub fn ctx(&self) -> CTX_R {
CTX_R::new(((self.bits >> 2) & 0x01) != 0)
} }
#[doc = "Bit 1 - RW,Control Receive"] #[doc = "Bit 1 - RW,Control Receive"]
#[inline(always)] #[inline(always)]
pub fn crx(&self) -> CRX_R { pub fn crx(&self) -> CrxR {
CRX_R::new(((self.bits >> 1) & 0x01) != 0) CrxR::new(((self.bits >> 1) & 1) != 0)
} }
#[doc = "Bit 0 - CAN Enable"] #[doc = "Bit 2 - RW,Control Transmit"]
#[inline(always)] #[inline(always)]
pub fn canen(&self) -> CANEN_R { pub fn ctx(&self) -> CtxR {
CANEN_R::new((self.bits & 0x01) != 0) CtxR::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - Buffer Lock"]
#[inline(always)]
pub fn bufflock(&self) -> BufflockR {
BufflockR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Time Sync Enable"]
#[inline(always)]
pub fn tstpen(&self) -> TstpenR {
TstpenR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - Data Direction"]
#[inline(always)]
pub fn ddir(&self) -> DdirR {
DdirR::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - Listen Only"]
#[inline(always)]
pub fn lo(&self) -> LoR {
LoR::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - Ignore Acknowledge"]
#[inline(always)]
pub fn ignack(&self) -> IgnackR {
IgnackR::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - Loopback"]
#[inline(always)]
pub fn loopback(&self) -> LoopbackR {
LoopbackR::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Internal"]
#[inline(always)]
pub fn internal(&self) -> InternalR {
InternalR::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - Diagnostic Enable"]
#[inline(always)]
pub fn diagen(&self) -> DiagenR {
DiagenR::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - Error Interrupt Type"]
#[inline(always)]
pub fn eit(&self) -> EitR {
EitR::new(((self.bits >> 11) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 11 - Error Interrupt Type"] #[doc = "Bit 0 - CAN Enable"]
#[inline(always)] #[inline(always)]
pub fn eit(&mut self) -> EIT_W { #[must_use]
EIT_W { w: self } pub fn canen(&mut self) -> CanenW<CgcrSpec> {
} CanenW::new(self, 0)
#[doc = "Bit 10 - Diagnostic Enable"]
#[inline(always)]
pub fn diagen(&mut self) -> DIAGEN_W {
DIAGEN_W { w: self }
}
#[doc = "Bit 9 - Internal"]
#[inline(always)]
pub fn internal(&mut self) -> INTERNAL_W {
INTERNAL_W { w: self }
}
#[doc = "Bit 8 - Loopback"]
#[inline(always)]
pub fn loopback(&mut self) -> LOOPBACK_W {
LOOPBACK_W { w: self }
}
#[doc = "Bit 7 - Ignore Acknowledge"]
#[inline(always)]
pub fn ignack(&mut self) -> IGNACK_W {
IGNACK_W { w: self }
}
#[doc = "Bit 6 - Listen Only"]
#[inline(always)]
pub fn lo(&mut self) -> LO_W {
LO_W { w: self }
}
#[doc = "Bit 5 - Data Direction"]
#[inline(always)]
pub fn ddir(&mut self) -> DDIR_W {
DDIR_W { w: self }
}
#[doc = "Bit 4 - Time Sync Enable"]
#[inline(always)]
pub fn tstpen(&mut self) -> TSTPEN_W {
TSTPEN_W { w: self }
}
#[doc = "Bit 3 - Buffer Lock"]
#[inline(always)]
pub fn bufflock(&mut self) -> BUFFLOCK_W {
BUFFLOCK_W { w: self }
}
#[doc = "Bit 2 - RW,Control Transmit"]
#[inline(always)]
pub fn ctx(&mut self) -> CTX_W {
CTX_W { w: self }
} }
#[doc = "Bit 1 - RW,Control Receive"] #[doc = "Bit 1 - RW,Control Receive"]
#[inline(always)] #[inline(always)]
pub fn crx(&mut self) -> CRX_W { #[must_use]
CRX_W { w: self } pub fn crx(&mut self) -> CrxW<CgcrSpec> {
CrxW::new(self, 1)
} }
#[doc = "Bit 0 - CAN Enable"] #[doc = "Bit 2 - RW,Control Transmit"]
#[inline(always)] #[inline(always)]
pub fn canen(&mut self) -> CANEN_W { #[must_use]
CANEN_W { w: self } pub fn ctx(&mut self) -> CtxW<CgcrSpec> {
CtxW::new(self, 2)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 3 - Buffer Lock"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn bufflock(&mut self) -> BufflockW<CgcrSpec> {
self BufflockW::new(self, 3)
}
#[doc = "Bit 4 - Time Sync Enable"]
#[inline(always)]
#[must_use]
pub fn tstpen(&mut self) -> TstpenW<CgcrSpec> {
TstpenW::new(self, 4)
}
#[doc = "Bit 5 - Data Direction"]
#[inline(always)]
#[must_use]
pub fn ddir(&mut self) -> DdirW<CgcrSpec> {
DdirW::new(self, 5)
}
#[doc = "Bit 6 - Listen Only"]
#[inline(always)]
#[must_use]
pub fn lo(&mut self) -> LoW<CgcrSpec> {
LoW::new(self, 6)
}
#[doc = "Bit 7 - Ignore Acknowledge"]
#[inline(always)]
#[must_use]
pub fn ignack(&mut self) -> IgnackW<CgcrSpec> {
IgnackW::new(self, 7)
}
#[doc = "Bit 8 - Loopback"]
#[inline(always)]
#[must_use]
pub fn loopback(&mut self) -> LoopbackW<CgcrSpec> {
LoopbackW::new(self, 8)
}
#[doc = "Bit 9 - Internal"]
#[inline(always)]
#[must_use]
pub fn internal(&mut self) -> InternalW<CgcrSpec> {
InternalW::new(self, 9)
}
#[doc = "Bit 10 - Diagnostic Enable"]
#[inline(always)]
#[must_use]
pub fn diagen(&mut self) -> DiagenW<CgcrSpec> {
DiagenW::new(self, 10)
}
#[doc = "Bit 11 - Error Interrupt Type"]
#[inline(always)]
#[must_use]
pub fn eit(&mut self) -> EitW<CgcrSpec> {
EitW::new(self, 11)
} }
} }
#[doc = "CAN Global Configuration Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cgcr](index.html) module"] #[doc = "CAN Global Configuration Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cgcr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cgcr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CGCR_SPEC; pub struct CgcrSpec;
impl crate::RegisterSpec for CGCR_SPEC { impl crate::RegisterSpec for CgcrSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cgcr::R](R) reader structure"] #[doc = "`read()` method returns [`cgcr::R`](R) reader structure"]
impl crate::Readable for CGCR_SPEC { impl crate::Readable for CgcrSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cgcr::W`](W) writer structure"]
} impl crate::Writable for CgcrSpec {
#[doc = "`write(|w| ..)` method takes [cgcr::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CGCR_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CGCR to value 0"] #[doc = "`reset()` method sets CGCR to value 0"]
impl crate::Resettable for CGCR_SPEC { impl crate::Resettable for CgcrSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

163
va416xx/src/can0/cicen.rs
View File

@ -1,150 +1,55 @@
#[doc = "Register `CICEN` reader"] #[doc = "Register `CICEN` reader"]
pub struct R(crate::R<CICEN_SPEC>); pub type R = crate::R<CicenSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CICEN_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CICEN_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CICEN_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CICEN` writer"] #[doc = "Register `CICEN` writer"]
pub struct W(crate::W<CICEN_SPEC>); pub type W = crate::W<CicenSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CICEN_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CICEN_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CICEN_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `EICEN` reader - Error Interrupt Code Enable"]
pub struct EICEN_R(crate::FieldReader<bool, bool>);
impl EICEN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
EICEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EICEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EICEN` writer - Error Interrupt Code Enable"]
pub struct EICEN_W<'a> {
w: &'a mut W,
}
impl<'a> EICEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
self.w
}
}
#[doc = "Field `ICEN` reader - Buffer Interrupt Code Enable\\[14:0\\]"] #[doc = "Field `ICEN` reader - Buffer Interrupt Code Enable\\[14:0\\]"]
pub struct ICEN_R(crate::FieldReader<u16, u16>); pub type IcenR = crate::FieldReader<u16>;
impl ICEN_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
ICEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ICEN_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ICEN` writer - Buffer Interrupt Code Enable\\[14:0\\]"] #[doc = "Field `ICEN` writer - Buffer Interrupt Code Enable\\[14:0\\]"]
pub struct ICEN_W<'a> { pub type IcenW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
w: &'a mut W, #[doc = "Field `EICEN` reader - Error Interrupt Code Enable"]
} pub type EicenR = crate::BitReader;
impl<'a> ICEN_W<'a> { #[doc = "Field `EICEN` writer - Error Interrupt Code Enable"]
#[doc = r"Writes raw bits to the field"] pub type EicenW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
self.w
}
}
impl R { impl R {
#[doc = "Bit 15 - Error Interrupt Code Enable"]
#[inline(always)]
pub fn eicen(&self) -> EICEN_R {
EICEN_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn icen(&self) -> ICEN_R { pub fn icen(&self) -> IcenR {
ICEN_R::new((self.bits & 0x7fff) as u16) IcenR::new((self.bits & 0x7fff) as u16)
}
#[doc = "Bit 15 - Error Interrupt Code Enable"]
#[inline(always)]
pub fn eicen(&self) -> EicenR {
EicenR::new(((self.bits >> 15) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 15 - Error Interrupt Code Enable"]
#[inline(always)]
pub fn eicen(&mut self) -> EICEN_W {
EICEN_W { w: self }
}
#[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn icen(&mut self) -> ICEN_W { #[must_use]
ICEN_W { w: self } pub fn icen(&mut self) -> IcenW<CicenSpec> {
IcenW::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 15 - Error Interrupt Code Enable"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn eicen(&mut self) -> EicenW<CicenSpec> {
self EicenW::new(self, 15)
} }
} }
#[doc = "CAN Interrupt Code Enable Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cicen](index.html) module"] #[doc = "CAN Interrupt Code Enable Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cicen::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cicen::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CICEN_SPEC; pub struct CicenSpec;
impl crate::RegisterSpec for CICEN_SPEC { impl crate::RegisterSpec for CicenSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cicen::R](R) reader structure"] #[doc = "`read()` method returns [`cicen::R`](R) reader structure"]
impl crate::Readable for CICEN_SPEC { impl crate::Readable for CicenSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cicen::W`](W) writer structure"]
} impl crate::Writable for CicenSpec {
#[doc = "`write(|w| ..)` method takes [cicen::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CICEN_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CICEN to value 0"] #[doc = "`reset()` method sets CICEN to value 0"]
impl crate::Resettable for CICEN_SPEC { impl crate::Resettable for CicenSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

163
va416xx/src/can0/ciclr.rs
View File

@ -1,150 +1,55 @@
#[doc = "Register `CICLR` reader"] #[doc = "Register `CICLR` reader"]
pub struct R(crate::R<CICLR_SPEC>); pub type R = crate::R<CiclrSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CICLR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CICLR_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CICLR_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CICLR` writer"] #[doc = "Register `CICLR` writer"]
pub struct W(crate::W<CICLR_SPEC>); pub type W = crate::W<CiclrSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CICLR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CICLR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CICLR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `EICLR` reader - Error Interrupt Clear"]
pub struct EICLR_R(crate::FieldReader<bool, bool>);
impl EICLR_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
EICLR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EICLR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EICLR` writer - Error Interrupt Clear"]
pub struct EICLR_W<'a> {
w: &'a mut W,
}
impl<'a> EICLR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
self.w
}
}
#[doc = "Field `ICLR` reader - Buffer Interrupt Clear\\[14:0\\]"] #[doc = "Field `ICLR` reader - Buffer Interrupt Clear\\[14:0\\]"]
pub struct ICLR_R(crate::FieldReader<u16, u16>); pub type IclrR = crate::FieldReader<u16>;
impl ICLR_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
ICLR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ICLR_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ICLR` writer - Buffer Interrupt Clear\\[14:0\\]"] #[doc = "Field `ICLR` writer - Buffer Interrupt Clear\\[14:0\\]"]
pub struct ICLR_W<'a> { pub type IclrW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
w: &'a mut W, #[doc = "Field `EICLR` reader - Error Interrupt Clear"]
} pub type EiclrR = crate::BitReader;
impl<'a> ICLR_W<'a> { #[doc = "Field `EICLR` writer - Error Interrupt Clear"]
#[doc = r"Writes raw bits to the field"] pub type EiclrW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
self.w
}
}
impl R { impl R {
#[doc = "Bit 15 - Error Interrupt Clear"]
#[inline(always)]
pub fn eiclr(&self) -> EICLR_R {
EICLR_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn iclr(&self) -> ICLR_R { pub fn iclr(&self) -> IclrR {
ICLR_R::new((self.bits & 0x7fff) as u16) IclrR::new((self.bits & 0x7fff) as u16)
}
#[doc = "Bit 15 - Error Interrupt Clear"]
#[inline(always)]
pub fn eiclr(&self) -> EiclrR {
EiclrR::new(((self.bits >> 15) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 15 - Error Interrupt Clear"]
#[inline(always)]
pub fn eiclr(&mut self) -> EICLR_W {
EICLR_W { w: self }
}
#[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn iclr(&mut self) -> ICLR_W { #[must_use]
ICLR_W { w: self } pub fn iclr(&mut self) -> IclrW<CiclrSpec> {
IclrW::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 15 - Error Interrupt Clear"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn eiclr(&mut self) -> EiclrW<CiclrSpec> {
self EiclrW::new(self, 15)
} }
} }
#[doc = "CAN Interrupt Clear Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ciclr](index.html) module"] #[doc = "CAN Interrupt Clear Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ciclr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ciclr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CICLR_SPEC; pub struct CiclrSpec;
impl crate::RegisterSpec for CICLR_SPEC { impl crate::RegisterSpec for CiclrSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [ciclr::R](R) reader structure"] #[doc = "`read()` method returns [`ciclr::R`](R) reader structure"]
impl crate::Readable for CICLR_SPEC { impl crate::Readable for CiclrSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`ciclr::W`](W) writer structure"]
} impl crate::Writable for CiclrSpec {
#[doc = "`write(|w| ..)` method takes [ciclr::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CICLR_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CICLR to value 0"] #[doc = "`reset()` method sets CICLR to value 0"]
impl crate::Resettable for CICLR_SPEC { impl crate::Resettable for CiclrSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

163
va416xx/src/can0/cien.rs
View File

@ -1,150 +1,55 @@
#[doc = "Register `CIEN` reader"] #[doc = "Register `CIEN` reader"]
pub struct R(crate::R<CIEN_SPEC>); pub type R = crate::R<CienSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CIEN_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CIEN_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CIEN_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CIEN` writer"] #[doc = "Register `CIEN` writer"]
pub struct W(crate::W<CIEN_SPEC>); pub type W = crate::W<CienSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CIEN_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CIEN_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CIEN_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `EIEN` reader - Error Interrupt Enable"]
pub struct EIEN_R(crate::FieldReader<bool, bool>);
impl EIEN_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
EIEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EIEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EIEN` writer - Error Interrupt Enable"]
pub struct EIEN_W<'a> {
w: &'a mut W,
}
impl<'a> EIEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
self.w
}
}
#[doc = "Field `IEN` reader - Buffer Interrupt Enable\\[14:0\\]"] #[doc = "Field `IEN` reader - Buffer Interrupt Enable\\[14:0\\]"]
pub struct IEN_R(crate::FieldReader<u16, u16>); pub type IenR = crate::FieldReader<u16>;
impl IEN_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
IEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for IEN_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `IEN` writer - Buffer Interrupt Enable\\[14:0\\]"] #[doc = "Field `IEN` writer - Buffer Interrupt Enable\\[14:0\\]"]
pub struct IEN_W<'a> { pub type IenW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
w: &'a mut W, #[doc = "Field `EIEN` reader - Error Interrupt Enable"]
} pub type EienR = crate::BitReader;
impl<'a> IEN_W<'a> { #[doc = "Field `EIEN` writer - Error Interrupt Enable"]
#[doc = r"Writes raw bits to the field"] pub type EienW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
self.w
}
}
impl R { impl R {
#[doc = "Bit 15 - Error Interrupt Enable"]
#[inline(always)]
pub fn eien(&self) -> EIEN_R {
EIEN_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn ien(&self) -> IEN_R { pub fn ien(&self) -> IenR {
IEN_R::new((self.bits & 0x7fff) as u16) IenR::new((self.bits & 0x7fff) as u16)
}
#[doc = "Bit 15 - Error Interrupt Enable"]
#[inline(always)]
pub fn eien(&self) -> EienR {
EienR::new(((self.bits >> 15) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 15 - Error Interrupt Enable"]
#[inline(always)]
pub fn eien(&mut self) -> EIEN_W {
EIEN_W { w: self }
}
#[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn ien(&mut self) -> IEN_W { #[must_use]
IEN_W { w: self } pub fn ien(&mut self) -> IenW<CienSpec> {
IenW::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 15 - Error Interrupt Enable"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn eien(&mut self) -> EienW<CienSpec> {
self EienW::new(self, 15)
} }
} }
#[doc = "CAN Interrupt Enable Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cien](index.html) module"] #[doc = "CAN Interrupt Enable Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cien::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cien::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CIEN_SPEC; pub struct CienSpec;
impl crate::RegisterSpec for CIEN_SPEC { impl crate::RegisterSpec for CienSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cien::R](R) reader structure"] #[doc = "`read()` method returns [`cien::R`](R) reader structure"]
impl crate::Readable for CIEN_SPEC { impl crate::Readable for CienSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cien::W`](W) writer structure"]
} impl crate::Writable for CienSpec {
#[doc = "`write(|w| ..)` method takes [cien::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CIEN_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CIEN to value 0"] #[doc = "`reset()` method sets CIEN to value 0"]
impl crate::Resettable for CIEN_SPEC { impl crate::Resettable for CienSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

163
va416xx/src/can0/cipnd.rs
View File

@ -1,150 +1,55 @@
#[doc = "Register `CIPND` reader"] #[doc = "Register `CIPND` reader"]
pub struct R(crate::R<CIPND_SPEC>); pub type R = crate::R<CipndSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CIPND_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CIPND_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CIPND_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CIPND` writer"] #[doc = "Register `CIPND` writer"]
pub struct W(crate::W<CIPND_SPEC>); pub type W = crate::W<CipndSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CIPND_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CIPND_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CIPND_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `EIPND` reader - Error Interrupt Pending"]
pub struct EIPND_R(crate::FieldReader<bool, bool>);
impl EIPND_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
EIPND_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for EIPND_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EIPND` writer - Error Interrupt Pending"]
pub struct EIPND_W<'a> {
w: &'a mut W,
}
impl<'a> EIPND_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
self.w
}
}
#[doc = "Field `IPND` reader - Buffer Interrupt Pending\\[14:0\\]"] #[doc = "Field `IPND` reader - Buffer Interrupt Pending\\[14:0\\]"]
pub struct IPND_R(crate::FieldReader<u16, u16>); pub type IpndR = crate::FieldReader<u16>;
impl IPND_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
IPND_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for IPND_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `IPND` writer - Buffer Interrupt Pending\\[14:0\\]"] #[doc = "Field `IPND` writer - Buffer Interrupt Pending\\[14:0\\]"]
pub struct IPND_W<'a> { pub type IpndW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
w: &'a mut W, #[doc = "Field `EIPND` reader - Error Interrupt Pending"]
} pub type EipndR = crate::BitReader;
impl<'a> IPND_W<'a> { #[doc = "Field `EIPND` writer - Error Interrupt Pending"]
#[doc = r"Writes raw bits to the field"] pub type EipndW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
self.w
}
}
impl R { impl R {
#[doc = "Bit 15 - Error Interrupt Pending"]
#[inline(always)]
pub fn eipnd(&self) -> EIPND_R {
EIPND_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn ipnd(&self) -> IPND_R { pub fn ipnd(&self) -> IpndR {
IPND_R::new((self.bits & 0x7fff) as u16) IpndR::new((self.bits & 0x7fff) as u16)
}
#[doc = "Bit 15 - Error Interrupt Pending"]
#[inline(always)]
pub fn eipnd(&self) -> EipndR {
EipndR::new(((self.bits >> 15) & 1) != 0)
} }
} }
impl W { impl W {
#[doc = "Bit 15 - Error Interrupt Pending"]
#[inline(always)]
pub fn eipnd(&mut self) -> EIPND_W {
EIPND_W { w: self }
}
#[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"] #[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
#[inline(always)] #[inline(always)]
pub fn ipnd(&mut self) -> IPND_W { #[must_use]
IPND_W { w: self } pub fn ipnd(&mut self) -> IpndW<CipndSpec> {
IpndW::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bit 15 - Error Interrupt Pending"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn eipnd(&mut self) -> EipndW<CipndSpec> {
self EipndW::new(self, 15)
} }
} }
#[doc = "CAN Interrupt Pending Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cipnd](index.html) module"] #[doc = "CAN Interrupt Pending Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cipnd::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cipnd::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CIPND_SPEC; pub struct CipndSpec;
impl crate::RegisterSpec for CIPND_SPEC { impl crate::RegisterSpec for CipndSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cipnd::R](R) reader structure"] #[doc = "`read()` method returns [`cipnd::R`](R) reader structure"]
impl crate::Readable for CIPND_SPEC { impl crate::Readable for CipndSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cipnd::W`](W) writer structure"]
} impl crate::Writable for CipndSpec {
#[doc = "`write(|w| ..)` method takes [cipnd::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CIPND_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CIPND to value 0"] #[doc = "`reset()` method sets CIPND to value 0"]
impl crate::Resettable for CIPND_SPEC { impl crate::Resettable for CipndSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb0.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB0` reader"] #[doc = "Register `CNSTAT_CMB0` reader"]
pub struct R(crate::R<CNSTAT_CMB0_SPEC>); pub type R = crate::R<CnstatCmb0Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB0_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB0_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB0` writer"] #[doc = "Register `CNSTAT_CMB0` writer"]
pub struct W(crate::W<CNSTAT_CMB0_SPEC>); pub type W = crate::W<CnstatCmb0Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB0_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB0_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb0Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb0Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb0Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb0](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb0::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB0_SPEC; pub struct CnstatCmb0Spec;
impl crate::RegisterSpec for CNSTAT_CMB0_SPEC { impl crate::RegisterSpec for CnstatCmb0Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb0::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb0::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB0_SPEC { impl crate::Readable for CnstatCmb0Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb0::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb0Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb0::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB0_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB0 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB0 to value 0"]
impl crate::Resettable for CNSTAT_CMB0_SPEC { impl crate::Resettable for CnstatCmb0Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb1.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB1` reader"] #[doc = "Register `CNSTAT_CMB1` reader"]
pub struct R(crate::R<CNSTAT_CMB1_SPEC>); pub type R = crate::R<CnstatCmb1Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB1_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB1_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB1` writer"] #[doc = "Register `CNSTAT_CMB1` writer"]
pub struct W(crate::W<CNSTAT_CMB1_SPEC>); pub type W = crate::W<CnstatCmb1Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB1_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB1_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb1Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb1Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb1Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb1](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB1_SPEC; pub struct CnstatCmb1Spec;
impl crate::RegisterSpec for CNSTAT_CMB1_SPEC { impl crate::RegisterSpec for CnstatCmb1Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb1::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb1::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB1_SPEC { impl crate::Readable for CnstatCmb1Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb1::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb1Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb1::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB1_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB1 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB1 to value 0"]
impl crate::Resettable for CNSTAT_CMB1_SPEC { impl crate::Resettable for CnstatCmb1Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb10.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB10` reader"] #[doc = "Register `CNSTAT_CMB10` reader"]
pub struct R(crate::R<CNSTAT_CMB10_SPEC>); pub type R = crate::R<CnstatCmb10Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB10_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB10_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB10` writer"] #[doc = "Register `CNSTAT_CMB10` writer"]
pub struct W(crate::W<CNSTAT_CMB10_SPEC>); pub type W = crate::W<CnstatCmb10Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB10_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB10_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb10Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb10Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb10Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb10](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb10::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB10_SPEC; pub struct CnstatCmb10Spec;
impl crate::RegisterSpec for CNSTAT_CMB10_SPEC { impl crate::RegisterSpec for CnstatCmb10Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb10::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb10::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB10_SPEC { impl crate::Readable for CnstatCmb10Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb10::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb10Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb10::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB10_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB10 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB10 to value 0"]
impl crate::Resettable for CNSTAT_CMB10_SPEC { impl crate::Resettable for CnstatCmb10Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb11.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB11` reader"] #[doc = "Register `CNSTAT_CMB11` reader"]
pub struct R(crate::R<CNSTAT_CMB11_SPEC>); pub type R = crate::R<CnstatCmb11Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB11_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB11_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB11` writer"] #[doc = "Register `CNSTAT_CMB11` writer"]
pub struct W(crate::W<CNSTAT_CMB11_SPEC>); pub type W = crate::W<CnstatCmb11Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB11_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB11_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb11Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb11Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb11Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb11](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb11::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB11_SPEC; pub struct CnstatCmb11Spec;
impl crate::RegisterSpec for CNSTAT_CMB11_SPEC { impl crate::RegisterSpec for CnstatCmb11Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb11::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb11::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB11_SPEC { impl crate::Readable for CnstatCmb11Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb11::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb11Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb11::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB11_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB11 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB11 to value 0"]
impl crate::Resettable for CNSTAT_CMB11_SPEC { impl crate::Resettable for CnstatCmb11Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb12.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB12` reader"] #[doc = "Register `CNSTAT_CMB12` reader"]
pub struct R(crate::R<CNSTAT_CMB12_SPEC>); pub type R = crate::R<CnstatCmb12Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB12_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB12_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB12` writer"] #[doc = "Register `CNSTAT_CMB12` writer"]
pub struct W(crate::W<CNSTAT_CMB12_SPEC>); pub type W = crate::W<CnstatCmb12Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB12_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB12_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb12Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb12Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb12Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb12](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb12::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB12_SPEC; pub struct CnstatCmb12Spec;
impl crate::RegisterSpec for CNSTAT_CMB12_SPEC { impl crate::RegisterSpec for CnstatCmb12Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb12::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb12::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB12_SPEC { impl crate::Readable for CnstatCmb12Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb12::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb12Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb12::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB12_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB12 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB12 to value 0"]
impl crate::Resettable for CNSTAT_CMB12_SPEC { impl crate::Resettable for CnstatCmb12Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb13.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB13` reader"] #[doc = "Register `CNSTAT_CMB13` reader"]
pub struct R(crate::R<CNSTAT_CMB13_SPEC>); pub type R = crate::R<CnstatCmb13Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB13_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB13_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB13` writer"] #[doc = "Register `CNSTAT_CMB13` writer"]
pub struct W(crate::W<CNSTAT_CMB13_SPEC>); pub type W = crate::W<CnstatCmb13Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB13_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB13_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb13Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb13Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb13Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb13](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb13::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB13_SPEC; pub struct CnstatCmb13Spec;
impl crate::RegisterSpec for CNSTAT_CMB13_SPEC { impl crate::RegisterSpec for CnstatCmb13Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb13::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb13::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB13_SPEC { impl crate::Readable for CnstatCmb13Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb13::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb13Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb13::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB13_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB13 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB13 to value 0"]
impl crate::Resettable for CNSTAT_CMB13_SPEC { impl crate::Resettable for CnstatCmb13Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb14.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB14` reader"] #[doc = "Register `CNSTAT_CMB14` reader"]
pub struct R(crate::R<CNSTAT_CMB14_SPEC>); pub type R = crate::R<CnstatCmb14Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB14_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB14_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB14` writer"] #[doc = "Register `CNSTAT_CMB14` writer"]
pub struct W(crate::W<CNSTAT_CMB14_SPEC>); pub type W = crate::W<CnstatCmb14Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB14_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB14_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb14Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb14Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb14Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb14](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb14::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB14_SPEC; pub struct CnstatCmb14Spec;
impl crate::RegisterSpec for CNSTAT_CMB14_SPEC { impl crate::RegisterSpec for CnstatCmb14Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb14::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb14::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB14_SPEC { impl crate::Readable for CnstatCmb14Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb14::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb14Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb14::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB14_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB14 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB14 to value 0"]
impl crate::Resettable for CNSTAT_CMB14_SPEC { impl crate::Resettable for CnstatCmb14Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb2.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB2` reader"] #[doc = "Register `CNSTAT_CMB2` reader"]
pub struct R(crate::R<CNSTAT_CMB2_SPEC>); pub type R = crate::R<CnstatCmb2Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB2_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB2_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB2` writer"] #[doc = "Register `CNSTAT_CMB2` writer"]
pub struct W(crate::W<CNSTAT_CMB2_SPEC>); pub type W = crate::W<CnstatCmb2Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB2_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB2_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb2Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb2Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb2Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb2](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb2::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB2_SPEC; pub struct CnstatCmb2Spec;
impl crate::RegisterSpec for CNSTAT_CMB2_SPEC { impl crate::RegisterSpec for CnstatCmb2Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb2::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb2::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB2_SPEC { impl crate::Readable for CnstatCmb2Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb2::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb2Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb2::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB2_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB2 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB2 to value 0"]
impl crate::Resettable for CNSTAT_CMB2_SPEC { impl crate::Resettable for CnstatCmb2Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb3.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB3` reader"] #[doc = "Register `CNSTAT_CMB3` reader"]
pub struct R(crate::R<CNSTAT_CMB3_SPEC>); pub type R = crate::R<CnstatCmb3Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB3_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB3_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB3` writer"] #[doc = "Register `CNSTAT_CMB3` writer"]
pub struct W(crate::W<CNSTAT_CMB3_SPEC>); pub type W = crate::W<CnstatCmb3Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB3_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB3_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb3Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb3Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb3Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb3](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb3::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB3_SPEC; pub struct CnstatCmb3Spec;
impl crate::RegisterSpec for CNSTAT_CMB3_SPEC { impl crate::RegisterSpec for CnstatCmb3Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb3::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb3::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB3_SPEC { impl crate::Readable for CnstatCmb3Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb3::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb3Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb3::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB3_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB3 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB3 to value 0"]
impl crate::Resettable for CNSTAT_CMB3_SPEC { impl crate::Resettable for CnstatCmb3Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb4.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB4` reader"] #[doc = "Register `CNSTAT_CMB4` reader"]
pub struct R(crate::R<CNSTAT_CMB4_SPEC>); pub type R = crate::R<CnstatCmb4Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB4_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB4_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB4` writer"] #[doc = "Register `CNSTAT_CMB4` writer"]
pub struct W(crate::W<CNSTAT_CMB4_SPEC>); pub type W = crate::W<CnstatCmb4Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB4_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB4_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb4Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb4Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb4Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb4](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb4::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB4_SPEC; pub struct CnstatCmb4Spec;
impl crate::RegisterSpec for CNSTAT_CMB4_SPEC { impl crate::RegisterSpec for CnstatCmb4Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb4::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb4::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB4_SPEC { impl crate::Readable for CnstatCmb4Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb4::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb4Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb4::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB4_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB4 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB4 to value 0"]
impl crate::Resettable for CNSTAT_CMB4_SPEC { impl crate::Resettable for CnstatCmb4Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb5.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB5` reader"] #[doc = "Register `CNSTAT_CMB5` reader"]
pub struct R(crate::R<CNSTAT_CMB5_SPEC>); pub type R = crate::R<CnstatCmb5Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB5_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB5_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB5` writer"] #[doc = "Register `CNSTAT_CMB5` writer"]
pub struct W(crate::W<CNSTAT_CMB5_SPEC>); pub type W = crate::W<CnstatCmb5Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB5_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB5_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb5Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb5Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb5Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb5](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb5::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB5_SPEC; pub struct CnstatCmb5Spec;
impl crate::RegisterSpec for CNSTAT_CMB5_SPEC { impl crate::RegisterSpec for CnstatCmb5Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb5::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb5::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB5_SPEC { impl crate::Readable for CnstatCmb5Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb5::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb5Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb5::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB5_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB5 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB5 to value 0"]
impl crate::Resettable for CNSTAT_CMB5_SPEC { impl crate::Resettable for CnstatCmb5Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb6.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB6` reader"] #[doc = "Register `CNSTAT_CMB6` reader"]
pub struct R(crate::R<CNSTAT_CMB6_SPEC>); pub type R = crate::R<CnstatCmb6Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB6_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB6_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB6` writer"] #[doc = "Register `CNSTAT_CMB6` writer"]
pub struct W(crate::W<CNSTAT_CMB6_SPEC>); pub type W = crate::W<CnstatCmb6Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB6_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB6_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb6Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb6Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb6Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb6](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb6::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB6_SPEC; pub struct CnstatCmb6Spec;
impl crate::RegisterSpec for CNSTAT_CMB6_SPEC { impl crate::RegisterSpec for CnstatCmb6Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb6::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb6::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB6_SPEC { impl crate::Readable for CnstatCmb6Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb6::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb6Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb6::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB6_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB6 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB6 to value 0"]
impl crate::Resettable for CNSTAT_CMB6_SPEC { impl crate::Resettable for CnstatCmb6Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb7.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB7` reader"] #[doc = "Register `CNSTAT_CMB7` reader"]
pub struct R(crate::R<CNSTAT_CMB7_SPEC>); pub type R = crate::R<CnstatCmb7Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB7_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB7_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB7` writer"] #[doc = "Register `CNSTAT_CMB7` writer"]
pub struct W(crate::W<CNSTAT_CMB7_SPEC>); pub type W = crate::W<CnstatCmb7Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB7_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB7_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb7Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb7Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb7Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb7](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb7::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB7_SPEC; pub struct CnstatCmb7Spec;
impl crate::RegisterSpec for CNSTAT_CMB7_SPEC { impl crate::RegisterSpec for CnstatCmb7Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb7::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb7::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB7_SPEC { impl crate::Readable for CnstatCmb7Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb7::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb7Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb7::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB7_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB7 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB7 to value 0"]
impl crate::Resettable for CNSTAT_CMB7_SPEC { impl crate::Resettable for CnstatCmb7Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb8.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB8` reader"] #[doc = "Register `CNSTAT_CMB8` reader"]
pub struct R(crate::R<CNSTAT_CMB8_SPEC>); pub type R = crate::R<CnstatCmb8Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB8_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB8_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB8` writer"] #[doc = "Register `CNSTAT_CMB8` writer"]
pub struct W(crate::W<CNSTAT_CMB8_SPEC>); pub type W = crate::W<CnstatCmb8Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB8_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB8_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb8Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb8Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb8Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb8](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb8::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB8_SPEC; pub struct CnstatCmb8Spec;
impl crate::RegisterSpec for CNSTAT_CMB8_SPEC { impl crate::RegisterSpec for CnstatCmb8Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb8::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb8::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB8_SPEC { impl crate::Readable for CnstatCmb8Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb8::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb8Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb8::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB8_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB8 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB8 to value 0"]
impl crate::Resettable for CNSTAT_CMB8_SPEC { impl crate::Resettable for CnstatCmb8Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_cmb9.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_CMB9` reader"] #[doc = "Register `CNSTAT_CMB9` reader"]
pub struct R(crate::R<CNSTAT_CMB9_SPEC>); pub type R = crate::R<CnstatCmb9Spec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_CMB9_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_CMB9_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_CMB9` writer"] #[doc = "Register `CNSTAT_CMB9` writer"]
pub struct W(crate::W<CNSTAT_CMB9_SPEC>); pub type W = crate::W<CnstatCmb9Spec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_CMB9_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_CMB9_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatCmb9Spec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatCmb9Spec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatCmb9Spec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb9](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_cmb9::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_CMB9_SPEC; pub struct CnstatCmb9Spec;
impl crate::RegisterSpec for CNSTAT_CMB9_SPEC { impl crate::RegisterSpec for CnstatCmb9Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_cmb9::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_cmb9::R`](R) reader structure"]
impl crate::Readable for CNSTAT_CMB9_SPEC { impl crate::Readable for CnstatCmb9Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_cmb9::W`](W) writer structure"]
} impl crate::Writable for CnstatCmb9Spec {
#[doc = "`write(|w| ..)` method takes [cnstat_cmb9::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_CMB9_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_CMB9 to value 0"] #[doc = "`reset()` method sets CNSTAT_CMB9 to value 0"]
impl crate::Resettable for CNSTAT_CMB9_SPEC { impl crate::Resettable for CnstatCmb9Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

193
va416xx/src/can0/cnstat_hcmb.rs
View File

@ -1,177 +1,70 @@
#[doc = "Register `CNSTAT_HCMB` reader"] #[doc = "Register `CNSTAT_HCMB` reader"]
pub struct R(crate::R<CNSTAT_HCMB_SPEC>); pub type R = crate::R<CnstatHcmbSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CNSTAT_HCMB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CNSTAT_HCMB_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CNSTAT_HCMB_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CNSTAT_HCMB` writer"] #[doc = "Register `CNSTAT_HCMB` writer"]
pub struct W(crate::W<CNSTAT_HCMB_SPEC>); pub type W = crate::W<CnstatHcmbSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CNSTAT_HCMB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CNSTAT_HCMB_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CNSTAT_HCMB_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `DLC` reader - Data Length Code"]
pub struct DLC_R(crate::FieldReader<u8, u8>);
impl DLC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
DLC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DLC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DLC` writer - Data Length Code"]
pub struct DLC_W<'a> {
w: &'a mut W,
}
impl<'a> DLC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
self.w
}
}
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub struct PRI_R(crate::FieldReader<u8, u8>);
impl PRI_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PRI_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PRI_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub struct PRI_W<'a> {
w: &'a mut W,
}
impl<'a> PRI_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
self.w
}
}
#[doc = "Field `ST` reader - Buffer Status"] #[doc = "Field `ST` reader - Buffer Status"]
pub struct ST_R(crate::FieldReader<u8, u8>); pub type StR = crate::FieldReader;
impl ST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
ST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ST` writer - Buffer Status"] #[doc = "Field `ST` writer - Buffer Status"]
pub struct ST_W<'a> { pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `PRI` reader - Transmit Priority Code"]
} pub type PriR = crate::FieldReader;
impl<'a> ST_W<'a> { #[doc = "Field `PRI` writer - Transmit Priority Code"]
#[doc = r"Writes raw bits to the field"] pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `DLC` reader - Data Length Code"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type DlcR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `DLC` writer - Data Length Code"]
self.w pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
}
}
impl R { impl R {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&self) -> DLC_R { pub fn st(&self) -> StR {
DLC_R::new(((self.bits >> 12) & 0x0f) as u8) StR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&self) -> PRI_R { pub fn pri(&self) -> PriR {
PRI_R::new(((self.bits >> 4) & 0x0f) as u8) PriR::new(((self.bits >> 4) & 0x0f) as u8)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&self) -> ST_R { pub fn dlc(&self) -> DlcR {
ST_R::new((self.bits & 0x0f) as u8) DlcR::new(((self.bits >> 12) & 0x0f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 12:15 - Data Length Code"] #[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)] #[inline(always)]
pub fn dlc(&mut self) -> DLC_W { #[must_use]
DLC_W { w: self } pub fn st(&mut self) -> StW<CnstatHcmbSpec> {
StW::new(self, 0)
} }
#[doc = "Bits 4:7 - Transmit Priority Code"] #[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)] #[inline(always)]
pub fn pri(&mut self) -> PRI_W { #[must_use]
PRI_W { w: self } pub fn pri(&mut self) -> PriW<CnstatHcmbSpec> {
PriW::new(self, 4)
} }
#[doc = "Bits 0:3 - Buffer Status"] #[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)] #[inline(always)]
pub fn st(&mut self) -> ST_W { #[must_use]
ST_W { w: self } pub fn dlc(&mut self) -> DlcW<CnstatHcmbSpec> {
} DlcW::new(self, 12)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_hcmb](index.html) module"] #[doc = "Buffer Status / Control Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cnstat_hcmb::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cnstat_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CNSTAT_HCMB_SPEC; pub struct CnstatHcmbSpec;
impl crate::RegisterSpec for CNSTAT_HCMB_SPEC { impl crate::RegisterSpec for CnstatHcmbSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cnstat_hcmb::R](R) reader structure"] #[doc = "`read()` method returns [`cnstat_hcmb::R`](R) reader structure"]
impl crate::Readable for CNSTAT_HCMB_SPEC { impl crate::Readable for CnstatHcmbSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cnstat_hcmb::W`](W) writer structure"]
} impl crate::Writable for CnstatHcmbSpec {
#[doc = "`write(|w| ..)` method takes [cnstat_hcmb::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CNSTAT_HCMB_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CNSTAT_HCMB to value 0"] #[doc = "`reset()` method sets CNSTAT_HCMB to value 0"]
impl crate::Resettable for CNSTAT_HCMB_SPEC { impl crate::Resettable for CnstatHcmbSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

203
va416xx/src/can0/cstpnd.rs
View File

@ -1,187 +1,70 @@
#[doc = "Register `CSTPND` reader"] #[doc = "Register `CSTPND` reader"]
pub struct R(crate::R<CSTPND_SPEC>); pub type R = crate::R<CstpndSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CSTPND_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CSTPND_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CSTPND_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CSTPND` writer"] #[doc = "Register `CSTPND` writer"]
pub struct W(crate::W<CSTPND_SPEC>); pub type W = crate::W<CstpndSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CSTPND_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CSTPND_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CSTPND_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `NS` reader - CAN Node Status"]
pub struct NS_R(crate::FieldReader<u8, u8>);
impl NS_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
NS_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for NS_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `NS` writer - CAN Node Status"]
pub struct NS_W<'a> {
w: &'a mut W,
}
impl<'a> NS_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x07 << 5)) | ((value as u32 & 0x07) << 5);
self.w
}
}
#[doc = "Field `IRQ` reader - Interrupt Request portion of Interrupt Code"]
pub struct IRQ_R(crate::FieldReader<bool, bool>);
impl IRQ_R {
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
IRQ_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for IRQ_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `IRQ` writer - Interrupt Request portion of Interrupt Code"]
pub struct IRQ_W<'a> {
w: &'a mut W,
}
impl<'a> IRQ_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
self.w
}
}
#[doc = "Field `IST` reader - Interrupt Source portion of Interrupt Code"] #[doc = "Field `IST` reader - Interrupt Source portion of Interrupt Code"]
pub struct IST_R(crate::FieldReader<u8, u8>); pub type IstR = crate::FieldReader;
impl IST_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
IST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for IST_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `IST` writer - Interrupt Source portion of Interrupt Code"] #[doc = "Field `IST` writer - Interrupt Source portion of Interrupt Code"]
pub struct IST_W<'a> { pub type IstW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
w: &'a mut W, #[doc = "Field `IRQ` reader - Interrupt Request portion of Interrupt Code"]
} pub type IrqR = crate::BitReader;
impl<'a> IST_W<'a> { #[doc = "Field `IRQ` writer - Interrupt Request portion of Interrupt Code"]
#[doc = r"Writes raw bits to the field"] pub type IrqW<'a, REG> = crate::BitWriter<'a, REG>;
#[inline(always)] #[doc = "Field `NS` reader - CAN Node Status"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type NsR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f); #[doc = "Field `NS` writer - CAN Node Status"]
self.w pub type NsW<'a, REG> = crate::FieldWriter<'a, REG, 3>;
}
}
impl R { impl R {
#[doc = "Bits 5:7 - CAN Node Status"] #[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
#[inline(always)] #[inline(always)]
pub fn ns(&self) -> NS_R { pub fn ist(&self) -> IstR {
NS_R::new(((self.bits >> 5) & 0x07) as u8) IstR::new((self.bits & 0x0f) as u8)
} }
#[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"] #[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
#[inline(always)] #[inline(always)]
pub fn irq(&self) -> IRQ_R { pub fn irq(&self) -> IrqR {
IRQ_R::new(((self.bits >> 4) & 0x01) != 0) IrqR::new(((self.bits >> 4) & 1) != 0)
} }
#[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"] #[doc = "Bits 5:7 - CAN Node Status"]
#[inline(always)] #[inline(always)]
pub fn ist(&self) -> IST_R { pub fn ns(&self) -> NsR {
IST_R::new((self.bits & 0x0f) as u8) NsR::new(((self.bits >> 5) & 7) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 5:7 - CAN Node Status"] #[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
#[inline(always)] #[inline(always)]
pub fn ns(&mut self) -> NS_W { #[must_use]
NS_W { w: self } pub fn ist(&mut self) -> IstW<CstpndSpec> {
IstW::new(self, 0)
} }
#[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"] #[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
#[inline(always)] #[inline(always)]
pub fn irq(&mut self) -> IRQ_W { #[must_use]
IRQ_W { w: self } pub fn irq(&mut self) -> IrqW<CstpndSpec> {
IrqW::new(self, 4)
} }
#[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"] #[doc = "Bits 5:7 - CAN Node Status"]
#[inline(always)] #[inline(always)]
pub fn ist(&mut self) -> IST_W { #[must_use]
IST_W { w: self } pub fn ns(&mut self) -> NsW<CstpndSpec> {
} NsW::new(self, 5)
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
} }
} }
#[doc = "CAN Status Pending Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cstpnd](index.html) module"] #[doc = "CAN Status Pending Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cstpnd::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cstpnd::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CSTPND_SPEC; pub struct CstpndSpec;
impl crate::RegisterSpec for CSTPND_SPEC { impl crate::RegisterSpec for CstpndSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [cstpnd::R](R) reader structure"] #[doc = "`read()` method returns [`cstpnd::R`](R) reader structure"]
impl crate::Readable for CSTPND_SPEC { impl crate::Readable for CstpndSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`cstpnd::W`](W) writer structure"]
} impl crate::Writable for CstpndSpec {
#[doc = "`write(|w| ..)` method takes [cstpnd::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CSTPND_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CSTPND to value 0"] #[doc = "`reset()` method sets CSTPND to value 0"]
impl crate::Resettable for CSTPND_SPEC { impl crate::Resettable for CstpndSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

241
va416xx/src/can0/ctim.rs
View File

@ -1,214 +1,85 @@
#[doc = "Register `CTIM` reader"] #[doc = "Register `CTIM` reader"]
pub struct R(crate::R<CTIM_SPEC>); pub type R = crate::R<CtimSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CTIM_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CTIM_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CTIM_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CTIM` writer"] #[doc = "Register `CTIM` writer"]
pub struct W(crate::W<CTIM_SPEC>); pub type W = crate::W<CtimSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CTIM_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CTIM_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CTIM_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `PSC` reader - Prescaler Configuration"]
pub struct PSC_R(crate::FieldReader<u8, u8>);
impl PSC_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
PSC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PSC_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PSC` writer - Prescaler Configuration"]
pub struct PSC_W<'a> {
w: &'a mut W,
}
impl<'a> PSC_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x7f << 9)) | ((value as u32 & 0x7f) << 9);
self.w
}
}
#[doc = "Field `SJW` reader - Synchronization Jump Width"]
pub struct SJW_R(crate::FieldReader<u8, u8>);
impl SJW_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
SJW_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SJW_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SJW` writer - Synchronization Jump Width"]
pub struct SJW_W<'a> {
w: &'a mut W,
}
impl<'a> SJW_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 7)) | ((value as u32 & 0x03) << 7);
self.w
}
}
#[doc = "Field `TSEG1` reader - Time Segment 1"]
pub struct TSEG1_R(crate::FieldReader<u8, u8>);
impl TSEG1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
TSEG1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TSEG1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TSEG1` writer - Time Segment 1"]
pub struct TSEG1_W<'a> {
w: &'a mut W,
}
impl<'a> TSEG1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 3)) | ((value as u32 & 0x0f) << 3);
self.w
}
}
#[doc = "Field `TSEG2` reader - Time Segment 2"] #[doc = "Field `TSEG2` reader - Time Segment 2"]
pub struct TSEG2_R(crate::FieldReader<u8, u8>); pub type Tseg2R = crate::FieldReader;
impl TSEG2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
TSEG2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TSEG2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TSEG2` writer - Time Segment 2"] #[doc = "Field `TSEG2` writer - Time Segment 2"]
pub struct TSEG2_W<'a> { pub type Tseg2W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
w: &'a mut W, #[doc = "Field `TSEG1` reader - Time Segment 1"]
} pub type Tseg1R = crate::FieldReader;
impl<'a> TSEG2_W<'a> { #[doc = "Field `TSEG1` writer - Time Segment 1"]
#[doc = r"Writes raw bits to the field"] pub type Tseg1W<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[inline(always)] #[doc = "Field `SJW` reader - Synchronization Jump Width"]
pub unsafe fn bits(self, value: u8) -> &'a mut W { pub type SjwR = crate::FieldReader;
self.w.bits = (self.w.bits & !0x07) | (value as u32 & 0x07); #[doc = "Field `SJW` writer - Synchronization Jump Width"]
self.w pub type SjwW<'a, REG> = crate::FieldWriter<'a, REG, 2>;
} #[doc = "Field `PSC` reader - Prescaler Configuration"]
} pub type PscR = crate::FieldReader;
#[doc = "Field `PSC` writer - Prescaler Configuration"]
pub type PscW<'a, REG> = crate::FieldWriter<'a, REG, 7>;
impl R { impl R {
#[doc = "Bits 9:15 - Prescaler Configuration"] #[doc = "Bits 0:2 - Time Segment 2"]
#[inline(always)] #[inline(always)]
pub fn psc(&self) -> PSC_R { pub fn tseg2(&self) -> Tseg2R {
PSC_R::new(((self.bits >> 9) & 0x7f) as u8) Tseg2R::new((self.bits & 7) as u8)
}
#[doc = "Bits 7:8 - Synchronization Jump Width"]
#[inline(always)]
pub fn sjw(&self) -> SJW_R {
SJW_R::new(((self.bits >> 7) & 0x03) as u8)
} }
#[doc = "Bits 3:6 - Time Segment 1"] #[doc = "Bits 3:6 - Time Segment 1"]
#[inline(always)] #[inline(always)]
pub fn tseg1(&self) -> TSEG1_R { pub fn tseg1(&self) -> Tseg1R {
TSEG1_R::new(((self.bits >> 3) & 0x0f) as u8) Tseg1R::new(((self.bits >> 3) & 0x0f) as u8)
} }
#[doc = "Bits 0:2 - Time Segment 2"] #[doc = "Bits 7:8 - Synchronization Jump Width"]
#[inline(always)] #[inline(always)]
pub fn tseg2(&self) -> TSEG2_R { pub fn sjw(&self) -> SjwR {
TSEG2_R::new((self.bits & 0x07) as u8) SjwR::new(((self.bits >> 7) & 3) as u8)
}
#[doc = "Bits 9:15 - Prescaler Configuration"]
#[inline(always)]
pub fn psc(&self) -> PscR {
PscR::new(((self.bits >> 9) & 0x7f) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 9:15 - Prescaler Configuration"] #[doc = "Bits 0:2 - Time Segment 2"]
#[inline(always)] #[inline(always)]
pub fn psc(&mut self) -> PSC_W { #[must_use]
PSC_W { w: self } pub fn tseg2(&mut self) -> Tseg2W<CtimSpec> {
} Tseg2W::new(self, 0)
#[doc = "Bits 7:8 - Synchronization Jump Width"]
#[inline(always)]
pub fn sjw(&mut self) -> SJW_W {
SJW_W { w: self }
} }
#[doc = "Bits 3:6 - Time Segment 1"] #[doc = "Bits 3:6 - Time Segment 1"]
#[inline(always)] #[inline(always)]
pub fn tseg1(&mut self) -> TSEG1_W { #[must_use]
TSEG1_W { w: self } pub fn tseg1(&mut self) -> Tseg1W<CtimSpec> {
Tseg1W::new(self, 3)
} }
#[doc = "Bits 0:2 - Time Segment 2"] #[doc = "Bits 7:8 - Synchronization Jump Width"]
#[inline(always)] #[inline(always)]
pub fn tseg2(&mut self) -> TSEG2_W { #[must_use]
TSEG2_W { w: self } pub fn sjw(&mut self) -> SjwW<CtimSpec> {
SjwW::new(self, 7)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 9:15 - Prescaler Configuration"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn psc(&mut self) -> PscW<CtimSpec> {
self PscW::new(self, 9)
} }
} }
#[doc = "CAN Timing Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ctim](index.html) module"] #[doc = "CAN Timing Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctim::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctim::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CTIM_SPEC; pub struct CtimSpec;
impl crate::RegisterSpec for CTIM_SPEC { impl crate::RegisterSpec for CtimSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [ctim::R](R) reader structure"] #[doc = "`read()` method returns [`ctim::R`](R) reader structure"]
impl crate::Readable for CTIM_SPEC { impl crate::Readable for CtimSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`ctim::W`](W) writer structure"]
} impl crate::Writable for CtimSpec {
#[doc = "`write(|w| ..)` method takes [ctim::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CTIM_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CTIM to value 0"] #[doc = "`reset()` method sets CTIM to value 0"]
impl crate::Resettable for CTIM_SPEC { impl crate::Resettable for CtimSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

91
va416xx/src/can0/ctmr.rs
View File

@ -1,86 +1,31 @@
#[doc = "Register `CTMR` reader"] #[doc = "Register `CTMR` reader"]
pub struct R(crate::R<CTMR_SPEC>); pub type R = crate::R<CtmrSpec>;
impl core::ops::Deref for R {
type Target = crate::R<CTMR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CTMR_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CTMR_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CTMR` writer"] #[doc = "Register `CTMR` writer"]
pub struct W(crate::W<CTMR_SPEC>); pub type W = crate::W<CtmrSpec>;
impl core::ops::Deref for W {
type Target = crate::W<CTMR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CTMR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CTMR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `CTMR` reader - Time Stamp Counter"] #[doc = "Field `CTMR` reader - Time Stamp Counter"]
pub struct CTMR_R(crate::FieldReader<u16, u16>); pub type CtmrR = crate::FieldReader<u16>;
impl CTMR_R {
#[inline(always)]
pub(crate) fn new(bits: u16) -> Self {
CTMR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CTMR_R {
type Target = crate::FieldReader<u16, u16>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl R { impl R {
#[doc = "Bits 0:15 - Time Stamp Counter"] #[doc = "Bits 0:15 - Time Stamp Counter"]
#[inline(always)] #[inline(always)]
pub fn ctmr(&self) -> CTMR_R { pub fn ctmr(&self) -> CtmrR {
CTMR_R::new((self.bits & 0xffff) as u16) CtmrR::new((self.bits & 0xffff) as u16)
} }
} }
impl W { impl W {}
#[doc = "Writes raw bits to the register."] #[doc = "CAN Timer Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ctmr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`ctmr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
#[inline(always)] pub struct CtmrSpec;
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { impl crate::RegisterSpec for CtmrSpec {
self.0.bits(bits);
self
}
}
#[doc = "CAN Timer Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ctmr](index.html) module"]
pub struct CTMR_SPEC;
impl crate::RegisterSpec for CTMR_SPEC {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [ctmr::R](R) reader structure"] #[doc = "`read()` method returns [`ctmr::R`](R) reader structure"]
impl crate::Readable for CTMR_SPEC { impl crate::Readable for CtmrSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`ctmr::W`](W) writer structure"]
} impl crate::Writable for CtmrSpec {
#[doc = "`write(|w| ..)` method takes [ctmr::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for CTMR_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets CTMR to value 0"] #[doc = "`reset()` method sets CTMR to value 0"]
impl crate::Resettable for CTMR_SPEC { impl crate::Resettable for CtmrSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb0.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB0` reader"] #[doc = "Register `DATA0_CMB0` reader"]
pub struct R(crate::R<DATA0_CMB0_SPEC>); pub type R = crate::R<Data0Cmb0Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB0_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB0_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB0` writer"] #[doc = "Register `DATA0_CMB0` writer"]
pub struct W(crate::W<DATA0_CMB0_SPEC>); pub type W = crate::W<Data0Cmb0Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB0_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB0_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb0Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb0Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb0](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb0::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB0_SPEC; pub struct Data0Cmb0Spec;
impl crate::RegisterSpec for DATA0_CMB0_SPEC { impl crate::RegisterSpec for Data0Cmb0Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb0::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb0::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB0_SPEC { impl crate::Readable for Data0Cmb0Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb0::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb0Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb0::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB0_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB0 to value 0"] #[doc = "`reset()` method sets DATA0_CMB0 to value 0"]
impl crate::Resettable for DATA0_CMB0_SPEC { impl crate::Resettable for Data0Cmb0Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb1.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB1` reader"] #[doc = "Register `DATA0_CMB1` reader"]
pub struct R(crate::R<DATA0_CMB1_SPEC>); pub type R = crate::R<Data0Cmb1Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB1_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB1_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB1` writer"] #[doc = "Register `DATA0_CMB1` writer"]
pub struct W(crate::W<DATA0_CMB1_SPEC>); pub type W = crate::W<Data0Cmb1Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB1_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB1_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb1Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb1Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb1](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB1_SPEC; pub struct Data0Cmb1Spec;
impl crate::RegisterSpec for DATA0_CMB1_SPEC { impl crate::RegisterSpec for Data0Cmb1Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb1::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb1::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB1_SPEC { impl crate::Readable for Data0Cmb1Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb1::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb1Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb1::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB1_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB1 to value 0"] #[doc = "`reset()` method sets DATA0_CMB1 to value 0"]
impl crate::Resettable for DATA0_CMB1_SPEC { impl crate::Resettable for Data0Cmb1Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb10.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB10` reader"] #[doc = "Register `DATA0_CMB10` reader"]
pub struct R(crate::R<DATA0_CMB10_SPEC>); pub type R = crate::R<Data0Cmb10Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB10_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB10_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB10` writer"] #[doc = "Register `DATA0_CMB10` writer"]
pub struct W(crate::W<DATA0_CMB10_SPEC>); pub type W = crate::W<Data0Cmb10Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB10_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB10_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb10Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb10Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb10](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb10::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB10_SPEC; pub struct Data0Cmb10Spec;
impl crate::RegisterSpec for DATA0_CMB10_SPEC { impl crate::RegisterSpec for Data0Cmb10Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb10::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb10::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB10_SPEC { impl crate::Readable for Data0Cmb10Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb10::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb10Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb10::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB10_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB10 to value 0"] #[doc = "`reset()` method sets DATA0_CMB10 to value 0"]
impl crate::Resettable for DATA0_CMB10_SPEC { impl crate::Resettable for Data0Cmb10Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb11.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB11` reader"] #[doc = "Register `DATA0_CMB11` reader"]
pub struct R(crate::R<DATA0_CMB11_SPEC>); pub type R = crate::R<Data0Cmb11Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB11_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB11_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB11` writer"] #[doc = "Register `DATA0_CMB11` writer"]
pub struct W(crate::W<DATA0_CMB11_SPEC>); pub type W = crate::W<Data0Cmb11Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB11_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB11_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb11Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb11Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb11](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb11::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB11_SPEC; pub struct Data0Cmb11Spec;
impl crate::RegisterSpec for DATA0_CMB11_SPEC { impl crate::RegisterSpec for Data0Cmb11Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb11::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb11::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB11_SPEC { impl crate::Readable for Data0Cmb11Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb11::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb11Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb11::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB11_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB11 to value 0"] #[doc = "`reset()` method sets DATA0_CMB11 to value 0"]
impl crate::Resettable for DATA0_CMB11_SPEC { impl crate::Resettable for Data0Cmb11Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb12.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB12` reader"] #[doc = "Register `DATA0_CMB12` reader"]
pub struct R(crate::R<DATA0_CMB12_SPEC>); pub type R = crate::R<Data0Cmb12Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB12_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB12_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB12` writer"] #[doc = "Register `DATA0_CMB12` writer"]
pub struct W(crate::W<DATA0_CMB12_SPEC>); pub type W = crate::W<Data0Cmb12Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB12_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB12_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb12Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb12Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb12](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb12::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB12_SPEC; pub struct Data0Cmb12Spec;
impl crate::RegisterSpec for DATA0_CMB12_SPEC { impl crate::RegisterSpec for Data0Cmb12Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb12::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb12::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB12_SPEC { impl crate::Readable for Data0Cmb12Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb12::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb12Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb12::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB12_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB12 to value 0"] #[doc = "`reset()` method sets DATA0_CMB12 to value 0"]
impl crate::Resettable for DATA0_CMB12_SPEC { impl crate::Resettable for Data0Cmb12Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb13.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB13` reader"] #[doc = "Register `DATA0_CMB13` reader"]
pub struct R(crate::R<DATA0_CMB13_SPEC>); pub type R = crate::R<Data0Cmb13Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB13_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB13_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB13` writer"] #[doc = "Register `DATA0_CMB13` writer"]
pub struct W(crate::W<DATA0_CMB13_SPEC>); pub type W = crate::W<Data0Cmb13Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB13_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB13_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb13Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb13Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb13](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb13::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB13_SPEC; pub struct Data0Cmb13Spec;
impl crate::RegisterSpec for DATA0_CMB13_SPEC { impl crate::RegisterSpec for Data0Cmb13Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb13::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb13::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB13_SPEC { impl crate::Readable for Data0Cmb13Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb13::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb13Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb13::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB13_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB13 to value 0"] #[doc = "`reset()` method sets DATA0_CMB13 to value 0"]
impl crate::Resettable for DATA0_CMB13_SPEC { impl crate::Resettable for Data0Cmb13Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb14.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB14` reader"] #[doc = "Register `DATA0_CMB14` reader"]
pub struct R(crate::R<DATA0_CMB14_SPEC>); pub type R = crate::R<Data0Cmb14Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB14_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB14_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB14` writer"] #[doc = "Register `DATA0_CMB14` writer"]
pub struct W(crate::W<DATA0_CMB14_SPEC>); pub type W = crate::W<Data0Cmb14Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB14_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB14_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb14Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb14Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb14](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb14::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB14_SPEC; pub struct Data0Cmb14Spec;
impl crate::RegisterSpec for DATA0_CMB14_SPEC { impl crate::RegisterSpec for Data0Cmb14Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb14::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb14::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB14_SPEC { impl crate::Readable for Data0Cmb14Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb14::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb14Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb14::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB14_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB14 to value 0"] #[doc = "`reset()` method sets DATA0_CMB14 to value 0"]
impl crate::Resettable for DATA0_CMB14_SPEC { impl crate::Resettable for Data0Cmb14Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb2.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB2` reader"] #[doc = "Register `DATA0_CMB2` reader"]
pub struct R(crate::R<DATA0_CMB2_SPEC>); pub type R = crate::R<Data0Cmb2Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB2_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB2_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB2` writer"] #[doc = "Register `DATA0_CMB2` writer"]
pub struct W(crate::W<DATA0_CMB2_SPEC>); pub type W = crate::W<Data0Cmb2Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB2_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB2_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb2Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb2Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb2](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb2::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB2_SPEC; pub struct Data0Cmb2Spec;
impl crate::RegisterSpec for DATA0_CMB2_SPEC { impl crate::RegisterSpec for Data0Cmb2Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb2::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb2::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB2_SPEC { impl crate::Readable for Data0Cmb2Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb2::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb2Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb2::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB2_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB2 to value 0"] #[doc = "`reset()` method sets DATA0_CMB2 to value 0"]
impl crate::Resettable for DATA0_CMB2_SPEC { impl crate::Resettable for Data0Cmb2Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb3.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB3` reader"] #[doc = "Register `DATA0_CMB3` reader"]
pub struct R(crate::R<DATA0_CMB3_SPEC>); pub type R = crate::R<Data0Cmb3Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB3_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB3_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB3` writer"] #[doc = "Register `DATA0_CMB3` writer"]
pub struct W(crate::W<DATA0_CMB3_SPEC>); pub type W = crate::W<Data0Cmb3Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB3_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB3_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb3Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb3Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb3](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb3::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB3_SPEC; pub struct Data0Cmb3Spec;
impl crate::RegisterSpec for DATA0_CMB3_SPEC { impl crate::RegisterSpec for Data0Cmb3Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb3::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb3::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB3_SPEC { impl crate::Readable for Data0Cmb3Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb3::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb3Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb3::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB3_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB3 to value 0"] #[doc = "`reset()` method sets DATA0_CMB3 to value 0"]
impl crate::Resettable for DATA0_CMB3_SPEC { impl crate::Resettable for Data0Cmb3Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb4.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB4` reader"] #[doc = "Register `DATA0_CMB4` reader"]
pub struct R(crate::R<DATA0_CMB4_SPEC>); pub type R = crate::R<Data0Cmb4Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB4_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB4_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB4` writer"] #[doc = "Register `DATA0_CMB4` writer"]
pub struct W(crate::W<DATA0_CMB4_SPEC>); pub type W = crate::W<Data0Cmb4Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB4_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB4_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb4Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb4Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb4](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb4::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB4_SPEC; pub struct Data0Cmb4Spec;
impl crate::RegisterSpec for DATA0_CMB4_SPEC { impl crate::RegisterSpec for Data0Cmb4Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb4::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb4::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB4_SPEC { impl crate::Readable for Data0Cmb4Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb4::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb4Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb4::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB4_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB4 to value 0"] #[doc = "`reset()` method sets DATA0_CMB4 to value 0"]
impl crate::Resettable for DATA0_CMB4_SPEC { impl crate::Resettable for Data0Cmb4Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb5.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB5` reader"] #[doc = "Register `DATA0_CMB5` reader"]
pub struct R(crate::R<DATA0_CMB5_SPEC>); pub type R = crate::R<Data0Cmb5Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB5_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB5_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB5` writer"] #[doc = "Register `DATA0_CMB5` writer"]
pub struct W(crate::W<DATA0_CMB5_SPEC>); pub type W = crate::W<Data0Cmb5Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB5_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB5_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb5Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb5Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb5](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb5::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB5_SPEC; pub struct Data0Cmb5Spec;
impl crate::RegisterSpec for DATA0_CMB5_SPEC { impl crate::RegisterSpec for Data0Cmb5Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb5::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb5::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB5_SPEC { impl crate::Readable for Data0Cmb5Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb5::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb5Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb5::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB5_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB5 to value 0"] #[doc = "`reset()` method sets DATA0_CMB5 to value 0"]
impl crate::Resettable for DATA0_CMB5_SPEC { impl crate::Resettable for Data0Cmb5Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb6.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB6` reader"] #[doc = "Register `DATA0_CMB6` reader"]
pub struct R(crate::R<DATA0_CMB6_SPEC>); pub type R = crate::R<Data0Cmb6Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB6_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB6_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB6` writer"] #[doc = "Register `DATA0_CMB6` writer"]
pub struct W(crate::W<DATA0_CMB6_SPEC>); pub type W = crate::W<Data0Cmb6Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB6_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB6_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb6Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb6Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb6](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb6::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB6_SPEC; pub struct Data0Cmb6Spec;
impl crate::RegisterSpec for DATA0_CMB6_SPEC { impl crate::RegisterSpec for Data0Cmb6Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb6::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb6::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB6_SPEC { impl crate::Readable for Data0Cmb6Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb6::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb6Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb6::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB6_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB6 to value 0"] #[doc = "`reset()` method sets DATA0_CMB6 to value 0"]
impl crate::Resettable for DATA0_CMB6_SPEC { impl crate::Resettable for Data0Cmb6Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb7.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB7` reader"] #[doc = "Register `DATA0_CMB7` reader"]
pub struct R(crate::R<DATA0_CMB7_SPEC>); pub type R = crate::R<Data0Cmb7Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB7_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB7_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB7` writer"] #[doc = "Register `DATA0_CMB7` writer"]
pub struct W(crate::W<DATA0_CMB7_SPEC>); pub type W = crate::W<Data0Cmb7Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB7_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB7_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb7Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb7Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb7](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb7::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB7_SPEC; pub struct Data0Cmb7Spec;
impl crate::RegisterSpec for DATA0_CMB7_SPEC { impl crate::RegisterSpec for Data0Cmb7Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb7::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb7::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB7_SPEC { impl crate::Readable for Data0Cmb7Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb7::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb7Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb7::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB7_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB7 to value 0"] #[doc = "`reset()` method sets DATA0_CMB7 to value 0"]
impl crate::Resettable for DATA0_CMB7_SPEC { impl crate::Resettable for Data0Cmb7Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb8.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB8` reader"] #[doc = "Register `DATA0_CMB8` reader"]
pub struct R(crate::R<DATA0_CMB8_SPEC>); pub type R = crate::R<Data0Cmb8Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB8_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB8_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB8` writer"] #[doc = "Register `DATA0_CMB8` writer"]
pub struct W(crate::W<DATA0_CMB8_SPEC>); pub type W = crate::W<Data0Cmb8Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB8_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB8_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb8Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb8Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb8](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb8::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB8_SPEC; pub struct Data0Cmb8Spec;
impl crate::RegisterSpec for DATA0_CMB8_SPEC { impl crate::RegisterSpec for Data0Cmb8Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb8::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb8::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB8_SPEC { impl crate::Readable for Data0Cmb8Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb8::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb8Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb8::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB8_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB8 to value 0"] #[doc = "`reset()` method sets DATA0_CMB8 to value 0"]
impl crate::Resettable for DATA0_CMB8_SPEC { impl crate::Resettable for Data0Cmb8Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_cmb9.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_CMB9` reader"] #[doc = "Register `DATA0_CMB9` reader"]
pub struct R(crate::R<DATA0_CMB9_SPEC>); pub type R = crate::R<Data0Cmb9Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_CMB9_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_CMB9_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_CMB9` writer"] #[doc = "Register `DATA0_CMB9` writer"]
pub struct W(crate::W<DATA0_CMB9_SPEC>); pub type W = crate::W<Data0Cmb9Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_CMB9_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_CMB9_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0Cmb9Spec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0Cmb9Spec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb9](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_cmb9::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_CMB9_SPEC; pub struct Data0Cmb9Spec;
impl crate::RegisterSpec for DATA0_CMB9_SPEC { impl crate::RegisterSpec for Data0Cmb9Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_cmb9::R](R) reader structure"] #[doc = "`read()` method returns [`data0_cmb9::R`](R) reader structure"]
impl crate::Readable for DATA0_CMB9_SPEC { impl crate::Readable for Data0Cmb9Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_cmb9::W`](W) writer structure"]
} impl crate::Writable for Data0Cmb9Spec {
#[doc = "`write(|w| ..)` method takes [data0_cmb9::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_CMB9_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_CMB9 to value 0"] #[doc = "`reset()` method sets DATA0_CMB9 to value 0"]
impl crate::Resettable for DATA0_CMB9_SPEC { impl crate::Resettable for Data0Cmb9Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data0_hcmb.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA0_HCMB` reader"] #[doc = "Register `DATA0_HCMB` reader"]
pub struct R(crate::R<DATA0_HCMB_SPEC>); pub type R = crate::R<Data0HcmbSpec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA0_HCMB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA0_HCMB_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA0_HCMB_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA0_HCMB` writer"] #[doc = "Register `DATA0_HCMB` writer"]
pub struct W(crate::W<DATA0_HCMB_SPEC>); pub type W = crate::W<Data0HcmbSpec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA0_HCMB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA0_HCMB_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA0_HCMB_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
impl BYTE1_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE1_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub struct BYTE1_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE2` reader - Data Byte 2"] #[doc = "Field `BYTE2` reader - Data Byte 2"]
pub struct BYTE2_R(crate::FieldReader<u8, u8>); pub type Byte2R = crate::FieldReader;
impl BYTE2_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE2_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE2_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE2` writer - Data Byte 2"] #[doc = "Field `BYTE2` writer - Data Byte 2"]
pub struct BYTE2_W<'a> { pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE1` reader - Data Byte 1"]
} pub type Byte1R = crate::FieldReader;
impl<'a> BYTE2_W<'a> { #[doc = "Field `BYTE1` writer - Data Byte 1"]
#[doc = r"Writes raw bits to the field"] pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> BYTE1_R {
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&self) -> BYTE2_R { pub fn byte2(&self) -> Byte2R {
BYTE2_R::new((self.bits & 0xff) as u8) Byte2R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&self) -> Byte1R {
Byte1R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
pub fn byte1(&mut self) -> BYTE1_W {
BYTE1_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 2"] #[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)] #[inline(always)]
pub fn byte2(&mut self) -> BYTE2_W { #[must_use]
BYTE2_W { w: self } pub fn byte2(&mut self) -> Byte2W<Data0HcmbSpec> {
Byte2W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte1(&mut self) -> Byte1W<Data0HcmbSpec> {
self Byte1W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_hcmb](index.html) module"] #[doc = "CAN Frame Data Word 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data0_hcmb::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data0_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA0_HCMB_SPEC; pub struct Data0HcmbSpec;
impl crate::RegisterSpec for DATA0_HCMB_SPEC { impl crate::RegisterSpec for Data0HcmbSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data0_hcmb::R](R) reader structure"] #[doc = "`read()` method returns [`data0_hcmb::R`](R) reader structure"]
impl crate::Readable for DATA0_HCMB_SPEC { impl crate::Readable for Data0HcmbSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data0_hcmb::W`](W) writer structure"]
} impl crate::Writable for Data0HcmbSpec {
#[doc = "`write(|w| ..)` method takes [data0_hcmb::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA0_HCMB_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA0_HCMB to value 0"] #[doc = "`reset()` method sets DATA0_HCMB to value 0"]
impl crate::Resettable for DATA0_HCMB_SPEC { impl crate::Resettable for Data0HcmbSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb0.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB0` reader"] #[doc = "Register `DATA1_CMB0` reader"]
pub struct R(crate::R<DATA1_CMB0_SPEC>); pub type R = crate::R<Data1Cmb0Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB0_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB0_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB0` writer"] #[doc = "Register `DATA1_CMB0` writer"]
pub struct W(crate::W<DATA1_CMB0_SPEC>); pub type W = crate::W<Data1Cmb0Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB0_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB0_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb0Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb0Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 1\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb0](index.html) module"] #[doc = "CAN Frame Data Word 1\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb0::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB0_SPEC; pub struct Data1Cmb0Spec;
impl crate::RegisterSpec for DATA1_CMB0_SPEC { impl crate::RegisterSpec for Data1Cmb0Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb0::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb0::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB0_SPEC { impl crate::Readable for Data1Cmb0Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb0::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb0Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb0::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB0_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB0 to value 0"] #[doc = "`reset()` method sets DATA1_CMB0 to value 0"]
impl crate::Resettable for DATA1_CMB0_SPEC { impl crate::Resettable for Data1Cmb0Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb1.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB1` reader"] #[doc = "Register `DATA1_CMB1` reader"]
pub struct R(crate::R<DATA1_CMB1_SPEC>); pub type R = crate::R<Data1Cmb1Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB1_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB1_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB1` writer"] #[doc = "Register `DATA1_CMB1` writer"]
pub struct W(crate::W<DATA1_CMB1_SPEC>); pub type W = crate::W<Data1Cmb1Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB1_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB1_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb1Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb1Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb1](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB1_SPEC; pub struct Data1Cmb1Spec;
impl crate::RegisterSpec for DATA1_CMB1_SPEC { impl crate::RegisterSpec for Data1Cmb1Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb1::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb1::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB1_SPEC { impl crate::Readable for Data1Cmb1Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb1::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb1Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb1::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB1_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB1 to value 0"] #[doc = "`reset()` method sets DATA1_CMB1 to value 0"]
impl crate::Resettable for DATA1_CMB1_SPEC { impl crate::Resettable for Data1Cmb1Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb10.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB10` reader"] #[doc = "Register `DATA1_CMB10` reader"]
pub struct R(crate::R<DATA1_CMB10_SPEC>); pub type R = crate::R<Data1Cmb10Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB10_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB10_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB10` writer"] #[doc = "Register `DATA1_CMB10` writer"]
pub struct W(crate::W<DATA1_CMB10_SPEC>); pub type W = crate::W<Data1Cmb10Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB10_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB10_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb10Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb10Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb10](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb10::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB10_SPEC; pub struct Data1Cmb10Spec;
impl crate::RegisterSpec for DATA1_CMB10_SPEC { impl crate::RegisterSpec for Data1Cmb10Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb10::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb10::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB10_SPEC { impl crate::Readable for Data1Cmb10Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb10::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb10Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb10::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB10_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB10 to value 0"] #[doc = "`reset()` method sets DATA1_CMB10 to value 0"]
impl crate::Resettable for DATA1_CMB10_SPEC { impl crate::Resettable for Data1Cmb10Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb11.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB11` reader"] #[doc = "Register `DATA1_CMB11` reader"]
pub struct R(crate::R<DATA1_CMB11_SPEC>); pub type R = crate::R<Data1Cmb11Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB11_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB11_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB11` writer"] #[doc = "Register `DATA1_CMB11` writer"]
pub struct W(crate::W<DATA1_CMB11_SPEC>); pub type W = crate::W<Data1Cmb11Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB11_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB11_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb11Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb11Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb11](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb11::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB11_SPEC; pub struct Data1Cmb11Spec;
impl crate::RegisterSpec for DATA1_CMB11_SPEC { impl crate::RegisterSpec for Data1Cmb11Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb11::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb11::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB11_SPEC { impl crate::Readable for Data1Cmb11Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb11::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb11Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb11::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB11_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB11 to value 0"] #[doc = "`reset()` method sets DATA1_CMB11 to value 0"]
impl crate::Resettable for DATA1_CMB11_SPEC { impl crate::Resettable for Data1Cmb11Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb12.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB12` reader"] #[doc = "Register `DATA1_CMB12` reader"]
pub struct R(crate::R<DATA1_CMB12_SPEC>); pub type R = crate::R<Data1Cmb12Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB12_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB12_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB12` writer"] #[doc = "Register `DATA1_CMB12` writer"]
pub struct W(crate::W<DATA1_CMB12_SPEC>); pub type W = crate::W<Data1Cmb12Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB12_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB12_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb12Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb12Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb12](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb12::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB12_SPEC; pub struct Data1Cmb12Spec;
impl crate::RegisterSpec for DATA1_CMB12_SPEC { impl crate::RegisterSpec for Data1Cmb12Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb12::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb12::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB12_SPEC { impl crate::Readable for Data1Cmb12Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb12::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb12Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb12::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB12_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB12 to value 0"] #[doc = "`reset()` method sets DATA1_CMB12 to value 0"]
impl crate::Resettable for DATA1_CMB12_SPEC { impl crate::Resettable for Data1Cmb12Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb13.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB13` reader"] #[doc = "Register `DATA1_CMB13` reader"]
pub struct R(crate::R<DATA1_CMB13_SPEC>); pub type R = crate::R<Data1Cmb13Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB13_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB13_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB13` writer"] #[doc = "Register `DATA1_CMB13` writer"]
pub struct W(crate::W<DATA1_CMB13_SPEC>); pub type W = crate::W<Data1Cmb13Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB13_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB13_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb13Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb13Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb13](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb13::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB13_SPEC; pub struct Data1Cmb13Spec;
impl crate::RegisterSpec for DATA1_CMB13_SPEC { impl crate::RegisterSpec for Data1Cmb13Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb13::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb13::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB13_SPEC { impl crate::Readable for Data1Cmb13Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb13::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb13Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb13::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB13_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB13 to value 0"] #[doc = "`reset()` method sets DATA1_CMB13 to value 0"]
impl crate::Resettable for DATA1_CMB13_SPEC { impl crate::Resettable for Data1Cmb13Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb14.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB14` reader"] #[doc = "Register `DATA1_CMB14` reader"]
pub struct R(crate::R<DATA1_CMB14_SPEC>); pub type R = crate::R<Data1Cmb14Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB14_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB14_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB14` writer"] #[doc = "Register `DATA1_CMB14` writer"]
pub struct W(crate::W<DATA1_CMB14_SPEC>); pub type W = crate::W<Data1Cmb14Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB14_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB14_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb14Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb14Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb14](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb14::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB14_SPEC; pub struct Data1Cmb14Spec;
impl crate::RegisterSpec for DATA1_CMB14_SPEC { impl crate::RegisterSpec for Data1Cmb14Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb14::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb14::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB14_SPEC { impl crate::Readable for Data1Cmb14Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb14::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb14Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb14::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB14_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB14 to value 0"] #[doc = "`reset()` method sets DATA1_CMB14 to value 0"]
impl crate::Resettable for DATA1_CMB14_SPEC { impl crate::Resettable for Data1Cmb14Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb2.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB2` reader"] #[doc = "Register `DATA1_CMB2` reader"]
pub struct R(crate::R<DATA1_CMB2_SPEC>); pub type R = crate::R<Data1Cmb2Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB2_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB2_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB2` writer"] #[doc = "Register `DATA1_CMB2` writer"]
pub struct W(crate::W<DATA1_CMB2_SPEC>); pub type W = crate::W<Data1Cmb2Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB2_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB2_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb2Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb2Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb2](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb2::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB2_SPEC; pub struct Data1Cmb2Spec;
impl crate::RegisterSpec for DATA1_CMB2_SPEC { impl crate::RegisterSpec for Data1Cmb2Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb2::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb2::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB2_SPEC { impl crate::Readable for Data1Cmb2Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb2::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb2Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb2::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB2_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB2 to value 0"] #[doc = "`reset()` method sets DATA1_CMB2 to value 0"]
impl crate::Resettable for DATA1_CMB2_SPEC { impl crate::Resettable for Data1Cmb2Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb3.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB3` reader"] #[doc = "Register `DATA1_CMB3` reader"]
pub struct R(crate::R<DATA1_CMB3_SPEC>); pub type R = crate::R<Data1Cmb3Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB3_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB3_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB3` writer"] #[doc = "Register `DATA1_CMB3` writer"]
pub struct W(crate::W<DATA1_CMB3_SPEC>); pub type W = crate::W<Data1Cmb3Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB3_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB3_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb3Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb3Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb3](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb3::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB3_SPEC; pub struct Data1Cmb3Spec;
impl crate::RegisterSpec for DATA1_CMB3_SPEC { impl crate::RegisterSpec for Data1Cmb3Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb3::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb3::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB3_SPEC { impl crate::Readable for Data1Cmb3Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb3::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb3Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb3::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB3_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB3 to value 0"] #[doc = "`reset()` method sets DATA1_CMB3 to value 0"]
impl crate::Resettable for DATA1_CMB3_SPEC { impl crate::Resettable for Data1Cmb3Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb4.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB4` reader"] #[doc = "Register `DATA1_CMB4` reader"]
pub struct R(crate::R<DATA1_CMB4_SPEC>); pub type R = crate::R<Data1Cmb4Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB4_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB4_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB4` writer"] #[doc = "Register `DATA1_CMB4` writer"]
pub struct W(crate::W<DATA1_CMB4_SPEC>); pub type W = crate::W<Data1Cmb4Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB4_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB4_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb4Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb4Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb4](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb4::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB4_SPEC; pub struct Data1Cmb4Spec;
impl crate::RegisterSpec for DATA1_CMB4_SPEC { impl crate::RegisterSpec for Data1Cmb4Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb4::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb4::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB4_SPEC { impl crate::Readable for Data1Cmb4Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb4::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb4Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb4::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB4_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB4 to value 0"] #[doc = "`reset()` method sets DATA1_CMB4 to value 0"]
impl crate::Resettable for DATA1_CMB4_SPEC { impl crate::Resettable for Data1Cmb4Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb5.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB5` reader"] #[doc = "Register `DATA1_CMB5` reader"]
pub struct R(crate::R<DATA1_CMB5_SPEC>); pub type R = crate::R<Data1Cmb5Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB5_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB5_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB5` writer"] #[doc = "Register `DATA1_CMB5` writer"]
pub struct W(crate::W<DATA1_CMB5_SPEC>); pub type W = crate::W<Data1Cmb5Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB5_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB5_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb5Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb5Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb5](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb5::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB5_SPEC; pub struct Data1Cmb5Spec;
impl crate::RegisterSpec for DATA1_CMB5_SPEC { impl crate::RegisterSpec for Data1Cmb5Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb5::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb5::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB5_SPEC { impl crate::Readable for Data1Cmb5Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb5::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb5Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb5::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB5_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB5 to value 0"] #[doc = "`reset()` method sets DATA1_CMB5 to value 0"]
impl crate::Resettable for DATA1_CMB5_SPEC { impl crate::Resettable for Data1Cmb5Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb6.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB6` reader"] #[doc = "Register `DATA1_CMB6` reader"]
pub struct R(crate::R<DATA1_CMB6_SPEC>); pub type R = crate::R<Data1Cmb6Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB6_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB6_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB6` writer"] #[doc = "Register `DATA1_CMB6` writer"]
pub struct W(crate::W<DATA1_CMB6_SPEC>); pub type W = crate::W<Data1Cmb6Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB6_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB6_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb6Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb6Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb6](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb6::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB6_SPEC; pub struct Data1Cmb6Spec;
impl crate::RegisterSpec for DATA1_CMB6_SPEC { impl crate::RegisterSpec for Data1Cmb6Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb6::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb6::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB6_SPEC { impl crate::Readable for Data1Cmb6Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb6::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb6Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb6::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB6_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB6 to value 0"] #[doc = "`reset()` method sets DATA1_CMB6 to value 0"]
impl crate::Resettable for DATA1_CMB6_SPEC { impl crate::Resettable for Data1Cmb6Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb7.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB7` reader"] #[doc = "Register `DATA1_CMB7` reader"]
pub struct R(crate::R<DATA1_CMB7_SPEC>); pub type R = crate::R<Data1Cmb7Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB7_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB7_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB7` writer"] #[doc = "Register `DATA1_CMB7` writer"]
pub struct W(crate::W<DATA1_CMB7_SPEC>); pub type W = crate::W<Data1Cmb7Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB7_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB7_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb7Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb7Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb7](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb7::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB7_SPEC; pub struct Data1Cmb7Spec;
impl crate::RegisterSpec for DATA1_CMB7_SPEC { impl crate::RegisterSpec for Data1Cmb7Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb7::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb7::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB7_SPEC { impl crate::Readable for Data1Cmb7Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb7::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb7Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb7::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB7_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB7 to value 0"] #[doc = "`reset()` method sets DATA1_CMB7 to value 0"]
impl crate::Resettable for DATA1_CMB7_SPEC { impl crate::Resettable for Data1Cmb7Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb8.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB8` reader"] #[doc = "Register `DATA1_CMB8` reader"]
pub struct R(crate::R<DATA1_CMB8_SPEC>); pub type R = crate::R<Data1Cmb8Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB8_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB8_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB8` writer"] #[doc = "Register `DATA1_CMB8` writer"]
pub struct W(crate::W<DATA1_CMB8_SPEC>); pub type W = crate::W<Data1Cmb8Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB8_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB8_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb8Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb8Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb8](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb8::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB8_SPEC; pub struct Data1Cmb8Spec;
impl crate::RegisterSpec for DATA1_CMB8_SPEC { impl crate::RegisterSpec for Data1Cmb8Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb8::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb8::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB8_SPEC { impl crate::Readable for Data1Cmb8Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb8::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb8Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb8::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB8_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB8 to value 0"] #[doc = "`reset()` method sets DATA1_CMB8 to value 0"]
impl crate::Resettable for DATA1_CMB8_SPEC { impl crate::Resettable for Data1Cmb8Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_cmb9.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_CMB9` reader"] #[doc = "Register `DATA1_CMB9` reader"]
pub struct R(crate::R<DATA1_CMB9_SPEC>); pub type R = crate::R<Data1Cmb9Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_CMB9_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_CMB9_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_CMB9` writer"] #[doc = "Register `DATA1_CMB9` writer"]
pub struct W(crate::W<DATA1_CMB9_SPEC>); pub type W = crate::W<Data1Cmb9Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_CMB9_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_CMB9_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1Cmb9Spec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1Cmb9Spec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb9](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_cmb9::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_CMB9_SPEC; pub struct Data1Cmb9Spec;
impl crate::RegisterSpec for DATA1_CMB9_SPEC { impl crate::RegisterSpec for Data1Cmb9Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_cmb9::R](R) reader structure"] #[doc = "`read()` method returns [`data1_cmb9::R`](R) reader structure"]
impl crate::Readable for DATA1_CMB9_SPEC { impl crate::Readable for Data1Cmb9Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_cmb9::W`](W) writer structure"]
} impl crate::Writable for Data1Cmb9Spec {
#[doc = "`write(|w| ..)` method takes [data1_cmb9::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_CMB9_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_CMB9 to value 0"] #[doc = "`reset()` method sets DATA1_CMB9 to value 0"]
impl crate::Resettable for DATA1_CMB9_SPEC { impl crate::Resettable for Data1Cmb9Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data1_hcmb.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA1_HCMB` reader"] #[doc = "Register `DATA1_HCMB` reader"]
pub struct R(crate::R<DATA1_HCMB_SPEC>); pub type R = crate::R<Data1HcmbSpec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA1_HCMB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA1_HCMB_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA1_HCMB_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA1_HCMB` writer"] #[doc = "Register `DATA1_HCMB` writer"]
pub struct W(crate::W<DATA1_HCMB_SPEC>); pub type W = crate::W<Data1HcmbSpec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA1_HCMB_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA1_HCMB_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA1_HCMB_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
impl BYTE3_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub struct BYTE3_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE4` reader - Data Byte 4"] #[doc = "Field `BYTE4` reader - Data Byte 4"]
pub struct BYTE4_R(crate::FieldReader<u8, u8>); pub type Byte4R = crate::FieldReader;
impl BYTE4_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE4_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE4_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE4` writer - Data Byte 4"] #[doc = "Field `BYTE4` writer - Data Byte 4"]
pub struct BYTE4_W<'a> { pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE3` reader - Data Byte 3"]
} pub type Byte3R = crate::FieldReader;
impl<'a> BYTE4_W<'a> { #[doc = "Field `BYTE3` writer - Data Byte 3"]
#[doc = r"Writes raw bits to the field"] pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> BYTE3_R {
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&self) -> BYTE4_R { pub fn byte4(&self) -> Byte4R {
BYTE4_R::new((self.bits & 0xff) as u8) Byte4R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&self) -> Byte3R {
Byte3R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
pub fn byte3(&mut self) -> BYTE3_W {
BYTE3_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 4"] #[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)] #[inline(always)]
pub fn byte4(&mut self) -> BYTE4_W { #[must_use]
BYTE4_W { w: self } pub fn byte4(&mut self) -> Byte4W<Data1HcmbSpec> {
Byte4W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte3(&mut self) -> Byte3W<Data1HcmbSpec> {
self Byte3W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_hcmb](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data1_hcmb::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data1_hcmb::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA1_HCMB_SPEC; pub struct Data1HcmbSpec;
impl crate::RegisterSpec for DATA1_HCMB_SPEC { impl crate::RegisterSpec for Data1HcmbSpec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data1_hcmb::R](R) reader structure"] #[doc = "`read()` method returns [`data1_hcmb::R`](R) reader structure"]
impl crate::Readable for DATA1_HCMB_SPEC { impl crate::Readable for Data1HcmbSpec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data1_hcmb::W`](W) writer structure"]
} impl crate::Writable for Data1HcmbSpec {
#[doc = "`write(|w| ..)` method takes [data1_hcmb::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA1_HCMB_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA1_HCMB to value 0"] #[doc = "`reset()` method sets DATA1_HCMB to value 0"]
impl crate::Resettable for DATA1_HCMB_SPEC { impl crate::Resettable for Data1HcmbSpec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb0.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB0` reader"] #[doc = "Register `DATA2_CMB0` reader"]
pub struct R(crate::R<DATA2_CMB0_SPEC>); pub type R = crate::R<Data2Cmb0Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB0_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB0_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB0` writer"] #[doc = "Register `DATA2_CMB0` writer"]
pub struct W(crate::W<DATA2_CMB0_SPEC>); pub type W = crate::W<Data2Cmb0Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB0_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB0_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB0_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb0Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb0Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb0](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb0::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB0_SPEC; pub struct Data2Cmb0Spec;
impl crate::RegisterSpec for DATA2_CMB0_SPEC { impl crate::RegisterSpec for Data2Cmb0Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb0::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb0::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB0_SPEC { impl crate::Readable for Data2Cmb0Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb0::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb0Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb0::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB0_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB0 to value 0"] #[doc = "`reset()` method sets DATA2_CMB0 to value 0"]
impl crate::Resettable for DATA2_CMB0_SPEC { impl crate::Resettable for Data2Cmb0Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb1.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB1` reader"] #[doc = "Register `DATA2_CMB1` reader"]
pub struct R(crate::R<DATA2_CMB1_SPEC>); pub type R = crate::R<Data2Cmb1Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB1_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB1_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB1` writer"] #[doc = "Register `DATA2_CMB1` writer"]
pub struct W(crate::W<DATA2_CMB1_SPEC>); pub type W = crate::W<Data2Cmb1Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB1_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB1_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb1Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb1Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb1](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB1_SPEC; pub struct Data2Cmb1Spec;
impl crate::RegisterSpec for DATA2_CMB1_SPEC { impl crate::RegisterSpec for Data2Cmb1Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb1::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb1::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB1_SPEC { impl crate::Readable for Data2Cmb1Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb1::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb1Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb1::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB1_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB1 to value 0"] #[doc = "`reset()` method sets DATA2_CMB1 to value 0"]
impl crate::Resettable for DATA2_CMB1_SPEC { impl crate::Resettable for Data2Cmb1Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb10.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB10` reader"] #[doc = "Register `DATA2_CMB10` reader"]
pub struct R(crate::R<DATA2_CMB10_SPEC>); pub type R = crate::R<Data2Cmb10Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB10_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB10_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB10` writer"] #[doc = "Register `DATA2_CMB10` writer"]
pub struct W(crate::W<DATA2_CMB10_SPEC>); pub type W = crate::W<Data2Cmb10Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB10_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB10_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB10_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb10Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb10Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb10](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb10::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb10::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB10_SPEC; pub struct Data2Cmb10Spec;
impl crate::RegisterSpec for DATA2_CMB10_SPEC { impl crate::RegisterSpec for Data2Cmb10Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb10::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb10::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB10_SPEC { impl crate::Readable for Data2Cmb10Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb10::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb10Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb10::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB10_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB10 to value 0"] #[doc = "`reset()` method sets DATA2_CMB10 to value 0"]
impl crate::Resettable for DATA2_CMB10_SPEC { impl crate::Resettable for Data2Cmb10Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb11.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB11` reader"] #[doc = "Register `DATA2_CMB11` reader"]
pub struct R(crate::R<DATA2_CMB11_SPEC>); pub type R = crate::R<Data2Cmb11Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB11_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB11_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB11` writer"] #[doc = "Register `DATA2_CMB11` writer"]
pub struct W(crate::W<DATA2_CMB11_SPEC>); pub type W = crate::W<Data2Cmb11Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB11_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB11_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB11_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb11Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb11Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb11](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb11::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb11::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB11_SPEC; pub struct Data2Cmb11Spec;
impl crate::RegisterSpec for DATA2_CMB11_SPEC { impl crate::RegisterSpec for Data2Cmb11Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb11::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb11::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB11_SPEC { impl crate::Readable for Data2Cmb11Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb11::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb11Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb11::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB11_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB11 to value 0"] #[doc = "`reset()` method sets DATA2_CMB11 to value 0"]
impl crate::Resettable for DATA2_CMB11_SPEC { impl crate::Resettable for Data2Cmb11Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb12.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB12` reader"] #[doc = "Register `DATA2_CMB12` reader"]
pub struct R(crate::R<DATA2_CMB12_SPEC>); pub type R = crate::R<Data2Cmb12Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB12_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB12_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB12` writer"] #[doc = "Register `DATA2_CMB12` writer"]
pub struct W(crate::W<DATA2_CMB12_SPEC>); pub type W = crate::W<Data2Cmb12Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB12_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB12_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB12_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb12Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb12Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb12](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb12::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb12::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB12_SPEC; pub struct Data2Cmb12Spec;
impl crate::RegisterSpec for DATA2_CMB12_SPEC { impl crate::RegisterSpec for Data2Cmb12Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb12::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb12::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB12_SPEC { impl crate::Readable for Data2Cmb12Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb12::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb12Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb12::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB12_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB12 to value 0"] #[doc = "`reset()` method sets DATA2_CMB12 to value 0"]
impl crate::Resettable for DATA2_CMB12_SPEC { impl crate::Resettable for Data2Cmb12Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb13.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB13` reader"] #[doc = "Register `DATA2_CMB13` reader"]
pub struct R(crate::R<DATA2_CMB13_SPEC>); pub type R = crate::R<Data2Cmb13Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB13_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB13_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB13` writer"] #[doc = "Register `DATA2_CMB13` writer"]
pub struct W(crate::W<DATA2_CMB13_SPEC>); pub type W = crate::W<Data2Cmb13Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB13_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB13_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB13_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb13Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb13Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb13](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb13::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb13::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB13_SPEC; pub struct Data2Cmb13Spec;
impl crate::RegisterSpec for DATA2_CMB13_SPEC { impl crate::RegisterSpec for Data2Cmb13Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb13::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb13::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB13_SPEC { impl crate::Readable for Data2Cmb13Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb13::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb13Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb13::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB13_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB13 to value 0"] #[doc = "`reset()` method sets DATA2_CMB13 to value 0"]
impl crate::Resettable for DATA2_CMB13_SPEC { impl crate::Resettable for Data2Cmb13Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb14.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB14` reader"] #[doc = "Register `DATA2_CMB14` reader"]
pub struct R(crate::R<DATA2_CMB14_SPEC>); pub type R = crate::R<Data2Cmb14Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB14_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB14_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB14` writer"] #[doc = "Register `DATA2_CMB14` writer"]
pub struct W(crate::W<DATA2_CMB14_SPEC>); pub type W = crate::W<Data2Cmb14Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB14_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB14_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB14_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb14Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb14Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb14](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb14::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb14::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB14_SPEC; pub struct Data2Cmb14Spec;
impl crate::RegisterSpec for DATA2_CMB14_SPEC { impl crate::RegisterSpec for Data2Cmb14Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb14::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb14::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB14_SPEC { impl crate::Readable for Data2Cmb14Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb14::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb14Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb14::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB14_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB14 to value 0"] #[doc = "`reset()` method sets DATA2_CMB14 to value 0"]
impl crate::Resettable for DATA2_CMB14_SPEC { impl crate::Resettable for Data2Cmb14Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb2.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB2` reader"] #[doc = "Register `DATA2_CMB2` reader"]
pub struct R(crate::R<DATA2_CMB2_SPEC>); pub type R = crate::R<Data2Cmb2Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB2_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB2_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB2` writer"] #[doc = "Register `DATA2_CMB2` writer"]
pub struct W(crate::W<DATA2_CMB2_SPEC>); pub type W = crate::W<Data2Cmb2Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB2_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB2_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb2Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb2Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb2](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb2::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB2_SPEC; pub struct Data2Cmb2Spec;
impl crate::RegisterSpec for DATA2_CMB2_SPEC { impl crate::RegisterSpec for Data2Cmb2Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb2::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb2::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB2_SPEC { impl crate::Readable for Data2Cmb2Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb2::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb2Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb2::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB2_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB2 to value 0"] #[doc = "`reset()` method sets DATA2_CMB2 to value 0"]
impl crate::Resettable for DATA2_CMB2_SPEC { impl crate::Resettable for Data2Cmb2Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb3.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB3` reader"] #[doc = "Register `DATA2_CMB3` reader"]
pub struct R(crate::R<DATA2_CMB3_SPEC>); pub type R = crate::R<Data2Cmb3Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB3_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB3_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB3` writer"] #[doc = "Register `DATA2_CMB3` writer"]
pub struct W(crate::W<DATA2_CMB3_SPEC>); pub type W = crate::W<Data2Cmb3Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB3_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB3_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB3_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb3Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb3Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb3](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb3::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB3_SPEC; pub struct Data2Cmb3Spec;
impl crate::RegisterSpec for DATA2_CMB3_SPEC { impl crate::RegisterSpec for Data2Cmb3Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb3::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb3::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB3_SPEC { impl crate::Readable for Data2Cmb3Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb3::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb3Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb3::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB3_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB3 to value 0"] #[doc = "`reset()` method sets DATA2_CMB3 to value 0"]
impl crate::Resettable for DATA2_CMB3_SPEC { impl crate::Resettable for Data2Cmb3Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb4.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB4` reader"] #[doc = "Register `DATA2_CMB4` reader"]
pub struct R(crate::R<DATA2_CMB4_SPEC>); pub type R = crate::R<Data2Cmb4Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB4_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB4_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB4` writer"] #[doc = "Register `DATA2_CMB4` writer"]
pub struct W(crate::W<DATA2_CMB4_SPEC>); pub type W = crate::W<Data2Cmb4Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB4_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB4_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB4_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb4Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb4Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb4](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb4::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb4::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB4_SPEC; pub struct Data2Cmb4Spec;
impl crate::RegisterSpec for DATA2_CMB4_SPEC { impl crate::RegisterSpec for Data2Cmb4Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb4::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb4::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB4_SPEC { impl crate::Readable for Data2Cmb4Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb4::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb4Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb4::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB4_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB4 to value 0"] #[doc = "`reset()` method sets DATA2_CMB4 to value 0"]
impl crate::Resettable for DATA2_CMB4_SPEC { impl crate::Resettable for Data2Cmb4Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb5.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB5` reader"] #[doc = "Register `DATA2_CMB5` reader"]
pub struct R(crate::R<DATA2_CMB5_SPEC>); pub type R = crate::R<Data2Cmb5Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB5_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB5_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB5` writer"] #[doc = "Register `DATA2_CMB5` writer"]
pub struct W(crate::W<DATA2_CMB5_SPEC>); pub type W = crate::W<Data2Cmb5Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB5_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB5_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB5_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb5Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb5Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb5](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb5::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb5::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB5_SPEC; pub struct Data2Cmb5Spec;
impl crate::RegisterSpec for DATA2_CMB5_SPEC { impl crate::RegisterSpec for Data2Cmb5Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb5::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb5::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB5_SPEC { impl crate::Readable for Data2Cmb5Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb5::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb5Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb5::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB5_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB5 to value 0"] #[doc = "`reset()` method sets DATA2_CMB5 to value 0"]
impl crate::Resettable for DATA2_CMB5_SPEC { impl crate::Resettable for Data2Cmb5Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb6.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB6` reader"] #[doc = "Register `DATA2_CMB6` reader"]
pub struct R(crate::R<DATA2_CMB6_SPEC>); pub type R = crate::R<Data2Cmb6Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB6_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB6_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB6` writer"] #[doc = "Register `DATA2_CMB6` writer"]
pub struct W(crate::W<DATA2_CMB6_SPEC>); pub type W = crate::W<Data2Cmb6Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB6_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB6_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB6_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb6Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb6Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb6](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb6::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb6::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB6_SPEC; pub struct Data2Cmb6Spec;
impl crate::RegisterSpec for DATA2_CMB6_SPEC { impl crate::RegisterSpec for Data2Cmb6Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb6::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb6::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB6_SPEC { impl crate::Readable for Data2Cmb6Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb6::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb6Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb6::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB6_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB6 to value 0"] #[doc = "`reset()` method sets DATA2_CMB6 to value 0"]
impl crate::Resettable for DATA2_CMB6_SPEC { impl crate::Resettable for Data2Cmb6Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb7.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB7` reader"] #[doc = "Register `DATA2_CMB7` reader"]
pub struct R(crate::R<DATA2_CMB7_SPEC>); pub type R = crate::R<Data2Cmb7Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB7_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB7_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB7` writer"] #[doc = "Register `DATA2_CMB7` writer"]
pub struct W(crate::W<DATA2_CMB7_SPEC>); pub type W = crate::W<Data2Cmb7Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB7_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB7_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB7_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb7Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb7Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb7](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb7::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb7::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB7_SPEC; pub struct Data2Cmb7Spec;
impl crate::RegisterSpec for DATA2_CMB7_SPEC { impl crate::RegisterSpec for Data2Cmb7Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb7::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb7::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB7_SPEC { impl crate::Readable for Data2Cmb7Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb7::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb7Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb7::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB7_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB7 to value 0"] #[doc = "`reset()` method sets DATA2_CMB7 to value 0"]
impl crate::Resettable for DATA2_CMB7_SPEC { impl crate::Resettable for Data2Cmb7Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb8.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB8` reader"] #[doc = "Register `DATA2_CMB8` reader"]
pub struct R(crate::R<DATA2_CMB8_SPEC>); pub type R = crate::R<Data2Cmb8Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB8_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB8_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB8` writer"] #[doc = "Register `DATA2_CMB8` writer"]
pub struct W(crate::W<DATA2_CMB8_SPEC>); pub type W = crate::W<Data2Cmb8Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB8_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB8_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB8_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb8Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb8Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb8](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb8::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb8::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB8_SPEC; pub struct Data2Cmb8Spec;
impl crate::RegisterSpec for DATA2_CMB8_SPEC { impl crate::RegisterSpec for Data2Cmb8Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb8::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb8::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB8_SPEC { impl crate::Readable for Data2Cmb8Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb8::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb8Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb8::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB8_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB8 to value 0"] #[doc = "`reset()` method sets DATA2_CMB8 to value 0"]
impl crate::Resettable for DATA2_CMB8_SPEC { impl crate::Resettable for Data2Cmb8Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

153
va416xx/src/can0/data2_cmb9.rs
View File

@ -1,140 +1,55 @@
#[doc = "Register `DATA2_CMB9` reader"] #[doc = "Register `DATA2_CMB9` reader"]
pub struct R(crate::R<DATA2_CMB9_SPEC>); pub type R = crate::R<Data2Cmb9Spec>;
impl core::ops::Deref for R {
type Target = crate::R<DATA2_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<DATA2_CMB9_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<DATA2_CMB9_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DATA2_CMB9` writer"] #[doc = "Register `DATA2_CMB9` writer"]
pub struct W(crate::W<DATA2_CMB9_SPEC>); pub type W = crate::W<Data2Cmb9Spec>;
impl core::ops::Deref for W {
type Target = crate::W<DATA2_CMB9_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<DATA2_CMB9_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<DATA2_CMB9_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
impl BYTE5_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE5_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE5_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub struct BYTE5_W<'a> {
w: &'a mut W,
}
impl<'a> BYTE5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
self.w
}
}
#[doc = "Field `BYTE6` reader - Data Byte 6"] #[doc = "Field `BYTE6` reader - Data Byte 6"]
pub struct BYTE6_R(crate::FieldReader<u8, u8>); pub type Byte6R = crate::FieldReader;
impl BYTE6_R {
#[inline(always)]
pub(crate) fn new(bits: u8) -> Self {
BYTE6_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for BYTE6_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BYTE6` writer - Data Byte 6"] #[doc = "Field `BYTE6` writer - Data Byte 6"]
pub struct BYTE6_W<'a> { pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
w: &'a mut W, #[doc = "Field `BYTE5` reader - Data Byte 5"]
} pub type Byte5R = crate::FieldReader;
impl<'a> BYTE6_W<'a> { #[doc = "Field `BYTE5` writer - Data Byte 5"]
#[doc = r"Writes raw bits to the field"] pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
self.w
}
}
impl R { impl R {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> BYTE5_R {
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&self) -> BYTE6_R { pub fn byte6(&self) -> Byte6R {
BYTE6_R::new((self.bits & 0xff) as u8) Byte6R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&self) -> Byte5R {
Byte5R::new(((self.bits >> 8) & 0xff) as u8)
} }
} }
impl W { impl W {
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
pub fn byte5(&mut self) -> BYTE5_W {
BYTE5_W { w: self }
}
#[doc = "Bits 0:7 - Data Byte 6"] #[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)] #[inline(always)]
pub fn byte6(&mut self) -> BYTE6_W { #[must_use]
BYTE6_W { w: self } pub fn byte6(&mut self) -> Byte6W<Data2Cmb9Spec> {
Byte6W::new(self, 0)
} }
#[doc = "Writes raw bits to the register."] #[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)] #[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { #[must_use]
self.0.bits(bits); pub fn byte5(&mut self) -> Byte5W<Data2Cmb9Spec> {
self Byte5W::new(self, 8)
} }
} }
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb9](index.html) module"] #[doc = "CAN Frame Data Word 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`data2_cmb9::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`data2_cmb9::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct DATA2_CMB9_SPEC; pub struct Data2Cmb9Spec;
impl crate::RegisterSpec for DATA2_CMB9_SPEC { impl crate::RegisterSpec for Data2Cmb9Spec {
type Ux = u32; type Ux = u32;
} }
#[doc = "`read()` method returns [data2_cmb9::R](R) reader structure"] #[doc = "`read()` method returns [`data2_cmb9::R`](R) reader structure"]
impl crate::Readable for DATA2_CMB9_SPEC { impl crate::Readable for Data2Cmb9Spec {}
type Reader = R; #[doc = "`write(|w| ..)` method takes [`data2_cmb9::W`](W) writer structure"]
} impl crate::Writable for Data2Cmb9Spec {
#[doc = "`write(|w| ..)` method takes [data2_cmb9::W](W) writer structure"] type Safety = crate::Unsafe;
impl crate::Writable for DATA2_CMB9_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
type Writer = W; const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
} }
#[doc = "`reset()` method sets DATA2_CMB9 to value 0"] #[doc = "`reset()` method sets DATA2_CMB9 to value 0"]
impl crate::Resettable for DATA2_CMB9_SPEC { impl crate::Resettable for Data2Cmb9Spec {
#[inline(always)] const RESET_VALUE: u32 = 0;
fn reset_value() -> Self::Ux {
0
}
} }

Some files were not shown because too many files have changed in this diff Show More