rust/va416xx-rs
7
0
Fork 0
Code Issues Pull Requests Projects Releases 14 Wiki Activity

Init Commit
All checks were successful
Rust/va416xx-rs/pipeline/head This commit looks good
Details

Browse Source 
Monorepo for Rust support of VA416XX family of radiation hardened MCUs
This commit is contained in:
Robin Müller
2021-12-07 00:31:51 +01:00
committed by Robin Mueller
commit 5d1740efea
606 changed files with 74678 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
va416xx/.github/bors.toml vendored Normal file
View File

@ -0,0 +1,2 @@
status = ["ci"]
delete_merged_branches = true

20
va416xx/.github/workflows/changelog.yml vendored Normal file
View File

@ -0,0 +1,20 @@
on:
pull_request_target:
name: Changelog check
jobs:
changelog:
name: Changelog check
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Changelog updated
uses: Zomzog/changelog-checker@v1.2.0
with:
fileName: CHANGELOG.md
noChangelogLabel: no changelog
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

64
va416xx/.github/workflows/ci.yml vendored Normal file
View File

@ -0,0 +1,64 @@
on: [push]
name: build
jobs:
check:
name: Check
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: stable
target: thumbv7em-none-eabihf
override: true
- uses: actions-rs/cargo@v1
with:
use-cross: true
command: check
args: --target thumbv7em-none-eabihf
fmt:
name: Rustfmt
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: stable
override: true
- run: rustup component add rustfmt
- uses: actions-rs/cargo@v1
with:
command: fmt
args: --all -- --check
clippy:
name: Clippy
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: stable
target: thumbv7em-none-eabihf
override: true
- run: rustup component add clippy
- uses: actions-rs/cargo@v1
with:
use-cross: true
command: clippy
args: --target thumbv7em-none-eabihf -- -D warnings
ci:
if: ${{ success() }}
# all new jobs must be added to this list
needs: [check, fmt, clippy]
runs-on: ubuntu-latest
steps:
- name: CI succeeded
run: exit 0

2
va416xx/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
/target
Cargo.lock

21
va416xx/CHANGELOG.md Normal file
View File

@ -0,0 +1,21 @@
Change Log
=======
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](http://keepachangelog.com/)
and this project adheres to [Semantic Versioning](http://semver.org/).
## [unreleased]
## [v0.1.1]
- Clippy issue fixed by regenerating PAC with patched `svd2rust`:
https://github.com/rust-embedded/svd2rust/pull/558
## [v0.1.0]
- Clippy currently complains about unsound code which should still work.
Related issue: https://github.com/rust-embedded/svd2rust/issues/557
Clippy is disabled in CI/CD for now.
- Initial release

29
va416xx/Cargo.toml Normal file
View File

@ -0,0 +1,29 @@
[package]
name = "va416xx"
version = "0.1.1"
authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
edition = "2021"
description = "PAC for the Vorago VA416xx family of MCUs"
homepage = "https://egit.irs.uni-stuttgart.de/rust/va416xx"
repository = "https://egit.irs.uni-stuttgart.de/rust/va416xx"
license = "Apache-2.0"
keywords = ["no-std", "arm", "cortex-m", "vorago", "va416xx"]
categories = ["embedded", "no-std", "hardware-support"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
cortex-m = "0.7"
vcell = "0.1.3"
critical-section = { version = "1", optional = true }
[dependencies.cortex-m-rt]
optional = true
version = ">=0.6.15,<0.8"
[features]
rt = ["cortex-m-rt/device"]
[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--generate-link-to-definition"]

201
va416xx/LICENSE-APACHE Normal file
View File

@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

3
va416xx/NOTICE Normal file
View File

@ -0,0 +1,3 @@
Rust Peripheral Access Crate (PAC) crate for the Vorago VA416xx family of MCUs
This software contains code developed at the University of Stuttgart.

58
va416xx/README.md Normal file
View File

@ -0,0 +1,58 @@
[![Crates.io](https://img.shields.io/crates/v/va416xx)](https://crates.io/crates/va416xx)
[![docs.rs](https://img.shields.io/docsrs/va416xx)](https://docs.rs/va416xx)
# PAC for the Vorago VA416xx microcontroller family
This repository contains the Peripheral Access Crate (PAC) for
Voragos VA416xx series of Cortex-M4 based microcontrollers.
The crate was generated using [`svd2rust`](https://github.com/rust-embedded/svd2rust).
## Usage
To use this crate, add this to your `Cargo.toml`
```toml
[dependencies.va416xx]
version = "<MostRecentVersion>"
features = ["rt"]
```
The `rt` feature is optional and recommended. It brings in support for `cortex-m-rt`.
For full details on the autgenerated API, you can read the
[svd2rust documentation](https://docs.rs/svd2rust/latest/svd2rust/).
## Regenerating the PAC
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.

11
va416xx/automation/Dockerfile Normal file
View File

@ -0,0 +1,11 @@
# Run the following commands from root directory to build and run locally
# docker build -f automation/Dockerfile -t <NAME> .
# docker run -it <NAME>
FROM rust:latest
RUN apt-get update
RUN apt-get --yes upgrade
# tzdata is a dependency, won't install otherwise
ARG DEBIAN_FRONTEND=noninteractive
RUN rustup target add thumbv7em-none-eabihf && \
rustup component add rustfmt clippy

39
va416xx/automation/Jenkinsfile vendored Normal file
View File

@ -0,0 +1,39 @@
pipeline {
agent any
stages {
stage('Clippy') {
agent {
dockerfile {
dir 'automation'
reuseNode true
}
}
steps {
sh 'cargo clippy'
}
}
stage('Rustfmt') {
agent {
dockerfile {
dir 'automation'
reuseNode true
}
}
steps {
sh 'cargo fmt'
}
}
stage('Check') {
agent {
dockerfile {
dir 'automation'
reuseNode true
}
}
steps {
sh 'cargo check --target thumbv7em-none-eabihf'
}
}
}
}

17
va416xx/build.rs Normal file
View File

@ -0,0 +1,17 @@
#![doc = r" Builder file for Peripheral access crate generated by svd2rust tool"]
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::PathBuf;
fn main() {
if env::var_os("CARGO_FEATURE_RT").is_some() {
let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
File::create(out.join("device.x"))
.unwrap()
.write_all(include_bytes!("device.x"))
.unwrap();
println!("cargo:rustc-link-search={}", out.display());
println!("cargo:rerun-if-changed=device.x");
}
println!("cargo:rerun-if-changed=build.rs");
}

197
va416xx/device.x Normal file
View File

@ -0,0 +1,197 @@
PROVIDE(U0 = DefaultHandler);
PROVIDE(U1 = DefaultHandler);
PROVIDE(U2 = DefaultHandler);
PROVIDE(U3 = DefaultHandler);
PROVIDE(U4 = DefaultHandler);
PROVIDE(U5 = DefaultHandler);
PROVIDE(U6 = DefaultHandler);
PROVIDE(U7 = DefaultHandler);
PROVIDE(U8 = DefaultHandler);
PROVIDE(U9 = DefaultHandler);
PROVIDE(U10 = DefaultHandler);
PROVIDE(U11 = DefaultHandler);
PROVIDE(U12 = DefaultHandler);
PROVIDE(U13 = DefaultHandler);
PROVIDE(U14 = DefaultHandler);
PROVIDE(U15 = DefaultHandler);
PROVIDE(SPI0_TX = DefaultHandler);
PROVIDE(SPI0_RX = DefaultHandler);
PROVIDE(SPI1_TX = DefaultHandler);
PROVIDE(SPI1_RX = DefaultHandler);
PROVIDE(SPI2_TX = DefaultHandler);
PROVIDE(SPI2_RX = DefaultHandler);
PROVIDE(SPI3_TX = DefaultHandler);
PROVIDE(SPI3_RX = DefaultHandler);
PROVIDE(UART0_TX = DefaultHandler);
PROVIDE(UART0_RX = DefaultHandler);
PROVIDE(UART1_TX = DefaultHandler);
PROVIDE(UART1_RX = DefaultHandler);
PROVIDE(UART2_TX = DefaultHandler);
PROVIDE(UART2_RX = DefaultHandler);
PROVIDE(I2C0_MS = DefaultHandler);
PROVIDE(I2C0_SL = DefaultHandler);
PROVIDE(I2C1_MS = DefaultHandler);
PROVIDE(I2C1_SL = DefaultHandler);
PROVIDE(I2C2_MS = DefaultHandler);
PROVIDE(I2C2_SL = DefaultHandler);
PROVIDE(Ethernet = DefaultHandler);
PROVIDE(U37 = DefaultHandler);
PROVIDE(SpW = DefaultHandler);
PROVIDE(U39 = DefaultHandler);
PROVIDE(DAC0 = DefaultHandler);
PROVIDE(DAC1 = DefaultHandler);
PROVIDE(TRNG = DefaultHandler);
PROVIDE(DMA_ERROR = DefaultHandler);
PROVIDE(ADC = DefaultHandler);
PROVIDE(LoCLK = DefaultHandler);
PROVIDE(LVD = DefaultHandler);
PROVIDE(WATCHDOG = DefaultHandler);
PROVIDE(TIM0 = DefaultHandler);
PROVIDE(TIM1 = DefaultHandler);
PROVIDE(TIM2 = DefaultHandler);
PROVIDE(TIM3 = DefaultHandler);
PROVIDE(TIM4 = DefaultHandler);
PROVIDE(TIM5 = DefaultHandler);
PROVIDE(TIM6 = DefaultHandler);
PROVIDE(TIM7 = DefaultHandler);
PROVIDE(TIM8 = DefaultHandler);
PROVIDE(TIM9 = DefaultHandler);
PROVIDE(TIM10 = DefaultHandler);
PROVIDE(TIM11 = DefaultHandler);
PROVIDE(TIM12 = DefaultHandler);
PROVIDE(TIM13 = DefaultHandler);
PROVIDE(TIM14 = DefaultHandler);
PROVIDE(TIM15 = DefaultHandler);
PROVIDE(TIM16 = DefaultHandler);
PROVIDE(TIM17 = DefaultHandler);
PROVIDE(TIM18 = DefaultHandler);
PROVIDE(TIM19 = DefaultHandler);
PROVIDE(TIM20 = DefaultHandler);
PROVIDE(TIM21 = DefaultHandler);
PROVIDE(TIM22 = DefaultHandler);
PROVIDE(TIM23 = DefaultHandler);
PROVIDE(CAN0 = DefaultHandler);
PROVIDE(U73 = DefaultHandler);
PROVIDE(CAN1 = DefaultHandler);
PROVIDE(U75 = DefaultHandler);
PROVIDE(EDAC_MBE = DefaultHandler);
PROVIDE(EDAC_SBE = DefaultHandler);
PROVIDE(PORTA0 = DefaultHandler);
PROVIDE(PORTA1 = DefaultHandler);
PROVIDE(PORTA2 = DefaultHandler);
PROVIDE(PORTA3 = DefaultHandler);
PROVIDE(PORTA4 = DefaultHandler);
PROVIDE(PORTA5 = DefaultHandler);
PROVIDE(PORTA6 = DefaultHandler);
PROVIDE(PORTA7 = DefaultHandler);
PROVIDE(PORTA8 = DefaultHandler);
PROVIDE(PORTA9 = DefaultHandler);
PROVIDE(PORTA10 = DefaultHandler);
PROVIDE(PORTA11 = DefaultHandler);
PROVIDE(PORTA12 = DefaultHandler);
PROVIDE(PORTA13 = DefaultHandler);
PROVIDE(PORTA14 = DefaultHandler);
PROVIDE(PORTA15 = DefaultHandler);
PROVIDE(PORTB0 = DefaultHandler);
PROVIDE(PORTB1 = DefaultHandler);
PROVIDE(PORTB2 = DefaultHandler);
PROVIDE(PORTB3 = DefaultHandler);
PROVIDE(PORTB4 = DefaultHandler);
PROVIDE(PORTB5 = DefaultHandler);
PROVIDE(PORTB6 = DefaultHandler);
PROVIDE(PORTB7 = DefaultHandler);
PROVIDE(PORTB8 = DefaultHandler);
PROVIDE(PORTB9 = DefaultHandler);
PROVIDE(PORTB10 = DefaultHandler);
PROVIDE(PORTB11 = DefaultHandler);
PROVIDE(PORTB12 = DefaultHandler);
PROVIDE(PORTB13 = DefaultHandler);
PROVIDE(PORTB14 = DefaultHandler);
PROVIDE(PORTB15 = DefaultHandler);
PROVIDE(PORTC0 = DefaultHandler);
PROVIDE(PORTC1 = DefaultHandler);
PROVIDE(PORTC2 = DefaultHandler);
PROVIDE(PORTC3 = DefaultHandler);
PROVIDE(PORTC4 = DefaultHandler);
PROVIDE(PORTC5 = DefaultHandler);
PROVIDE(PORTC6 = DefaultHandler);
PROVIDE(PORTC7 = DefaultHandler);
PROVIDE(PORTC8 = DefaultHandler);
PROVIDE(PORTC9 = DefaultHandler);
PROVIDE(PORTC10 = DefaultHandler);
PROVIDE(PORTC11 = DefaultHandler);
PROVIDE(PORTC12 = DefaultHandler);
PROVIDE(PORTC13 = DefaultHandler);
PROVIDE(PORTC14 = DefaultHandler);
PROVIDE(PORTC15 = DefaultHandler);
PROVIDE(PORTD0 = DefaultHandler);
PROVIDE(PORTD1 = DefaultHandler);
PROVIDE(PORTD2 = DefaultHandler);
PROVIDE(PORTD3 = DefaultHandler);
PROVIDE(PORTD4 = DefaultHandler);
PROVIDE(PORTD5 = DefaultHandler);
PROVIDE(PORTD6 = DefaultHandler);
PROVIDE(PORTD7 = DefaultHandler);
PROVIDE(PORTD8 = DefaultHandler);
PROVIDE(PORTD9 = DefaultHandler);
PROVIDE(PORTD10 = DefaultHandler);
PROVIDE(PORTD11 = DefaultHandler);
PROVIDE(PORTD12 = DefaultHandler);
PROVIDE(PORTD13 = DefaultHandler);
PROVIDE(PORTD14 = DefaultHandler);
PROVIDE(PORTD15 = DefaultHandler);
PROVIDE(PORTE0 = DefaultHandler);
PROVIDE(PORTE1 = DefaultHandler);
PROVIDE(PORTE2 = DefaultHandler);
PROVIDE(PORTE3 = DefaultHandler);
PROVIDE(PORTE4 = DefaultHandler);
PROVIDE(PORTE5 = DefaultHandler);
PROVIDE(PORTE6 = DefaultHandler);
PROVIDE(PORTE7 = DefaultHandler);
PROVIDE(PORTE8 = DefaultHandler);
PROVIDE(PORTE9 = DefaultHandler);
PROVIDE(PORTE10 = DefaultHandler);
PROVIDE(PORTE11 = DefaultHandler);
PROVIDE(PORTE12 = DefaultHandler);
PROVIDE(PORTE13 = DefaultHandler);
PROVIDE(PORTE14 = DefaultHandler);
PROVIDE(PORTE15 = DefaultHandler);
PROVIDE(PORTF0 = DefaultHandler);
PROVIDE(PORTF1 = DefaultHandler);
PROVIDE(PORTF2 = DefaultHandler);
PROVIDE(PORTF3 = DefaultHandler);
PROVIDE(PORTF4 = DefaultHandler);
PROVIDE(PORTF5 = DefaultHandler);
PROVIDE(PORTF6 = DefaultHandler);
PROVIDE(PORTF7 = DefaultHandler);
PROVIDE(PORTF8 = DefaultHandler);
PROVIDE(PORTF9 = DefaultHandler);
PROVIDE(PORTF10 = DefaultHandler);
PROVIDE(PORTF11 = DefaultHandler);
PROVIDE(PORTF12 = DefaultHandler);
PROVIDE(PORTF13 = DefaultHandler);
PROVIDE(PORTF14 = DefaultHandler);
PROVIDE(PORTF15 = DefaultHandler);
PROVIDE(DMA_ACTIVE0 = DefaultHandler);
PROVIDE(DMA_ACTIVE1 = DefaultHandler);
PROVIDE(DMA_ACTIVE2 = DefaultHandler);
PROVIDE(DMA_ACTIVE3 = DefaultHandler);
PROVIDE(DMA_DONE0 = DefaultHandler);
PROVIDE(DMA_DONE1 = DefaultHandler);
PROVIDE(DMA_DONE2 = DefaultHandler);
PROVIDE(DMA_DONE3 = DefaultHandler);
PROVIDE(I2C0_MS_RX = DefaultHandler);
PROVIDE(I2C0_MS_TX = DefaultHandler);
PROVIDE(I2C0_SL_RX = DefaultHandler);
PROVIDE(I2C0_SL_TX = DefaultHandler);
PROVIDE(I2C1_MS_RX = DefaultHandler);
PROVIDE(I2C1_MS_TX = DefaultHandler);
PROVIDE(I2C1_SL_RX = DefaultHandler);
PROVIDE(I2C1_SL_TX = DefaultHandler);
PROVIDE(I2C2_MS_RX = DefaultHandler);
PROVIDE(I2C2_MS_TX = DefaultHandler);
PROVIDE(I2C2_SL_RX = DefaultHandler);
PROVIDE(I2C2_SL_TX = DefaultHandler);
PROVIDE(FPU = DefaultHandler);
PROVIDE(TXEV = DefaultHandler);

42
va416xx/gen-helper.sh Executable file
View File

@ -0,0 +1,42 @@
#!/bin/sh
# Use installed tool by default
svd2rust_bin="svd2rust"
# Automates the steps specified in https://docs.rs/svd2rust/0.19.0/svd2rust/
if [ -f svd2rust ]; then
# If the local directory contains svd2rust, use that version instead
svd2rust_bin="./svd2rust"
elif [ -f ../svd2rust ]; then
# Keeps the repository clean
svd2rust_bin="../svd2rust"
fi
if [ -x "$(${svd2rust_bin} --version)" ]; then
echo "No svd2rust found locally or installed." \
"Install it with cargo install svd2rust"
exit
fi
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} --reexport-interrupt -i svd/va416xx.svd.patched
result=$?
if [ $result -ne 0 ]; then
echo "svd2rust failed with code $result"
exit
fi
rm -rf src
form -i lib.rs -o src/ && rm lib.rs
cargo fmt

127
va416xx/src/adc.rs Normal file
View File

@ -0,0 +1,127 @@
#[repr(C)]
#[doc = "Register block"]
pub struct RegisterBlock {
ctrl: Ctrl,
fifo_data: FifoData,
status: Status,
irq_enb: IrqEnb,
irq_raw: IrqRaw,
irq_end: IrqEnd,
irq_clr: IrqClr,
rxfifoirqtrg: Rxfifoirqtrg,
fifo_clr: FifoClr,
_reserved9: [u8; 0x0fd8],
perid: Perid,
}
impl RegisterBlock {
#[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"]
pub mod ctrl;
#[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`]
module"]
#[doc(alias = "FIFO_DATA")]
pub type FifoData = crate::Reg<fifo_data::FifoDataSpec>;
#[doc = "FIFO data"]
pub mod fifo_data;
#[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`]
module"]
#[doc(alias = "STATUS")]
pub type Status = crate::Reg<status::StatusSpec>;
#[doc = "Status"]
pub mod status;
#[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`]
module"]
#[doc(alias = "IRQ_ENB")]
pub type IrqEnb = crate::Reg<irq_enb::IrqEnbSpec>;
#[doc = "Interrupt Enable"]
pub mod irq_enb;
#[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`]
module"]
#[doc(alias = "IRQ_RAW")]
pub type IrqRaw = crate::Reg<irq_raw::IrqRawSpec>;
#[doc = "Raw Interrupt Status"]
pub mod irq_raw;
#[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`]
module"]
#[doc(alias = "IRQ_END")]
pub type IrqEnd = crate::Reg<irq_end::IrqEndSpec>;
#[doc = "Enabled Interrupt Status"]
pub mod irq_end;
#[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`]
module"]
#[doc(alias = "IRQ_CLR")]
pub type IrqClr = crate::Reg<irq_clr::IrqClrSpec>;
#[doc = "Clear Interrupt"]
pub mod irq_clr;
#[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`]
module"]
#[doc(alias = "RXFIFOIRQTRG")]
pub type Rxfifoirqtrg = crate::Reg<rxfifoirqtrg::RxfifoirqtrgSpec>;
#[doc = "Receive FIFO Interrupt Trigger Value"]
pub mod rxfifoirqtrg;
#[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`]
module"]
#[doc(alias = "FIFO_CLR")]
pub type FifoClr = crate::Reg<fifo_clr::FifoClrSpec>;
#[doc = "FIFO Clear"]
pub mod fifo_clr;
#[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`]
module"]
#[doc(alias = "PERID")]
pub type Perid = crate::Reg<perid::PeridSpec>;
#[doc = "Peripheral ID Register"]
pub mod perid;

115
va416xx/src/adc/ctrl.rs Normal file
View File

@ -0,0 +1,115 @@
#[doc = "Register `CTRL` reader"]
pub type R = crate::R<CtrlSpec>;
#[doc = "Register `CTRL` writer"]
pub type W = crate::W<CtrlSpec>;
#[doc = "Field `CHAN_EN` reader - Enables the channel for data collection"]
pub type ChanEnR = crate::FieldReader<u16>;
#[doc = "Field `CHAN_EN` writer - Enables the channel for data collection"]
pub type ChanEnW<'a, REG> = crate::FieldWriter<'a, REG, 16, u16>;
#[doc = "Field `CHAN_TAG_EN` reader - Enables the channel tag to be saved with the ADC data"]
pub type ChanTagEnR = crate::BitReader;
#[doc = "Field `CHAN_TAG_EN` writer - Enables the channel tag to be saved with the ADC data"]
pub type ChanTagEnW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `SWEEP_EN` reader - ADC data acquisition for all enabled channel"]
pub type SweepEnR = crate::BitReader;
#[doc = "Field `SWEEP_EN` writer - ADC data acquisition for all enabled channel"]
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 {
#[doc = "Bits 0:15 - Enables the channel for data collection"]
#[inline(always)]
pub fn chan_en(&self) -> ChanEnR {
ChanEnR::new((self.bits & 0xffff) as u16)
}
#[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
#[inline(always)]
pub fn chan_tag_en(&self) -> ChanTagEnR {
ChanTagEnR::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
#[inline(always)]
pub fn sweep_en(&self) -> SweepEnR {
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 {
#[doc = "Bits 0:15 - Enables the channel for data collection"]
#[inline(always)]
#[must_use]
pub fn chan_en(&mut self) -> ChanEnW<CtrlSpec> {
ChanEnW::new(self, 0)
}
#[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
#[inline(always)]
#[must_use]
pub fn chan_tag_en(&mut self) -> ChanTagEnW<CtrlSpec> {
ChanTagEnW::new(self, 16)
}
#[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
#[inline(always)]
#[must_use]
pub fn sweep_en(&mut self) -> SweepEnW<CtrlSpec> {
SweepEnW::new(self, 17)
}
#[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
#[inline(always)]
#[must_use]
pub fn ext_trig_en(&mut self) -> ExtTrigEnW<CtrlSpec> {
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\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 CtrlSpec;
impl crate::RegisterSpec for CtrlSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`ctrl::R`](R) reader structure"]
impl crate::Readable for CtrlSpec {}
#[doc = "`write(|w| ..)` method takes [`ctrl::W`](W) writer structure"]
impl crate::Writable for CtrlSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CTRL to value 0"]
impl crate::Resettable for CtrlSpec {
const RESET_VALUE: u32 = 0;
}

31
va416xx/src/adc/fifo_clr.rs Normal file
View File

@ -0,0 +1,31 @@
#[doc = "Register `FIFO_CLR` reader"]
pub type R = crate::R<FifoClrSpec>;
#[doc = "Register `FIFO_CLR` writer"]
pub type W = crate::W<FifoClrSpec>;
#[doc = "Field `FIFO_CLR` writer - Clears the ADC FIFO. Always reads 0"]
pub type FifoClrW<'a, REG> = crate::BitWriter<'a, REG>;
impl W {
#[doc = "Bit 0 - Clears the ADC FIFO. Always reads 0"]
#[inline(always)]
#[must_use]
pub fn fifo_clr(&mut self) -> FifoClrW<FifoClrSpec> {
FifoClrW::new(self, 0)
}
}
#[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 FifoClrSpec;
impl crate::RegisterSpec for FifoClrSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`fifo_clr::R`](R) reader structure"]
impl crate::Readable for FifoClrSpec {}
#[doc = "`write(|w| ..)` method takes [`fifo_clr::W`](W) writer structure"]
impl crate::Writable for FifoClrSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets FIFO_CLR to value 0"]
impl crate::Resettable for FifoClrSpec {
const RESET_VALUE: u32 = 0;
}

29
va416xx/src/adc/fifo_data.rs Normal file
View File

@ -0,0 +1,29 @@
#[doc = "Register `FIFO_DATA` reader"]
pub type R = crate::R<FifoDataSpec>;
#[doc = "Field `ADC_DATA` reader - ADC acquisition data from the FIFO"]
pub type AdcDataR = crate::FieldReader<u16>;
#[doc = "Field `CHAN_TAG` reader - If enabled, this will include the number of the channel corresponding to the measurement"]
pub type ChanTagR = crate::FieldReader;
impl R {
#[doc = "Bits 0:11 - ADC acquisition data from the FIFO"]
#[inline(always)]
pub fn adc_data(&self) -> AdcDataR {
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\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 FifoDataSpec;
impl crate::RegisterSpec for FifoDataSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`fifo_data::R`](R) reader structure"]
impl crate::Readable for FifoDataSpec {}
#[doc = "`reset()` method sets FIFO_DATA to value 0"]
impl crate::Resettable for FifoDataSpec {
const RESET_VALUE: u32 = 0;
}

51
va416xx/src/adc/irq_clr.rs Normal file
View File

@ -0,0 +1,51 @@
#[doc = "Register `IRQ_CLR` writer"]
pub type W = crate::W<IrqClrSpec>;
#[doc = "Field `FIFO_OFLOW` writer - Clears the FIFO overflow interrupt status. Always reads 0"]
pub type FifoOflowW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FIFO_UFLOW` writer - Clears the FIFO underflow interrupt status. Always reads 0"]
pub type FifoUflowW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `ADC_DONE` writer - Clears the ADC done interrupt status. Always reads 0"]
pub type AdcDoneW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `TRIG_ERROR` writer - Clears the trigger error interrupt status. Always reads 0"]
pub type TrigErrorW<'a, REG> = crate::BitWriter<'a, REG>;
impl W {
#[doc = "Bit 0 - Clears the FIFO overflow interrupt status. Always reads 0"]
#[inline(always)]
#[must_use]
pub fn fifo_oflow(&mut self) -> FifoOflowW<IrqClrSpec> {
FifoOflowW::new(self, 0)
}
#[doc = "Bit 1 - Clears the FIFO underflow interrupt status. Always reads 0"]
#[inline(always)]
#[must_use]
pub fn fifo_uflow(&mut self) -> FifoUflowW<IrqClrSpec> {
FifoUflowW::new(self, 1)
}
#[doc = "Bit 2 - Clears the ADC done interrupt status. Always reads 0"]
#[inline(always)]
#[must_use]
pub fn adc_done(&mut self) -> AdcDoneW<IrqClrSpec> {
AdcDoneW::new(self, 2)
}
#[doc = "Bit 3 - Clears the trigger error interrupt status. Always reads 0"]
#[inline(always)]
#[must_use]
pub fn trig_error(&mut self) -> TrigErrorW<IrqClrSpec> {
TrigErrorW::new(self, 3)
}
}
#[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 IrqClrSpec;
impl crate::RegisterSpec for IrqClrSpec {
type Ux = u32;
}
#[doc = "`write(|w| ..)` method takes [`irq_clr::W`](W) writer structure"]
impl crate::Writable for IrqClrSpec {
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"]
impl crate::Resettable for IrqClrSpec {
const RESET_VALUE: u32 = 0;
}

130
va416xx/src/adc/irq_enb.rs Normal file
View File

@ -0,0 +1,130 @@
#[doc = "Register `IRQ_ENB` reader"]
pub type R = crate::R<IrqEnbSpec>;
#[doc = "Register `IRQ_ENB` writer"]
pub type W = crate::W<IrqEnbSpec>;
#[doc = "Field `FIFO_EMPTY` reader - Enables the interrupt for FIFO empty"]
pub type FifoEmptyR = crate::BitReader;
#[doc = "Field `FIFO_EMPTY` writer - Enables the interrupt for FIFO empty"]
pub type FifoEmptyW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FIFO_FULL` reader - Enables the interrupt for FIFO full"]
pub type FifoFullR = crate::BitReader;
#[doc = "Field `FIFO_FULL` writer - Enables the interrupt for FIFO full"]
pub type FifoFullW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FIFO_OFLOW` reader - Enables the interrupt for a FIFO overflow"]
pub type FifoOflowR = crate::BitReader;
#[doc = "Field `FIFO_OFLOW` writer - Enables the interrupt for a FIFO overflow"]
pub type FifoOflowW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FIFO_UFLOW` reader - Enables the interrupt for a FIFO underflow"]
pub type FifoUflowR = crate::BitReader;
#[doc = "Field `FIFO_UFLOW` writer - Enables the interrupt for a FIFO underflow"]
pub type FifoUflowW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `ADC_DONE` reader - Enables the interrupt for an ADC data acquisition completion"]
pub type AdcDoneR = crate::BitReader;
#[doc = "Field `ADC_DONE` writer - Enables the interrupt for an ADC data acquisition completion"]
pub type AdcDoneW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `TRIG_ERROR` reader - Enables the interrupt for a trigger error"]
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 {
#[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
#[inline(always)]
pub fn fifo_empty(&self) -> FifoEmptyR {
FifoEmptyR::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - Enables the interrupt for FIFO full"]
#[inline(always)]
pub fn fifo_full(&self) -> FifoFullR {
FifoFullR::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
#[inline(always)]
pub fn fifo_oflow(&self) -> FifoOflowR {
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 {
#[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
#[inline(always)]
#[must_use]
pub fn fifo_empty(&mut self) -> FifoEmptyW<IrqEnbSpec> {
FifoEmptyW::new(self, 0)
}
#[doc = "Bit 1 - Enables the interrupt for FIFO full"]
#[inline(always)]
#[must_use]
pub fn fifo_full(&mut self) -> FifoFullW<IrqEnbSpec> {
FifoFullW::new(self, 1)
}
#[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
#[inline(always)]
#[must_use]
pub fn fifo_oflow(&mut self) -> FifoOflowW<IrqEnbSpec> {
FifoOflowW::new(self, 2)
}
#[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
#[inline(always)]
#[must_use]
pub fn fifo_uflow(&mut self) -> FifoUflowW<IrqEnbSpec> {
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\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 IrqEnbSpec;
impl crate::RegisterSpec for IrqEnbSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`irq_enb::R`](R) reader structure"]
impl crate::Readable for IrqEnbSpec {}
#[doc = "`write(|w| ..)` method takes [`irq_enb::W`](W) writer structure"]
impl crate::Writable for IrqEnbSpec {
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_ENB to value 0"]
impl crate::Resettable for IrqEnbSpec {
const RESET_VALUE: u32 = 0;
}

64
va416xx/src/adc/irq_end.rs Normal file
View File

@ -0,0 +1,64 @@
#[doc = "Register `IRQ_END` reader"]
pub type R = crate::R<IrqEndSpec>;
#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty and the interrupt is enabled"]
pub type FifoEmptyR = crate::BitReader;
#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full and the interrupt is enabled"]
pub type FifoFullR = crate::BitReader;
#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred and the interrupt is enabled"]
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;
#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done and the interrupt is enabled"]
pub type AdcDoneR = crate::BitReader;
#[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 type TrigErrorR = crate::BitReader;
#[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 {
#[doc = "Bit 0 - Indicates the FIFO is empty and the interrupt is enabled"]
#[inline(always)]
pub fn fifo_empty(&self) -> FifoEmptyR {
FifoEmptyR::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - Indicates the FIFO is full and the interrupt is enabled"]
#[inline(always)]
pub fn fifo_full(&self) -> FifoFullR {
FifoFullR::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - Indicates a FIFO overflow occurred and the interrupt is enabled"]
#[inline(always)]
pub fn fifo_oflow(&self) -> FifoOflowR {
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\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 IrqEndSpec;
impl crate::RegisterSpec for IrqEndSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`irq_end::R`](R) reader structure"]
impl crate::Readable for IrqEndSpec {}
#[doc = "`reset()` method sets IRQ_END to value 0"]
impl crate::Resettable for IrqEndSpec {
const RESET_VALUE: u32 = 0;
}

64
va416xx/src/adc/irq_raw.rs Normal file
View File

@ -0,0 +1,64 @@
#[doc = "Register `IRQ_RAW` reader"]
pub type R = crate::R<IrqRawSpec>;
#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty"]
pub type FifoEmptyR = crate::BitReader;
#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full"]
pub type FifoFullR = crate::BitReader;
#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
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;
#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done"]
pub type AdcDoneR = crate::BitReader;
#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
pub type TrigErrorR = crate::BitReader;
#[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 {
#[doc = "Bit 0 - Indicates the FIFO is empty"]
#[inline(always)]
pub fn fifo_empty(&self) -> FifoEmptyR {
FifoEmptyR::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - Indicates the FIFO is full"]
#[inline(always)]
pub fn fifo_full(&self) -> FifoFullR {
FifoFullR::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
#[inline(always)]
pub fn fifo_oflow(&self) -> FifoOflowR {
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\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 IrqRawSpec;
impl crate::RegisterSpec for IrqRawSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`irq_raw::R`](R) reader structure"]
impl crate::Readable for IrqRawSpec {}
#[doc = "`reset()` method sets IRQ_RAW to value 0x01"]
impl crate::Resettable for IrqRawSpec {
const RESET_VALUE: u32 = 0x01;
}

18
va416xx/src/adc/perid.rs Normal file
View File

@ -0,0 +1,18 @@
#[doc = "Register `PERID` reader"]
pub type R = crate::R<PeridSpec>;
impl core::fmt::Debug for R {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "{}", self.bits())
}
}
#[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)."]
pub struct PeridSpec;
impl crate::RegisterSpec for PeridSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`perid::R`](R) reader structure"]
impl crate::Readable for PeridSpec {}
#[doc = "`reset()` method sets PERID to value 0x0019_07e9"]
impl crate::Resettable for PeridSpec {
const RESET_VALUE: u32 = 0x0019_07e9;
}

40
va416xx/src/adc/rxfifoirqtrg.rs Normal file
View File

@ -0,0 +1,40 @@
#[doc = "Register `RXFIFOIRQTRG` reader"]
pub type R = crate::R<RxfifoirqtrgSpec>;
#[doc = "Register `RXFIFOIRQTRG` writer"]
pub type W = crate::W<RxfifoirqtrgSpec>;
#[doc = "Field `LEVEL` reader - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
pub type LevelR = crate::FieldReader;
#[doc = "Field `LEVEL` writer - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
pub type LevelW<'a, REG> = crate::FieldWriter<'a, REG, 5>;
impl R {
#[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
#[inline(always)]
pub fn level(&self) -> LevelR {
LevelR::new((self.bits & 0x1f) as u8)
}
}
impl W {
#[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
#[inline(always)]
#[must_use]
pub fn level(&mut self) -> LevelW<RxfifoirqtrgSpec> {
LevelW::new(self, 0)
}
}
#[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 RxfifoirqtrgSpec;
impl crate::RegisterSpec for RxfifoirqtrgSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`rxfifoirqtrg::R`](R) reader structure"]
impl crate::Readable for RxfifoirqtrgSpec {}
#[doc = "`write(|w| ..)` method takes [`rxfifoirqtrg::W`](W) writer structure"]
impl crate::Writable for RxfifoirqtrgSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets RXFIFOIRQTRG to value 0x10"]
impl crate::Resettable for RxfifoirqtrgSpec {
const RESET_VALUE: u32 = 0x10;
}

29
va416xx/src/adc/status.rs Normal file
View File

@ -0,0 +1,29 @@
#[doc = "Register `STATUS` reader"]
pub type R = crate::R<StatusSpec>;
#[doc = "Field `FIFO_ENTRY_CNT` reader - Indicates the number of entries in the FIFO"]
pub type FifoEntryCntR = crate::FieldReader;
#[doc = "Field `ADC_BUSY` reader - Indicates an ADC data acquisition is in process"]
pub type AdcBusyR = crate::BitReader;
impl R {
#[doc = "Bits 0:5 - Indicates the number of entries in the FIFO"]
#[inline(always)]
pub fn fifo_entry_cnt(&self) -> FifoEntryCntR {
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\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 StatusSpec;
impl crate::RegisterSpec for StatusSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`status::R`](R) reader structure"]
impl crate::Readable for StatusSpec {}
#[doc = "`reset()` method sets STATUS to value 0"]
impl crate::Resettable for StatusSpec {
const RESET_VALUE: u32 = 0;
}

1710
va416xx/src/can0.rs Normal file
View File

File diff suppressed because it is too large Load Diff

105
va416xx/src/can0/bmskb.rs Normal file
View File

@ -0,0 +1,105 @@
#[doc = "Register `BMSKB` reader"]
pub type R = crate::R<BmskbSpec>;
#[doc = "Register `BMSKB` writer"]
pub type W = crate::W<BmskbSpec>;
#[doc = "Field `BM0` reader - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
pub type Bm0R = crate::FieldReader;
#[doc = "Field `BM0` writer - BM\\[17:15\\]
- Unused in standard, ID\\[17:15\\]
in extended"]
pub type Bm0W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
#[doc = "Field `IDE` reader - Identifier Extension Bit"]
pub type IdeR = crate::BitReader;
#[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"]
pub type RtrR = crate::BitReader;
#[doc = "Field `RTR` writer - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
pub type RtrW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `BM1` reader - BM\\[28:18\\]
- ID\\[10:0\\]
in standard, ID\\[28:18\\]
in extended"]
pub type Bm1R = crate::FieldReader<u16>;
#[doc = "Field `BM1` writer - BM\\[28:18\\]
- ID\\[10:0\\]
in standard, ID\\[28:18\\]
in extended"]
pub type Bm1W<'a, REG> = crate::FieldWriter<'a, REG, 11, u16>;
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\\]
- ID\\[10:0\\]
in standard, ID\\[28:18\\]
in extended"]
#[inline(always)]
pub fn bm1(&self) -> Bm1R {
Bm1R::new(((self.bits >> 5) & 0x07ff) as u16)
}
}
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\\]
- ID\\[10:0\\]
in standard, ID\\[28:18\\]
in extended"]
#[inline(always)]
#[must_use]
pub fn bm1(&mut self) -> Bm1W<BmskbSpec> {
Bm1W::new(self, 5)
}
}
#[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 BmskbSpec;
impl crate::RegisterSpec for BmskbSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`bmskb::R`](R) reader structure"]
impl crate::Readable for BmskbSpec {}
#[doc = "`write(|w| ..)` method takes [`bmskb::W`](W) writer structure"]
impl crate::Writable for BmskbSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets BMSKB to value 0"]
impl crate::Resettable for BmskbSpec {
const RESET_VALUE: u32 = 0;
}

63
va416xx/src/can0/bmskx.rs Normal file
View File

@ -0,0 +1,63 @@
#[doc = "Register `BMSKX` reader"]
pub type R = crate::R<BmskxSpec>;
#[doc = "Register `BMSKX` writer"]
pub type W = crate::W<BmskxSpec>;
#[doc = "Field `XRTR` reader - Extended Remote transmission Request Bit"]
pub type XrtrR = crate::BitReader;
#[doc = "Field `XRTR` writer - Extended Remote transmission Request Bit"]
pub type XrtrW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `BM` reader - BM\\[14:0\\]
used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"]
pub type BmR = crate::FieldReader<u16>;
#[doc = "Field `BM` writer - BM\\[14:0\\]
used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"]
pub type BmW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
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\\]
used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"]
#[inline(always)]
pub fn bm(&self) -> BmR {
BmR::new(((self.bits >> 1) & 0x7fff) as u16)
}
}
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\\]
used when an extended frame is received. ID\\[14:0\\]
in extended, unused standard"]
#[inline(always)]
#[must_use]
pub fn bm(&mut self) -> BmW<BmskxSpec> {
BmW::new(self, 1)
}
}
#[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 BmskxSpec;
impl crate::RegisterSpec for BmskxSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`bmskx::R`](R) reader structure"]
impl crate::Readable for BmskxSpec {}
#[doc = "`write(|w| ..)` method takes [`bmskx::W`](W) writer structure"]
impl crate::Writable for BmskxSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets BMSKX to value 0"]
impl crate::Resettable for BmskxSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/canec.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `CANEC` reader"]
pub type R = crate::R<CanecSpec>;
#[doc = "Register `CANEC` writer"]
pub type W = crate::W<CanecSpec>;
#[doc = "Field `TEC` reader - Transmit Error Counter"]
pub type TecR = crate::FieldReader;
#[doc = "Field `TEC` writer - Transmit Error Counter"]
pub type TecW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `REC` reader - Receive Error Counter"]
pub type RecR = crate::FieldReader;
#[doc = "Field `REC` writer - Receive Error Counter"]
pub type RecW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Transmit Error Counter"]
#[inline(always)]
pub fn tec(&self) -> TecR {
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 {
#[doc = "Bits 0:7 - Transmit Error Counter"]
#[inline(always)]
#[must_use]
pub fn tec(&mut self) -> TecW<CanecSpec> {
TecW::new(self, 0)
}
#[doc = "Bits 8:15 - Receive Error Counter"]
#[inline(always)]
#[must_use]
pub fn rec(&mut self) -> RecW<CanecSpec> {
RecW::new(self, 8)
}
}
#[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 CanecSpec;
impl crate::RegisterSpec for CanecSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`canec::R`](R) reader structure"]
impl crate::Readable for CanecSpec {}
#[doc = "`write(|w| ..)` method takes [`canec::W`](W) writer structure"]
impl crate::Writable for CanecSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CANEC to value 0"]
impl crate::Resettable for CanecSpec {
const RESET_VALUE: u32 = 0;
}

130
va416xx/src/can0/cediag.rs Normal file
View File

@ -0,0 +1,130 @@
#[doc = "Register `CEDIAG` reader"]
pub type R = crate::R<CediagSpec>;
#[doc = "Register `CEDIAG` writer"]
pub type W = crate::W<CediagSpec>;
#[doc = "Field `EFID` reader - Error Field Identifier"]
pub type EfidR = crate::FieldReader;
#[doc = "Field `EFID` writer - Error Field Identifier"]
pub type EfidW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `EBID` reader - Error Bit Identifier"]
pub type EbidR = crate::FieldReader;
#[doc = "Field `EBID` writer - Error Bit Identifier"]
pub type EbidW<'a, REG> = crate::FieldWriter<'a, REG, 6>;
#[doc = "Field `TXE` reader - Transmit Error"]
pub type TxeR = crate::BitReader;
#[doc = "Field `TXE` writer - Transmit Error"]
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 {
#[doc = "Bits 0:3 - Error Field Identifier"]
#[inline(always)]
pub fn efid(&self) -> EfidR {
EfidR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:9 - Error Bit Identifier"]
#[inline(always)]
pub fn ebid(&self) -> EbidR {
EbidR::new(((self.bits >> 4) & 0x3f) as u8)
}
#[doc = "Bit 10 - Transmit Error"]
#[inline(always)]
pub fn txe(&self) -> TxeR {
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 {
#[doc = "Bits 0:3 - Error Field Identifier"]
#[inline(always)]
#[must_use]
pub fn efid(&mut self) -> EfidW<CediagSpec> {
EfidW::new(self, 0)
}
#[doc = "Bits 4:9 - Error Bit Identifier"]
#[inline(always)]
#[must_use]
pub fn ebid(&mut self) -> EbidW<CediagSpec> {
EbidW::new(self, 4)
}
#[doc = "Bit 10 - Transmit Error"]
#[inline(always)]
#[must_use]
pub fn txe(&mut self) -> TxeW<CediagSpec> {
TxeW::new(self, 10)
}
#[doc = "Bit 11 - Stuff Error"]
#[inline(always)]
#[must_use]
pub fn stuff(&mut self) -> StuffW<CediagSpec> {
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\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 CediagSpec;
impl crate::RegisterSpec for CediagSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cediag::R`](R) reader structure"]
impl crate::Readable for CediagSpec {}
#[doc = "`write(|w| ..)` method takes [`cediag::W`](W) writer structure"]
impl crate::Writable for CediagSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CEDIAG to value 0"]
impl crate::Resettable for CediagSpec {
const RESET_VALUE: u32 = 0;
}

205
va416xx/src/can0/cgcr.rs Normal file
View File

@ -0,0 +1,205 @@
#[doc = "Register `CGCR` reader"]
pub type R = crate::R<CgcrSpec>;
#[doc = "Register `CGCR` writer"]
pub type W = crate::W<CgcrSpec>;
#[doc = "Field `CANEN` reader - CAN Enable"]
pub type CanenR = crate::BitReader;
#[doc = "Field `CANEN` writer - CAN Enable"]
pub type CanenW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `CRX` reader - RW,Control Receive"]
pub type CrxR = crate::BitReader;
#[doc = "Field `CRX` writer - RW,Control Receive"]
pub type CrxW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `CTX` reader - RW,Control Transmit"]
pub type CtxR = crate::BitReader;
#[doc = "Field `CTX` writer - RW,Control Transmit"]
pub type CtxW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `BUFFLOCK` reader - Buffer Lock"]
pub type BufflockR = crate::BitReader;
#[doc = "Field `BUFFLOCK` writer - Buffer Lock"]
pub type BufflockW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `TSTPEN` reader - Time Sync Enable"]
pub type TstpenR = crate::BitReader;
#[doc = "Field `TSTPEN` writer - Time Sync Enable"]
pub type TstpenW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `DDIR` reader - Data Direction"]
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 {
#[doc = "Bit 0 - CAN Enable"]
#[inline(always)]
pub fn canen(&self) -> CanenR {
CanenR::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - RW,Control Receive"]
#[inline(always)]
pub fn crx(&self) -> CrxR {
CrxR::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - RW,Control Transmit"]
#[inline(always)]
pub fn ctx(&self) -> CtxR {
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 {
#[doc = "Bit 0 - CAN Enable"]
#[inline(always)]
#[must_use]
pub fn canen(&mut self) -> CanenW<CgcrSpec> {
CanenW::new(self, 0)
}
#[doc = "Bit 1 - RW,Control Receive"]
#[inline(always)]
#[must_use]
pub fn crx(&mut self) -> CrxW<CgcrSpec> {
CrxW::new(self, 1)
}
#[doc = "Bit 2 - RW,Control Transmit"]
#[inline(always)]
#[must_use]
pub fn ctx(&mut self) -> CtxW<CgcrSpec> {
CtxW::new(self, 2)
}
#[doc = "Bit 3 - Buffer Lock"]
#[inline(always)]
#[must_use]
pub fn bufflock(&mut self) -> BufflockW<CgcrSpec> {
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\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 CgcrSpec;
impl crate::RegisterSpec for CgcrSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cgcr::R`](R) reader structure"]
impl crate::Readable for CgcrSpec {}
#[doc = "`write(|w| ..)` method takes [`cgcr::W`](W) writer structure"]
impl crate::Writable for CgcrSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CGCR to value 0"]
impl crate::Resettable for CgcrSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/cicen.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `CICEN` reader"]
pub type R = crate::R<CicenSpec>;
#[doc = "Register `CICEN` writer"]
pub type W = crate::W<CicenSpec>;
#[doc = "Field `ICEN` reader - Buffer Interrupt Code Enable\\[14:0\\]"]
pub type IcenR = crate::FieldReader<u16>;
#[doc = "Field `ICEN` writer - Buffer Interrupt Code Enable\\[14:0\\]"]
pub type IcenW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
#[doc = "Field `EICEN` reader - Error Interrupt Code Enable"]
pub type EicenR = crate::BitReader;
#[doc = "Field `EICEN` writer - Error Interrupt Code Enable"]
pub type EicenW<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
#[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
#[inline(always)]
pub fn icen(&self) -> IcenR {
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 {
#[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
#[inline(always)]
#[must_use]
pub fn icen(&mut self) -> IcenW<CicenSpec> {
IcenW::new(self, 0)
}
#[doc = "Bit 15 - Error Interrupt Code Enable"]
#[inline(always)]
#[must_use]
pub fn eicen(&mut self) -> EicenW<CicenSpec> {
EicenW::new(self, 15)
}
}
#[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 CicenSpec;
impl crate::RegisterSpec for CicenSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cicen::R`](R) reader structure"]
impl crate::Readable for CicenSpec {}
#[doc = "`write(|w| ..)` method takes [`cicen::W`](W) writer structure"]
impl crate::Writable for CicenSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CICEN to value 0"]
impl crate::Resettable for CicenSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/ciclr.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `CICLR` reader"]
pub type R = crate::R<CiclrSpec>;
#[doc = "Register `CICLR` writer"]
pub type W = crate::W<CiclrSpec>;
#[doc = "Field `ICLR` reader - Buffer Interrupt Clear\\[14:0\\]"]
pub type IclrR = crate::FieldReader<u16>;
#[doc = "Field `ICLR` writer - Buffer Interrupt Clear\\[14:0\\]"]
pub type IclrW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
#[doc = "Field `EICLR` reader - Error Interrupt Clear"]
pub type EiclrR = crate::BitReader;
#[doc = "Field `EICLR` writer - Error Interrupt Clear"]
pub type EiclrW<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
#[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
#[inline(always)]
pub fn iclr(&self) -> IclrR {
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 {
#[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
#[inline(always)]
#[must_use]
pub fn iclr(&mut self) -> IclrW<CiclrSpec> {
IclrW::new(self, 0)
}
#[doc = "Bit 15 - Error Interrupt Clear"]
#[inline(always)]
#[must_use]
pub fn eiclr(&mut self) -> EiclrW<CiclrSpec> {
EiclrW::new(self, 15)
}
}
#[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 CiclrSpec;
impl crate::RegisterSpec for CiclrSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`ciclr::R`](R) reader structure"]
impl crate::Readable for CiclrSpec {}
#[doc = "`write(|w| ..)` method takes [`ciclr::W`](W) writer structure"]
impl crate::Writable for CiclrSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CICLR to value 0"]
impl crate::Resettable for CiclrSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/cien.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `CIEN` reader"]
pub type R = crate::R<CienSpec>;
#[doc = "Register `CIEN` writer"]
pub type W = crate::W<CienSpec>;
#[doc = "Field `IEN` reader - Buffer Interrupt Enable\\[14:0\\]"]
pub type IenR = crate::FieldReader<u16>;
#[doc = "Field `IEN` writer - Buffer Interrupt Enable\\[14:0\\]"]
pub type IenW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
#[doc = "Field `EIEN` reader - Error Interrupt Enable"]
pub type EienR = crate::BitReader;
#[doc = "Field `EIEN` writer - Error Interrupt Enable"]
pub type EienW<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
#[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
#[inline(always)]
pub fn ien(&self) -> IenR {
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 {
#[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
#[inline(always)]
#[must_use]
pub fn ien(&mut self) -> IenW<CienSpec> {
IenW::new(self, 0)
}
#[doc = "Bit 15 - Error Interrupt Enable"]
#[inline(always)]
#[must_use]
pub fn eien(&mut self) -> EienW<CienSpec> {
EienW::new(self, 15)
}
}
#[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 CienSpec;
impl crate::RegisterSpec for CienSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cien::R`](R) reader structure"]
impl crate::Readable for CienSpec {}
#[doc = "`write(|w| ..)` method takes [`cien::W`](W) writer structure"]
impl crate::Writable for CienSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CIEN to value 0"]
impl crate::Resettable for CienSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/cipnd.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `CIPND` reader"]
pub type R = crate::R<CipndSpec>;
#[doc = "Register `CIPND` writer"]
pub type W = crate::W<CipndSpec>;
#[doc = "Field `IPND` reader - Buffer Interrupt Pending\\[14:0\\]"]
pub type IpndR = crate::FieldReader<u16>;
#[doc = "Field `IPND` writer - Buffer Interrupt Pending\\[14:0\\]"]
pub type IpndW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
#[doc = "Field `EIPND` reader - Error Interrupt Pending"]
pub type EipndR = crate::BitReader;
#[doc = "Field `EIPND` writer - Error Interrupt Pending"]
pub type EipndW<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
#[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
#[inline(always)]
pub fn ipnd(&self) -> IpndR {
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 {
#[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
#[inline(always)]
#[must_use]
pub fn ipnd(&mut self) -> IpndW<CipndSpec> {
IpndW::new(self, 0)
}
#[doc = "Bit 15 - Error Interrupt Pending"]
#[inline(always)]
#[must_use]
pub fn eipnd(&mut self) -> EipndW<CipndSpec> {
EipndW::new(self, 15)
}
}
#[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 CipndSpec;
impl crate::RegisterSpec for CipndSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cipnd::R`](R) reader structure"]
impl crate::Readable for CipndSpec {}
#[doc = "`write(|w| ..)` method takes [`cipnd::W`](W) writer structure"]
impl crate::Writable for CipndSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CIPND to value 0"]
impl crate::Resettable for CipndSpec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb0.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB0` reader"]
pub type R = crate::R<CnstatCmb0Spec>;
#[doc = "Register `CNSTAT_CMB0` writer"]
pub type W = crate::W<CnstatCmb0Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb0Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb0Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb0Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb0Spec;
impl crate::RegisterSpec for CnstatCmb0Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb0::R`](R) reader structure"]
impl crate::Readable for CnstatCmb0Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb0::W`](W) writer structure"]
impl crate::Writable for CnstatCmb0Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB0 to value 0"]
impl crate::Resettable for CnstatCmb0Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb1.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB1` reader"]
pub type R = crate::R<CnstatCmb1Spec>;
#[doc = "Register `CNSTAT_CMB1` writer"]
pub type W = crate::W<CnstatCmb1Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb1Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb1Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb1Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb1Spec;
impl crate::RegisterSpec for CnstatCmb1Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb1::R`](R) reader structure"]
impl crate::Readable for CnstatCmb1Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb1::W`](W) writer structure"]
impl crate::Writable for CnstatCmb1Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB1 to value 0"]
impl crate::Resettable for CnstatCmb1Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb10.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB10` reader"]
pub type R = crate::R<CnstatCmb10Spec>;
#[doc = "Register `CNSTAT_CMB10` writer"]
pub type W = crate::W<CnstatCmb10Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb10Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb10Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb10Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb10Spec;
impl crate::RegisterSpec for CnstatCmb10Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb10::R`](R) reader structure"]
impl crate::Readable for CnstatCmb10Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb10::W`](W) writer structure"]
impl crate::Writable for CnstatCmb10Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB10 to value 0"]
impl crate::Resettable for CnstatCmb10Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb11.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB11` reader"]
pub type R = crate::R<CnstatCmb11Spec>;
#[doc = "Register `CNSTAT_CMB11` writer"]
pub type W = crate::W<CnstatCmb11Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb11Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb11Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb11Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb11Spec;
impl crate::RegisterSpec for CnstatCmb11Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb11::R`](R) reader structure"]
impl crate::Readable for CnstatCmb11Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb11::W`](W) writer structure"]
impl crate::Writable for CnstatCmb11Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB11 to value 0"]
impl crate::Resettable for CnstatCmb11Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb12.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB12` reader"]
pub type R = crate::R<CnstatCmb12Spec>;
#[doc = "Register `CNSTAT_CMB12` writer"]
pub type W = crate::W<CnstatCmb12Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb12Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb12Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb12Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb12Spec;
impl crate::RegisterSpec for CnstatCmb12Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb12::R`](R) reader structure"]
impl crate::Readable for CnstatCmb12Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb12::W`](W) writer structure"]
impl crate::Writable for CnstatCmb12Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB12 to value 0"]
impl crate::Resettable for CnstatCmb12Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb13.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB13` reader"]
pub type R = crate::R<CnstatCmb13Spec>;
#[doc = "Register `CNSTAT_CMB13` writer"]
pub type W = crate::W<CnstatCmb13Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb13Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb13Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb13Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb13Spec;
impl crate::RegisterSpec for CnstatCmb13Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb13::R`](R) reader structure"]
impl crate::Readable for CnstatCmb13Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb13::W`](W) writer structure"]
impl crate::Writable for CnstatCmb13Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB13 to value 0"]
impl crate::Resettable for CnstatCmb13Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb14.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB14` reader"]
pub type R = crate::R<CnstatCmb14Spec>;
#[doc = "Register `CNSTAT_CMB14` writer"]
pub type W = crate::W<CnstatCmb14Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb14Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb14Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb14Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb14Spec;
impl crate::RegisterSpec for CnstatCmb14Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb14::R`](R) reader structure"]
impl crate::Readable for CnstatCmb14Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb14::W`](W) writer structure"]
impl crate::Writable for CnstatCmb14Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB14 to value 0"]
impl crate::Resettable for CnstatCmb14Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb2.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB2` reader"]
pub type R = crate::R<CnstatCmb2Spec>;
#[doc = "Register `CNSTAT_CMB2` writer"]
pub type W = crate::W<CnstatCmb2Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb2Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb2Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb2Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb2Spec;
impl crate::RegisterSpec for CnstatCmb2Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb2::R`](R) reader structure"]
impl crate::Readable for CnstatCmb2Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb2::W`](W) writer structure"]
impl crate::Writable for CnstatCmb2Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB2 to value 0"]
impl crate::Resettable for CnstatCmb2Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb3.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB3` reader"]
pub type R = crate::R<CnstatCmb3Spec>;
#[doc = "Register `CNSTAT_CMB3` writer"]
pub type W = crate::W<CnstatCmb3Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb3Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb3Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb3Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb3Spec;
impl crate::RegisterSpec for CnstatCmb3Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb3::R`](R) reader structure"]
impl crate::Readable for CnstatCmb3Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb3::W`](W) writer structure"]
impl crate::Writable for CnstatCmb3Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB3 to value 0"]
impl crate::Resettable for CnstatCmb3Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb4.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB4` reader"]
pub type R = crate::R<CnstatCmb4Spec>;
#[doc = "Register `CNSTAT_CMB4` writer"]
pub type W = crate::W<CnstatCmb4Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb4Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb4Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb4Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb4Spec;
impl crate::RegisterSpec for CnstatCmb4Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb4::R`](R) reader structure"]
impl crate::Readable for CnstatCmb4Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb4::W`](W) writer structure"]
impl crate::Writable for CnstatCmb4Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB4 to value 0"]
impl crate::Resettable for CnstatCmb4Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb5.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB5` reader"]
pub type R = crate::R<CnstatCmb5Spec>;
#[doc = "Register `CNSTAT_CMB5` writer"]
pub type W = crate::W<CnstatCmb5Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb5Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb5Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb5Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb5Spec;
impl crate::RegisterSpec for CnstatCmb5Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb5::R`](R) reader structure"]
impl crate::Readable for CnstatCmb5Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb5::W`](W) writer structure"]
impl crate::Writable for CnstatCmb5Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB5 to value 0"]
impl crate::Resettable for CnstatCmb5Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb6.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB6` reader"]
pub type R = crate::R<CnstatCmb6Spec>;
#[doc = "Register `CNSTAT_CMB6` writer"]
pub type W = crate::W<CnstatCmb6Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb6Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb6Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb6Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb6Spec;
impl crate::RegisterSpec for CnstatCmb6Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb6::R`](R) reader structure"]
impl crate::Readable for CnstatCmb6Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb6::W`](W) writer structure"]
impl crate::Writable for CnstatCmb6Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB6 to value 0"]
impl crate::Resettable for CnstatCmb6Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb7.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB7` reader"]
pub type R = crate::R<CnstatCmb7Spec>;
#[doc = "Register `CNSTAT_CMB7` writer"]
pub type W = crate::W<CnstatCmb7Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb7Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb7Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb7Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb7Spec;
impl crate::RegisterSpec for CnstatCmb7Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb7::R`](R) reader structure"]
impl crate::Readable for CnstatCmb7Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb7::W`](W) writer structure"]
impl crate::Writable for CnstatCmb7Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB7 to value 0"]
impl crate::Resettable for CnstatCmb7Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb8.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB8` reader"]
pub type R = crate::R<CnstatCmb8Spec>;
#[doc = "Register `CNSTAT_CMB8` writer"]
pub type W = crate::W<CnstatCmb8Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb8Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb8Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb8Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb8Spec;
impl crate::RegisterSpec for CnstatCmb8Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb8::R`](R) reader structure"]
impl crate::Readable for CnstatCmb8Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb8::W`](W) writer structure"]
impl crate::Writable for CnstatCmb8Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB8 to value 0"]
impl crate::Resettable for CnstatCmb8Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_cmb9.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_CMB9` reader"]
pub type R = crate::R<CnstatCmb9Spec>;
#[doc = "Register `CNSTAT_CMB9` writer"]
pub type W = crate::W<CnstatCmb9Spec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatCmb9Spec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatCmb9Spec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatCmb9Spec> {
DlcW::new(self, 12)
}
}
#[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 CnstatCmb9Spec;
impl crate::RegisterSpec for CnstatCmb9Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_cmb9::R`](R) reader structure"]
impl crate::Readable for CnstatCmb9Spec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_cmb9::W`](W) writer structure"]
impl crate::Writable for CnstatCmb9Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_CMB9 to value 0"]
impl crate::Resettable for CnstatCmb9Spec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cnstat_hcmb.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CNSTAT_HCMB` reader"]
pub type R = crate::R<CnstatHcmbSpec>;
#[doc = "Register `CNSTAT_HCMB` writer"]
pub type W = crate::W<CnstatHcmbSpec>;
#[doc = "Field `ST` reader - Buffer Status"]
pub type StR = crate::FieldReader;
#[doc = "Field `ST` writer - Buffer Status"]
pub type StW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `PRI` reader - Transmit Priority Code"]
pub type PriR = crate::FieldReader;
#[doc = "Field `PRI` writer - Transmit Priority Code"]
pub type PriW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `DLC` reader - Data Length Code"]
pub type DlcR = crate::FieldReader;
#[doc = "Field `DLC` writer - Data Length Code"]
pub type DlcW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
impl R {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
pub fn st(&self) -> StR {
StR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
pub fn pri(&self) -> PriR {
PriR::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
pub fn dlc(&self) -> DlcR {
DlcR::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Buffer Status"]
#[inline(always)]
#[must_use]
pub fn st(&mut self) -> StW<CnstatHcmbSpec> {
StW::new(self, 0)
}
#[doc = "Bits 4:7 - Transmit Priority Code"]
#[inline(always)]
#[must_use]
pub fn pri(&mut self) -> PriW<CnstatHcmbSpec> {
PriW::new(self, 4)
}
#[doc = "Bits 12:15 - Data Length Code"]
#[inline(always)]
#[must_use]
pub fn dlc(&mut self) -> DlcW<CnstatHcmbSpec> {
DlcW::new(self, 12)
}
}
#[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 CnstatHcmbSpec;
impl crate::RegisterSpec for CnstatHcmbSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cnstat_hcmb::R`](R) reader structure"]
impl crate::Readable for CnstatHcmbSpec {}
#[doc = "`write(|w| ..)` method takes [`cnstat_hcmb::W`](W) writer structure"]
impl crate::Writable for CnstatHcmbSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CNSTAT_HCMB to value 0"]
impl crate::Resettable for CnstatHcmbSpec {
const RESET_VALUE: u32 = 0;
}

70
va416xx/src/can0/cstpnd.rs Normal file
View File

@ -0,0 +1,70 @@
#[doc = "Register `CSTPND` reader"]
pub type R = crate::R<CstpndSpec>;
#[doc = "Register `CSTPND` writer"]
pub type W = crate::W<CstpndSpec>;
#[doc = "Field `IST` reader - Interrupt Source portion of Interrupt Code"]
pub type IstR = crate::FieldReader;
#[doc = "Field `IST` writer - Interrupt Source portion of Interrupt Code"]
pub type IstW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `IRQ` reader - Interrupt Request portion of Interrupt Code"]
pub type IrqR = crate::BitReader;
#[doc = "Field `IRQ` writer - Interrupt Request portion of Interrupt Code"]
pub type IrqW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `NS` reader - CAN Node Status"]
pub type NsR = crate::FieldReader;
#[doc = "Field `NS` writer - CAN Node Status"]
pub type NsW<'a, REG> = crate::FieldWriter<'a, REG, 3>;
impl R {
#[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
#[inline(always)]
pub fn ist(&self) -> IstR {
IstR::new((self.bits & 0x0f) as u8)
}
#[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
#[inline(always)]
pub fn irq(&self) -> IrqR {
IrqR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bits 5:7 - CAN Node Status"]
#[inline(always)]
pub fn ns(&self) -> NsR {
NsR::new(((self.bits >> 5) & 7) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
#[inline(always)]
#[must_use]
pub fn ist(&mut self) -> IstW<CstpndSpec> {
IstW::new(self, 0)
}
#[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
#[inline(always)]
#[must_use]
pub fn irq(&mut self) -> IrqW<CstpndSpec> {
IrqW::new(self, 4)
}
#[doc = "Bits 5:7 - CAN Node Status"]
#[inline(always)]
#[must_use]
pub fn ns(&mut self) -> NsW<CstpndSpec> {
NsW::new(self, 5)
}
}
#[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 CstpndSpec;
impl crate::RegisterSpec for CstpndSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`cstpnd::R`](R) reader structure"]
impl crate::Readable for CstpndSpec {}
#[doc = "`write(|w| ..)` method takes [`cstpnd::W`](W) writer structure"]
impl crate::Writable for CstpndSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CSTPND to value 0"]
impl crate::Resettable for CstpndSpec {
const RESET_VALUE: u32 = 0;
}

85
va416xx/src/can0/ctim.rs Normal file
View File

@ -0,0 +1,85 @@
#[doc = "Register `CTIM` reader"]
pub type R = crate::R<CtimSpec>;
#[doc = "Register `CTIM` writer"]
pub type W = crate::W<CtimSpec>;
#[doc = "Field `TSEG2` reader - Time Segment 2"]
pub type Tseg2R = crate::FieldReader;
#[doc = "Field `TSEG2` writer - Time Segment 2"]
pub type Tseg2W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
#[doc = "Field `TSEG1` reader - Time Segment 1"]
pub type Tseg1R = crate::FieldReader;
#[doc = "Field `TSEG1` writer - Time Segment 1"]
pub type Tseg1W<'a, REG> = crate::FieldWriter<'a, REG, 4>;
#[doc = "Field `SJW` reader - Synchronization Jump Width"]
pub type SjwR = crate::FieldReader;
#[doc = "Field `SJW` writer - Synchronization Jump Width"]
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 {
#[doc = "Bits 0:2 - Time Segment 2"]
#[inline(always)]
pub fn tseg2(&self) -> Tseg2R {
Tseg2R::new((self.bits & 7) as u8)
}
#[doc = "Bits 3:6 - Time Segment 1"]
#[inline(always)]
pub fn tseg1(&self) -> Tseg1R {
Tseg1R::new(((self.bits >> 3) & 0x0f) as u8)
}
#[doc = "Bits 7:8 - Synchronization Jump Width"]
#[inline(always)]
pub fn sjw(&self) -> SjwR {
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 {
#[doc = "Bits 0:2 - Time Segment 2"]
#[inline(always)]
#[must_use]
pub fn tseg2(&mut self) -> Tseg2W<CtimSpec> {
Tseg2W::new(self, 0)
}
#[doc = "Bits 3:6 - Time Segment 1"]
#[inline(always)]
#[must_use]
pub fn tseg1(&mut self) -> Tseg1W<CtimSpec> {
Tseg1W::new(self, 3)
}
#[doc = "Bits 7:8 - Synchronization Jump Width"]
#[inline(always)]
#[must_use]
pub fn sjw(&mut self) -> SjwW<CtimSpec> {
SjwW::new(self, 7)
}
#[doc = "Bits 9:15 - Prescaler Configuration"]
#[inline(always)]
#[must_use]
pub fn psc(&mut self) -> PscW<CtimSpec> {
PscW::new(self, 9)
}
}
#[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 CtimSpec;
impl crate::RegisterSpec for CtimSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`ctim::R`](R) reader structure"]
impl crate::Readable for CtimSpec {}
#[doc = "`write(|w| ..)` method takes [`ctim::W`](W) writer structure"]
impl crate::Writable for CtimSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CTIM to value 0"]
impl crate::Resettable for CtimSpec {
const RESET_VALUE: u32 = 0;
}

31
va416xx/src/can0/ctmr.rs Normal file
View File

@ -0,0 +1,31 @@
#[doc = "Register `CTMR` reader"]
pub type R = crate::R<CtmrSpec>;
#[doc = "Register `CTMR` writer"]
pub type W = crate::W<CtmrSpec>;
#[doc = "Field `CTMR` reader - Time Stamp Counter"]
pub type CtmrR = crate::FieldReader<u16>;
impl R {
#[doc = "Bits 0:15 - Time Stamp Counter"]
#[inline(always)]
pub fn ctmr(&self) -> CtmrR {
CtmrR::new((self.bits & 0xffff) as u16)
}
}
impl W {}
#[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)."]
pub struct CtmrSpec;
impl crate::RegisterSpec for CtmrSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`ctmr::R`](R) reader structure"]
impl crate::Readable for CtmrSpec {}
#[doc = "`write(|w| ..)` method takes [`ctmr::W`](W) writer structure"]
impl crate::Writable for CtmrSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets CTMR to value 0"]
impl crate::Resettable for CtmrSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb0.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB0` reader"]
pub type R = crate::R<Data0Cmb0Spec>;
#[doc = "Register `DATA0_CMB0` writer"]
pub type W = crate::W<Data0Cmb0Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb0Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb0Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb0Spec;
impl crate::RegisterSpec for Data0Cmb0Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb0::R`](R) reader structure"]
impl crate::Readable for Data0Cmb0Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb0::W`](W) writer structure"]
impl crate::Writable for Data0Cmb0Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB0 to value 0"]
impl crate::Resettable for Data0Cmb0Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb1.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB1` reader"]
pub type R = crate::R<Data0Cmb1Spec>;
#[doc = "Register `DATA0_CMB1` writer"]
pub type W = crate::W<Data0Cmb1Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb1Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb1Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb1Spec;
impl crate::RegisterSpec for Data0Cmb1Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb1::R`](R) reader structure"]
impl crate::Readable for Data0Cmb1Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb1::W`](W) writer structure"]
impl crate::Writable for Data0Cmb1Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB1 to value 0"]
impl crate::Resettable for Data0Cmb1Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb10.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB10` reader"]
pub type R = crate::R<Data0Cmb10Spec>;
#[doc = "Register `DATA0_CMB10` writer"]
pub type W = crate::W<Data0Cmb10Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb10Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb10Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb10Spec;
impl crate::RegisterSpec for Data0Cmb10Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb10::R`](R) reader structure"]
impl crate::Readable for Data0Cmb10Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb10::W`](W) writer structure"]
impl crate::Writable for Data0Cmb10Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB10 to value 0"]
impl crate::Resettable for Data0Cmb10Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb11.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB11` reader"]
pub type R = crate::R<Data0Cmb11Spec>;
#[doc = "Register `DATA0_CMB11` writer"]
pub type W = crate::W<Data0Cmb11Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb11Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb11Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb11Spec;
impl crate::RegisterSpec for Data0Cmb11Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb11::R`](R) reader structure"]
impl crate::Readable for Data0Cmb11Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb11::W`](W) writer structure"]
impl crate::Writable for Data0Cmb11Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB11 to value 0"]
impl crate::Resettable for Data0Cmb11Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb12.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB12` reader"]
pub type R = crate::R<Data0Cmb12Spec>;
#[doc = "Register `DATA0_CMB12` writer"]
pub type W = crate::W<Data0Cmb12Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb12Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb12Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb12Spec;
impl crate::RegisterSpec for Data0Cmb12Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb12::R`](R) reader structure"]
impl crate::Readable for Data0Cmb12Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb12::W`](W) writer structure"]
impl crate::Writable for Data0Cmb12Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB12 to value 0"]
impl crate::Resettable for Data0Cmb12Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb13.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB13` reader"]
pub type R = crate::R<Data0Cmb13Spec>;
#[doc = "Register `DATA0_CMB13` writer"]
pub type W = crate::W<Data0Cmb13Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb13Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb13Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb13Spec;
impl crate::RegisterSpec for Data0Cmb13Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb13::R`](R) reader structure"]
impl crate::Readable for Data0Cmb13Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb13::W`](W) writer structure"]
impl crate::Writable for Data0Cmb13Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB13 to value 0"]
impl crate::Resettable for Data0Cmb13Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb14.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB14` reader"]
pub type R = crate::R<Data0Cmb14Spec>;
#[doc = "Register `DATA0_CMB14` writer"]
pub type W = crate::W<Data0Cmb14Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb14Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb14Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb14Spec;
impl crate::RegisterSpec for Data0Cmb14Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb14::R`](R) reader structure"]
impl crate::Readable for Data0Cmb14Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb14::W`](W) writer structure"]
impl crate::Writable for Data0Cmb14Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB14 to value 0"]
impl crate::Resettable for Data0Cmb14Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb2.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB2` reader"]
pub type R = crate::R<Data0Cmb2Spec>;
#[doc = "Register `DATA0_CMB2` writer"]
pub type W = crate::W<Data0Cmb2Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb2Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb2Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb2Spec;
impl crate::RegisterSpec for Data0Cmb2Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb2::R`](R) reader structure"]
impl crate::Readable for Data0Cmb2Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb2::W`](W) writer structure"]
impl crate::Writable for Data0Cmb2Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB2 to value 0"]
impl crate::Resettable for Data0Cmb2Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb3.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB3` reader"]
pub type R = crate::R<Data0Cmb3Spec>;
#[doc = "Register `DATA0_CMB3` writer"]
pub type W = crate::W<Data0Cmb3Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb3Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb3Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb3Spec;
impl crate::RegisterSpec for Data0Cmb3Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb3::R`](R) reader structure"]
impl crate::Readable for Data0Cmb3Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb3::W`](W) writer structure"]
impl crate::Writable for Data0Cmb3Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB3 to value 0"]
impl crate::Resettable for Data0Cmb3Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb4.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB4` reader"]
pub type R = crate::R<Data0Cmb4Spec>;
#[doc = "Register `DATA0_CMB4` writer"]
pub type W = crate::W<Data0Cmb4Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb4Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb4Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb4Spec;
impl crate::RegisterSpec for Data0Cmb4Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb4::R`](R) reader structure"]
impl crate::Readable for Data0Cmb4Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb4::W`](W) writer structure"]
impl crate::Writable for Data0Cmb4Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB4 to value 0"]
impl crate::Resettable for Data0Cmb4Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb5.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB5` reader"]
pub type R = crate::R<Data0Cmb5Spec>;
#[doc = "Register `DATA0_CMB5` writer"]
pub type W = crate::W<Data0Cmb5Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb5Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb5Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb5Spec;
impl crate::RegisterSpec for Data0Cmb5Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb5::R`](R) reader structure"]
impl crate::Readable for Data0Cmb5Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb5::W`](W) writer structure"]
impl crate::Writable for Data0Cmb5Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB5 to value 0"]
impl crate::Resettable for Data0Cmb5Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb6.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB6` reader"]
pub type R = crate::R<Data0Cmb6Spec>;
#[doc = "Register `DATA0_CMB6` writer"]
pub type W = crate::W<Data0Cmb6Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb6Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb6Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb6Spec;
impl crate::RegisterSpec for Data0Cmb6Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb6::R`](R) reader structure"]
impl crate::Readable for Data0Cmb6Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb6::W`](W) writer structure"]
impl crate::Writable for Data0Cmb6Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB6 to value 0"]
impl crate::Resettable for Data0Cmb6Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb7.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB7` reader"]
pub type R = crate::R<Data0Cmb7Spec>;
#[doc = "Register `DATA0_CMB7` writer"]
pub type W = crate::W<Data0Cmb7Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb7Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb7Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb7Spec;
impl crate::RegisterSpec for Data0Cmb7Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb7::R`](R) reader structure"]
impl crate::Readable for Data0Cmb7Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb7::W`](W) writer structure"]
impl crate::Writable for Data0Cmb7Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB7 to value 0"]
impl crate::Resettable for Data0Cmb7Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb8.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB8` reader"]
pub type R = crate::R<Data0Cmb8Spec>;
#[doc = "Register `DATA0_CMB8` writer"]
pub type W = crate::W<Data0Cmb8Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb8Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb8Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb8Spec;
impl crate::RegisterSpec for Data0Cmb8Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb8::R`](R) reader structure"]
impl crate::Readable for Data0Cmb8Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb8::W`](W) writer structure"]
impl crate::Writable for Data0Cmb8Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB8 to value 0"]
impl crate::Resettable for Data0Cmb8Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_cmb9.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_CMB9` reader"]
pub type R = crate::R<Data0Cmb9Spec>;
#[doc = "Register `DATA0_CMB9` writer"]
pub type W = crate::W<Data0Cmb9Spec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0Cmb9Spec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0Cmb9Spec> {
Byte1W::new(self, 8)
}
}
#[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 Data0Cmb9Spec;
impl crate::RegisterSpec for Data0Cmb9Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_cmb9::R`](R) reader structure"]
impl crate::Readable for Data0Cmb9Spec {}
#[doc = "`write(|w| ..)` method takes [`data0_cmb9::W`](W) writer structure"]
impl crate::Writable for Data0Cmb9Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_CMB9 to value 0"]
impl crate::Resettable for Data0Cmb9Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data0_hcmb.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA0_HCMB` reader"]
pub type R = crate::R<Data0HcmbSpec>;
#[doc = "Register `DATA0_HCMB` writer"]
pub type W = crate::W<Data0HcmbSpec>;
#[doc = "Field `BYTE2` reader - Data Byte 2"]
pub type Byte2R = crate::FieldReader;
#[doc = "Field `BYTE2` writer - Data Byte 2"]
pub type Byte2W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE1` reader - Data Byte 1"]
pub type Byte1R = crate::FieldReader;
#[doc = "Field `BYTE1` writer - Data Byte 1"]
pub type Byte1W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
pub fn byte2(&self) -> Byte2R {
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 {
#[doc = "Bits 0:7 - Data Byte 2"]
#[inline(always)]
#[must_use]
pub fn byte2(&mut self) -> Byte2W<Data0HcmbSpec> {
Byte2W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 1"]
#[inline(always)]
#[must_use]
pub fn byte1(&mut self) -> Byte1W<Data0HcmbSpec> {
Byte1W::new(self, 8)
}
}
#[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 Data0HcmbSpec;
impl crate::RegisterSpec for Data0HcmbSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data0_hcmb::R`](R) reader structure"]
impl crate::Readable for Data0HcmbSpec {}
#[doc = "`write(|w| ..)` method takes [`data0_hcmb::W`](W) writer structure"]
impl crate::Writable for Data0HcmbSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA0_HCMB to value 0"]
impl crate::Resettable for Data0HcmbSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb0.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB0` reader"]
pub type R = crate::R<Data1Cmb0Spec>;
#[doc = "Register `DATA1_CMB0` writer"]
pub type W = crate::W<Data1Cmb0Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb0Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb0Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb0Spec;
impl crate::RegisterSpec for Data1Cmb0Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb0::R`](R) reader structure"]
impl crate::Readable for Data1Cmb0Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb0::W`](W) writer structure"]
impl crate::Writable for Data1Cmb0Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB0 to value 0"]
impl crate::Resettable for Data1Cmb0Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb1.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB1` reader"]
pub type R = crate::R<Data1Cmb1Spec>;
#[doc = "Register `DATA1_CMB1` writer"]
pub type W = crate::W<Data1Cmb1Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb1Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb1Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb1Spec;
impl crate::RegisterSpec for Data1Cmb1Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb1::R`](R) reader structure"]
impl crate::Readable for Data1Cmb1Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb1::W`](W) writer structure"]
impl crate::Writable for Data1Cmb1Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB1 to value 0"]
impl crate::Resettable for Data1Cmb1Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb10.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB10` reader"]
pub type R = crate::R<Data1Cmb10Spec>;
#[doc = "Register `DATA1_CMB10` writer"]
pub type W = crate::W<Data1Cmb10Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb10Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb10Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb10Spec;
impl crate::RegisterSpec for Data1Cmb10Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb10::R`](R) reader structure"]
impl crate::Readable for Data1Cmb10Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb10::W`](W) writer structure"]
impl crate::Writable for Data1Cmb10Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB10 to value 0"]
impl crate::Resettable for Data1Cmb10Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb11.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB11` reader"]
pub type R = crate::R<Data1Cmb11Spec>;
#[doc = "Register `DATA1_CMB11` writer"]
pub type W = crate::W<Data1Cmb11Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb11Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb11Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb11Spec;
impl crate::RegisterSpec for Data1Cmb11Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb11::R`](R) reader structure"]
impl crate::Readable for Data1Cmb11Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb11::W`](W) writer structure"]
impl crate::Writable for Data1Cmb11Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB11 to value 0"]
impl crate::Resettable for Data1Cmb11Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb12.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB12` reader"]
pub type R = crate::R<Data1Cmb12Spec>;
#[doc = "Register `DATA1_CMB12` writer"]
pub type W = crate::W<Data1Cmb12Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb12Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb12Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb12Spec;
impl crate::RegisterSpec for Data1Cmb12Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb12::R`](R) reader structure"]
impl crate::Readable for Data1Cmb12Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb12::W`](W) writer structure"]
impl crate::Writable for Data1Cmb12Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB12 to value 0"]
impl crate::Resettable for Data1Cmb12Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb13.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB13` reader"]
pub type R = crate::R<Data1Cmb13Spec>;
#[doc = "Register `DATA1_CMB13` writer"]
pub type W = crate::W<Data1Cmb13Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb13Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb13Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb13Spec;
impl crate::RegisterSpec for Data1Cmb13Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb13::R`](R) reader structure"]
impl crate::Readable for Data1Cmb13Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb13::W`](W) writer structure"]
impl crate::Writable for Data1Cmb13Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB13 to value 0"]
impl crate::Resettable for Data1Cmb13Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb14.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB14` reader"]
pub type R = crate::R<Data1Cmb14Spec>;
#[doc = "Register `DATA1_CMB14` writer"]
pub type W = crate::W<Data1Cmb14Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb14Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb14Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb14Spec;
impl crate::RegisterSpec for Data1Cmb14Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb14::R`](R) reader structure"]
impl crate::Readable for Data1Cmb14Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb14::W`](W) writer structure"]
impl crate::Writable for Data1Cmb14Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB14 to value 0"]
impl crate::Resettable for Data1Cmb14Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb2.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB2` reader"]
pub type R = crate::R<Data1Cmb2Spec>;
#[doc = "Register `DATA1_CMB2` writer"]
pub type W = crate::W<Data1Cmb2Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb2Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb2Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb2Spec;
impl crate::RegisterSpec for Data1Cmb2Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb2::R`](R) reader structure"]
impl crate::Readable for Data1Cmb2Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb2::W`](W) writer structure"]
impl crate::Writable for Data1Cmb2Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB2 to value 0"]
impl crate::Resettable for Data1Cmb2Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb3.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB3` reader"]
pub type R = crate::R<Data1Cmb3Spec>;
#[doc = "Register `DATA1_CMB3` writer"]
pub type W = crate::W<Data1Cmb3Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb3Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb3Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb3Spec;
impl crate::RegisterSpec for Data1Cmb3Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb3::R`](R) reader structure"]
impl crate::Readable for Data1Cmb3Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb3::W`](W) writer structure"]
impl crate::Writable for Data1Cmb3Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB3 to value 0"]
impl crate::Resettable for Data1Cmb3Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb4.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB4` reader"]
pub type R = crate::R<Data1Cmb4Spec>;
#[doc = "Register `DATA1_CMB4` writer"]
pub type W = crate::W<Data1Cmb4Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb4Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb4Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb4Spec;
impl crate::RegisterSpec for Data1Cmb4Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb4::R`](R) reader structure"]
impl crate::Readable for Data1Cmb4Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb4::W`](W) writer structure"]
impl crate::Writable for Data1Cmb4Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB4 to value 0"]
impl crate::Resettable for Data1Cmb4Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb5.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB5` reader"]
pub type R = crate::R<Data1Cmb5Spec>;
#[doc = "Register `DATA1_CMB5` writer"]
pub type W = crate::W<Data1Cmb5Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb5Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb5Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb5Spec;
impl crate::RegisterSpec for Data1Cmb5Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb5::R`](R) reader structure"]
impl crate::Readable for Data1Cmb5Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb5::W`](W) writer structure"]
impl crate::Writable for Data1Cmb5Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB5 to value 0"]
impl crate::Resettable for Data1Cmb5Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb6.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB6` reader"]
pub type R = crate::R<Data1Cmb6Spec>;
#[doc = "Register `DATA1_CMB6` writer"]
pub type W = crate::W<Data1Cmb6Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb6Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb6Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb6Spec;
impl crate::RegisterSpec for Data1Cmb6Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb6::R`](R) reader structure"]
impl crate::Readable for Data1Cmb6Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb6::W`](W) writer structure"]
impl crate::Writable for Data1Cmb6Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB6 to value 0"]
impl crate::Resettable for Data1Cmb6Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb7.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB7` reader"]
pub type R = crate::R<Data1Cmb7Spec>;
#[doc = "Register `DATA1_CMB7` writer"]
pub type W = crate::W<Data1Cmb7Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb7Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb7Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb7Spec;
impl crate::RegisterSpec for Data1Cmb7Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb7::R`](R) reader structure"]
impl crate::Readable for Data1Cmb7Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb7::W`](W) writer structure"]
impl crate::Writable for Data1Cmb7Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB7 to value 0"]
impl crate::Resettable for Data1Cmb7Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb8.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB8` reader"]
pub type R = crate::R<Data1Cmb8Spec>;
#[doc = "Register `DATA1_CMB8` writer"]
pub type W = crate::W<Data1Cmb8Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb8Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb8Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb8Spec;
impl crate::RegisterSpec for Data1Cmb8Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb8::R`](R) reader structure"]
impl crate::Readable for Data1Cmb8Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb8::W`](W) writer structure"]
impl crate::Writable for Data1Cmb8Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB8 to value 0"]
impl crate::Resettable for Data1Cmb8Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_cmb9.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_CMB9` reader"]
pub type R = crate::R<Data1Cmb9Spec>;
#[doc = "Register `DATA1_CMB9` writer"]
pub type W = crate::W<Data1Cmb9Spec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1Cmb9Spec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1Cmb9Spec> {
Byte3W::new(self, 8)
}
}
#[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 Data1Cmb9Spec;
impl crate::RegisterSpec for Data1Cmb9Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_cmb9::R`](R) reader structure"]
impl crate::Readable for Data1Cmb9Spec {}
#[doc = "`write(|w| ..)` method takes [`data1_cmb9::W`](W) writer structure"]
impl crate::Writable for Data1Cmb9Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_CMB9 to value 0"]
impl crate::Resettable for Data1Cmb9Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data1_hcmb.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA1_HCMB` reader"]
pub type R = crate::R<Data1HcmbSpec>;
#[doc = "Register `DATA1_HCMB` writer"]
pub type W = crate::W<Data1HcmbSpec>;
#[doc = "Field `BYTE4` reader - Data Byte 4"]
pub type Byte4R = crate::FieldReader;
#[doc = "Field `BYTE4` writer - Data Byte 4"]
pub type Byte4W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE3` reader - Data Byte 3"]
pub type Byte3R = crate::FieldReader;
#[doc = "Field `BYTE3` writer - Data Byte 3"]
pub type Byte3W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
pub fn byte4(&self) -> Byte4R {
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 {
#[doc = "Bits 0:7 - Data Byte 4"]
#[inline(always)]
#[must_use]
pub fn byte4(&mut self) -> Byte4W<Data1HcmbSpec> {
Byte4W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 3"]
#[inline(always)]
#[must_use]
pub fn byte3(&mut self) -> Byte3W<Data1HcmbSpec> {
Byte3W::new(self, 8)
}
}
#[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 Data1HcmbSpec;
impl crate::RegisterSpec for Data1HcmbSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data1_hcmb::R`](R) reader structure"]
impl crate::Readable for Data1HcmbSpec {}
#[doc = "`write(|w| ..)` method takes [`data1_hcmb::W`](W) writer structure"]
impl crate::Writable for Data1HcmbSpec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA1_HCMB to value 0"]
impl crate::Resettable for Data1HcmbSpec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb0.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB0` reader"]
pub type R = crate::R<Data2Cmb0Spec>;
#[doc = "Register `DATA2_CMB0` writer"]
pub type W = crate::W<Data2Cmb0Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb0Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb0Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb0Spec;
impl crate::RegisterSpec for Data2Cmb0Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb0::R`](R) reader structure"]
impl crate::Readable for Data2Cmb0Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb0::W`](W) writer structure"]
impl crate::Writable for Data2Cmb0Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB0 to value 0"]
impl crate::Resettable for Data2Cmb0Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb1.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB1` reader"]
pub type R = crate::R<Data2Cmb1Spec>;
#[doc = "Register `DATA2_CMB1` writer"]
pub type W = crate::W<Data2Cmb1Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb1Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb1Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb1Spec;
impl crate::RegisterSpec for Data2Cmb1Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb1::R`](R) reader structure"]
impl crate::Readable for Data2Cmb1Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb1::W`](W) writer structure"]
impl crate::Writable for Data2Cmb1Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB1 to value 0"]
impl crate::Resettable for Data2Cmb1Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb10.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB10` reader"]
pub type R = crate::R<Data2Cmb10Spec>;
#[doc = "Register `DATA2_CMB10` writer"]
pub type W = crate::W<Data2Cmb10Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb10Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb10Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb10Spec;
impl crate::RegisterSpec for Data2Cmb10Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb10::R`](R) reader structure"]
impl crate::Readable for Data2Cmb10Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb10::W`](W) writer structure"]
impl crate::Writable for Data2Cmb10Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB10 to value 0"]
impl crate::Resettable for Data2Cmb10Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb11.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB11` reader"]
pub type R = crate::R<Data2Cmb11Spec>;
#[doc = "Register `DATA2_CMB11` writer"]
pub type W = crate::W<Data2Cmb11Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb11Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb11Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb11Spec;
impl crate::RegisterSpec for Data2Cmb11Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb11::R`](R) reader structure"]
impl crate::Readable for Data2Cmb11Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb11::W`](W) writer structure"]
impl crate::Writable for Data2Cmb11Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB11 to value 0"]
impl crate::Resettable for Data2Cmb11Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb12.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB12` reader"]
pub type R = crate::R<Data2Cmb12Spec>;
#[doc = "Register `DATA2_CMB12` writer"]
pub type W = crate::W<Data2Cmb12Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb12Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb12Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb12Spec;
impl crate::RegisterSpec for Data2Cmb12Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb12::R`](R) reader structure"]
impl crate::Readable for Data2Cmb12Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb12::W`](W) writer structure"]
impl crate::Writable for Data2Cmb12Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB12 to value 0"]
impl crate::Resettable for Data2Cmb12Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb13.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB13` reader"]
pub type R = crate::R<Data2Cmb13Spec>;
#[doc = "Register `DATA2_CMB13` writer"]
pub type W = crate::W<Data2Cmb13Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb13Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb13Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb13Spec;
impl crate::RegisterSpec for Data2Cmb13Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb13::R`](R) reader structure"]
impl crate::Readable for Data2Cmb13Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb13::W`](W) writer structure"]
impl crate::Writable for Data2Cmb13Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB13 to value 0"]
impl crate::Resettable for Data2Cmb13Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb14.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB14` reader"]
pub type R = crate::R<Data2Cmb14Spec>;
#[doc = "Register `DATA2_CMB14` writer"]
pub type W = crate::W<Data2Cmb14Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb14Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb14Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb14Spec;
impl crate::RegisterSpec for Data2Cmb14Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb14::R`](R) reader structure"]
impl crate::Readable for Data2Cmb14Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb14::W`](W) writer structure"]
impl crate::Writable for Data2Cmb14Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB14 to value 0"]
impl crate::Resettable for Data2Cmb14Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb2.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB2` reader"]
pub type R = crate::R<Data2Cmb2Spec>;
#[doc = "Register `DATA2_CMB2` writer"]
pub type W = crate::W<Data2Cmb2Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb2Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb2Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb2Spec;
impl crate::RegisterSpec for Data2Cmb2Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb2::R`](R) reader structure"]
impl crate::Readable for Data2Cmb2Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb2::W`](W) writer structure"]
impl crate::Writable for Data2Cmb2Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB2 to value 0"]
impl crate::Resettable for Data2Cmb2Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb3.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB3` reader"]
pub type R = crate::R<Data2Cmb3Spec>;
#[doc = "Register `DATA2_CMB3` writer"]
pub type W = crate::W<Data2Cmb3Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb3Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb3Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb3Spec;
impl crate::RegisterSpec for Data2Cmb3Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb3::R`](R) reader structure"]
impl crate::Readable for Data2Cmb3Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb3::W`](W) writer structure"]
impl crate::Writable for Data2Cmb3Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB3 to value 0"]
impl crate::Resettable for Data2Cmb3Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb4.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB4` reader"]
pub type R = crate::R<Data2Cmb4Spec>;
#[doc = "Register `DATA2_CMB4` writer"]
pub type W = crate::W<Data2Cmb4Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb4Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb4Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb4Spec;
impl crate::RegisterSpec for Data2Cmb4Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb4::R`](R) reader structure"]
impl crate::Readable for Data2Cmb4Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb4::W`](W) writer structure"]
impl crate::Writable for Data2Cmb4Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB4 to value 0"]
impl crate::Resettable for Data2Cmb4Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb5.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB5` reader"]
pub type R = crate::R<Data2Cmb5Spec>;
#[doc = "Register `DATA2_CMB5` writer"]
pub type W = crate::W<Data2Cmb5Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb5Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb5Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb5Spec;
impl crate::RegisterSpec for Data2Cmb5Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb5::R`](R) reader structure"]
impl crate::Readable for Data2Cmb5Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb5::W`](W) writer structure"]
impl crate::Writable for Data2Cmb5Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB5 to value 0"]
impl crate::Resettable for Data2Cmb5Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb6.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB6` reader"]
pub type R = crate::R<Data2Cmb6Spec>;
#[doc = "Register `DATA2_CMB6` writer"]
pub type W = crate::W<Data2Cmb6Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb6Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb6Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb6Spec;
impl crate::RegisterSpec for Data2Cmb6Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb6::R`](R) reader structure"]
impl crate::Readable for Data2Cmb6Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb6::W`](W) writer structure"]
impl crate::Writable for Data2Cmb6Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB6 to value 0"]
impl crate::Resettable for Data2Cmb6Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb7.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB7` reader"]
pub type R = crate::R<Data2Cmb7Spec>;
#[doc = "Register `DATA2_CMB7` writer"]
pub type W = crate::W<Data2Cmb7Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb7Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb7Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb7Spec;
impl crate::RegisterSpec for Data2Cmb7Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb7::R`](R) reader structure"]
impl crate::Readable for Data2Cmb7Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb7::W`](W) writer structure"]
impl crate::Writable for Data2Cmb7Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB7 to value 0"]
impl crate::Resettable for Data2Cmb7Spec {
const RESET_VALUE: u32 = 0;
}

55
va416xx/src/can0/data2_cmb8.rs Normal file
View File

@ -0,0 +1,55 @@
#[doc = "Register `DATA2_CMB8` reader"]
pub type R = crate::R<Data2Cmb8Spec>;
#[doc = "Register `DATA2_CMB8` writer"]
pub type W = crate::W<Data2Cmb8Spec>;
#[doc = "Field `BYTE6` reader - Data Byte 6"]
pub type Byte6R = crate::FieldReader;
#[doc = "Field `BYTE6` writer - Data Byte 6"]
pub type Byte6W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
#[doc = "Field `BYTE5` reader - Data Byte 5"]
pub type Byte5R = crate::FieldReader;
#[doc = "Field `BYTE5` writer - Data Byte 5"]
pub type Byte5W<'a, REG> = crate::FieldWriter<'a, REG, 8>;
impl R {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
pub fn byte6(&self) -> Byte6R {
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 {
#[doc = "Bits 0:7 - Data Byte 6"]
#[inline(always)]
#[must_use]
pub fn byte6(&mut self) -> Byte6W<Data2Cmb8Spec> {
Byte6W::new(self, 0)
}
#[doc = "Bits 8:15 - Data Byte 5"]
#[inline(always)]
#[must_use]
pub fn byte5(&mut self) -> Byte5W<Data2Cmb8Spec> {
Byte5W::new(self, 8)
}
}
#[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 Data2Cmb8Spec;
impl crate::RegisterSpec for Data2Cmb8Spec {
type Ux = u32;
}
#[doc = "`read()` method returns [`data2_cmb8::R`](R) reader structure"]
impl crate::Readable for Data2Cmb8Spec {}
#[doc = "`write(|w| ..)` method takes [`data2_cmb8::W`](W) writer structure"]
impl crate::Writable for Data2Cmb8Spec {
type Safety = crate::Unsafe;
const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
}
#[doc = "`reset()` method sets DATA2_CMB8 to value 0"]
impl crate::Resettable for Data2Cmb8Spec {
const RESET_VALUE: u32 = 0;
}

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