add va416xx regularly
This commit is contained in:
parent
18b2432f6b
commit
9aa0eeb3ce
3
.gitmodules
vendored
3
.gitmodules
vendored
@ -1,6 +1,3 @@
|
||||
[submodule "va416xx"]
|
||||
path = va416xx
|
||||
url = https://egit.irs.uni-stuttgart.de/rust/va416xx.git
|
||||
[submodule "va416xx-hal"]
|
||||
path = va416xx-hal
|
||||
url = https://egit.irs.uni-stuttgart.de/rust/va416xx-hal.git
|
||||
|
1
va416xx
1
va416xx
@ -1 +0,0 @@
|
||||
Subproject commit 2cdc2a8128ff6a4db5b8a1a87a3e243a9fc634e2
|
2
va416xx/.github/bors.toml
vendored
Normal file
2
va416xx/.github/bors.toml
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
status = ["ci"]
|
||||
delete_merged_branches = true
|
20
va416xx/.github/workflows/changelog.yml
vendored
Normal file
20
va416xx/.github/workflows/changelog.yml
vendored
Normal 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
64
va416xx/.github/workflows/ci.yml
vendored
Normal 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
2
va416xx/.gitignore
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
/target
|
||||
Cargo.lock
|
21
va416xx/CHANGELOG.md
Normal file
21
va416xx/CHANGELOG.md
Normal 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
|
24
va416xx/Cargo.toml
Normal file
24
va416xx/Cargo.toml
Normal file
@ -0,0 +1,24 @@
|
||||
[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"
|
||||
|
||||
[dependencies.cortex-m-rt]
|
||||
optional = true
|
||||
version = ">=0.6.15,<0.8"
|
||||
|
||||
[features]
|
||||
rt = ["cortex-m-rt/device"]
|
201
va416xx/LICENSE-APACHE
Normal file
201
va416xx/LICENSE-APACHE
Normal 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
3
va416xx/NOTICE
Normal 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.
|
29
va416xx/README.md
Normal file
29
va416xx/README.md
Normal file
@ -0,0 +1,29 @@
|
||||
[![Crates.io](https://img.shields.io/crates/v/va416xx)](https://crates.io/crates/va416xx)
|
||||
[![build](https://github.com/us-irs/va416xx-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/us-irs/va416xx-rs/actions/workflows/ci.yml)
|
||||
[![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, please see the
|
||||
[svd2rust documentation](https://docs.rs/svd2rust/0.19.0/svd2rust/#peripheral-api).
|
||||
|
||||
## Regenerating the PAC
|
||||
|
||||
You can regenerate the PAC by running the `gen-helper.sh` helper script.
|
11
va416xx/automation/Dockerfile
Normal file
11
va416xx/automation/Dockerfile
Normal 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
39
va416xx/automation/Jenkinsfile
vendored
Normal 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'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
16
va416xx/build.rs
Normal file
16
va416xx/build.rs
Normal file
@ -0,0 +1,16 @@
|
||||
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
197
va416xx/device.x
Normal 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);
|
||||
|
21
va416xx/gen-helper.sh
Executable file
21
va416xx/gen-helper.sh
Executable file
@ -0,0 +1,21 @@
|
||||
#!/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
|
||||
${svd2rust_bin} -i svd/va416xx-base.svd
|
||||
rm -rf src
|
||||
form -i lib.rs -o src/ && rm lib.rs
|
||||
cargo fmt
|
65
va416xx/src/adc.rs
Normal file
65
va416xx/src/adc.rs
Normal file
@ -0,0 +1,65 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct RegisterBlock {
|
||||
#[doc = "0x00 - Control Register"]
|
||||
pub ctrl: crate::Reg<ctrl::CTRL_SPEC>,
|
||||
#[doc = "0x04 - FIFO data"]
|
||||
pub fifo_data: crate::Reg<fifo_data::FIFO_DATA_SPEC>,
|
||||
#[doc = "0x08 - Status"]
|
||||
pub status: crate::Reg<status::STATUS_SPEC>,
|
||||
#[doc = "0x0c - Interrupt Enable"]
|
||||
pub irq_enb: crate::Reg<irq_enb::IRQ_ENB_SPEC>,
|
||||
#[doc = "0x10 - Raw Interrupt Status"]
|
||||
pub irq_raw: crate::Reg<irq_raw::IRQ_RAW_SPEC>,
|
||||
#[doc = "0x14 - Enabled Interrupt Status"]
|
||||
pub irq_end: crate::Reg<irq_end::IRQ_END_SPEC>,
|
||||
#[doc = "0x18 - Clear Interrupt"]
|
||||
pub irq_clr: crate::Reg<irq_clr::IRQ_CLR_SPEC>,
|
||||
#[doc = "0x1c - Receive FIFO Interrupt Trigger Value"]
|
||||
pub rxfifoirqtrg: crate::Reg<rxfifoirqtrg::RXFIFOIRQTRG_SPEC>,
|
||||
#[doc = "0x20 - FIFO Clear"]
|
||||
pub fifo_clr: crate::Reg<fifo_clr::FIFO_CLR_SPEC>,
|
||||
_reserved9: [u8; 0x0fd8],
|
||||
#[doc = "0xffc - Peripheral ID Register"]
|
||||
pub perid: crate::Reg<perid::PERID_SPEC>,
|
||||
}
|
||||
#[doc = "CTRL register accessor: an alias for `Reg<CTRL_SPEC>`"]
|
||||
pub type CTRL = crate::Reg<ctrl::CTRL_SPEC>;
|
||||
#[doc = "Control Register"]
|
||||
pub mod ctrl;
|
||||
#[doc = "FIFO_DATA register accessor: an alias for `Reg<FIFO_DATA_SPEC>`"]
|
||||
pub type FIFO_DATA = crate::Reg<fifo_data::FIFO_DATA_SPEC>;
|
||||
#[doc = "FIFO data"]
|
||||
pub mod fifo_data;
|
||||
#[doc = "STATUS register accessor: an alias for `Reg<STATUS_SPEC>`"]
|
||||
pub type STATUS = crate::Reg<status::STATUS_SPEC>;
|
||||
#[doc = "Status"]
|
||||
pub mod status;
|
||||
#[doc = "IRQ_ENB register accessor: an alias for `Reg<IRQ_ENB_SPEC>`"]
|
||||
pub type IRQ_ENB = crate::Reg<irq_enb::IRQ_ENB_SPEC>;
|
||||
#[doc = "Interrupt Enable"]
|
||||
pub mod irq_enb;
|
||||
#[doc = "IRQ_RAW register accessor: an alias for `Reg<IRQ_RAW_SPEC>`"]
|
||||
pub type IRQ_RAW = crate::Reg<irq_raw::IRQ_RAW_SPEC>;
|
||||
#[doc = "Raw Interrupt Status"]
|
||||
pub mod irq_raw;
|
||||
#[doc = "IRQ_END register accessor: an alias for `Reg<IRQ_END_SPEC>`"]
|
||||
pub type IRQ_END = crate::Reg<irq_end::IRQ_END_SPEC>;
|
||||
#[doc = "Enabled Interrupt Status"]
|
||||
pub mod irq_end;
|
||||
#[doc = "IRQ_CLR register accessor: an alias for `Reg<IRQ_CLR_SPEC>`"]
|
||||
pub type IRQ_CLR = crate::Reg<irq_clr::IRQ_CLR_SPEC>;
|
||||
#[doc = "Clear Interrupt"]
|
||||
pub mod irq_clr;
|
||||
#[doc = "RXFIFOIRQTRG register accessor: an alias for `Reg<RXFIFOIRQTRG_SPEC>`"]
|
||||
pub type RXFIFOIRQTRG = crate::Reg<rxfifoirqtrg::RXFIFOIRQTRG_SPEC>;
|
||||
#[doc = "Receive FIFO Interrupt Trigger Value"]
|
||||
pub mod rxfifoirqtrg;
|
||||
#[doc = "FIFO_CLR register accessor: an alias for `Reg<FIFO_CLR_SPEC>`"]
|
||||
pub type FIFO_CLR = crate::Reg<fifo_clr::FIFO_CLR_SPEC>;
|
||||
#[doc = "FIFO Clear"]
|
||||
pub mod fifo_clr;
|
||||
#[doc = "PERID register accessor: an alias for `Reg<PERID_SPEC>`"]
|
||||
pub type PERID = crate::Reg<perid::PERID_SPEC>;
|
||||
#[doc = "Peripheral ID Register"]
|
||||
pub mod perid;
|
328
va416xx/src/adc/ctrl.rs
Normal file
328
va416xx/src/adc/ctrl.rs
Normal file
@ -0,0 +1,328 @@
|
||||
#[doc = "Register `CTRL` reader"]
|
||||
pub struct R(crate::R<CTRL_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CTRL_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CTRL_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CTRL_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CTRL` writer"]
|
||||
pub struct W(crate::W<CTRL_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CTRL_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CTRL_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CTRL_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CONV_CNT` reader - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
|
||||
pub struct CONV_CNT_R(crate::FieldReader<u8, u8>);
|
||||
impl CONV_CNT_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
CONV_CNT_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CONV_CNT_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CONV_CNT` writer - Conversion count describes the number of conversions to be applied for triggers/sweeps. (N+1 conversions)"]
|
||||
pub struct CONV_CNT_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CONV_CNT_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 20)) | ((value as u32 & 0x0f) << 20);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `MANUAL_TRIG` reader - Starts analog acquisition"]
|
||||
pub struct MANUAL_TRIG_R(crate::FieldReader<bool, bool>);
|
||||
impl MANUAL_TRIG_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
MANUAL_TRIG_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for MANUAL_TRIG_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `MANUAL_TRIG` writer - Starts analog acquisition"]
|
||||
pub struct MANUAL_TRIG_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> MANUAL_TRIG_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EXT_TRIG_EN` reader - Allows the external trigger to start analog acquisition"]
|
||||
pub struct EXT_TRIG_EN_R(crate::FieldReader<bool, bool>);
|
||||
impl EXT_TRIG_EN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
EXT_TRIG_EN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EXT_TRIG_EN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EXT_TRIG_EN` writer - Allows the external trigger to start analog acquisition"]
|
||||
pub struct EXT_TRIG_EN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EXT_TRIG_EN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `SWEEP_EN` reader - ADC data acquisition for all enabled channel"]
|
||||
pub struct SWEEP_EN_R(crate::FieldReader<bool, bool>);
|
||||
impl SWEEP_EN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
SWEEP_EN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for SWEEP_EN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `SWEEP_EN` writer - ADC data acquisition for all enabled channel"]
|
||||
pub struct SWEEP_EN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> SWEEP_EN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHAN_TAG_EN` reader - Enables the channel tag to be saved with the ADC data"]
|
||||
pub struct CHAN_TAG_EN_R(crate::FieldReader<bool, bool>);
|
||||
impl CHAN_TAG_EN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
CHAN_TAG_EN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CHAN_TAG_EN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHAN_TAG_EN` writer - Enables the channel tag to be saved with the ADC data"]
|
||||
pub struct CHAN_TAG_EN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CHAN_TAG_EN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHAN_EN` reader - Enables the channel for data collection"]
|
||||
pub struct CHAN_EN_R(crate::FieldReader<u16, u16>);
|
||||
impl CHAN_EN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
CHAN_EN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CHAN_EN_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHAN_EN` writer - Enables the channel for data collection"]
|
||||
pub struct CHAN_EN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CHAN_EN_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xffff) | (value as u32 & 0xffff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[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) -> CONV_CNT_R {
|
||||
CONV_CNT_R::new(((self.bits >> 20) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bit 19 - Starts analog acquisition"]
|
||||
#[inline(always)]
|
||||
pub fn manual_trig(&self) -> MANUAL_TRIG_R {
|
||||
MANUAL_TRIG_R::new(((self.bits >> 19) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
|
||||
#[inline(always)]
|
||||
pub fn ext_trig_en(&self) -> EXT_TRIG_EN_R {
|
||||
EXT_TRIG_EN_R::new(((self.bits >> 18) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
|
||||
#[inline(always)]
|
||||
pub fn sweep_en(&self) -> SWEEP_EN_R {
|
||||
SWEEP_EN_R::new(((self.bits >> 17) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
|
||||
#[inline(always)]
|
||||
pub fn chan_tag_en(&self) -> CHAN_TAG_EN_R {
|
||||
CHAN_TAG_EN_R::new(((self.bits >> 16) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:15 - Enables the channel for data collection"]
|
||||
#[inline(always)]
|
||||
pub fn chan_en(&self) -> CHAN_EN_R {
|
||||
CHAN_EN_R::new((self.bits & 0xffff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[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(&mut self) -> CONV_CNT_W {
|
||||
CONV_CNT_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 19 - Starts analog acquisition"]
|
||||
#[inline(always)]
|
||||
pub fn manual_trig(&mut self) -> MANUAL_TRIG_W {
|
||||
MANUAL_TRIG_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 18 - Allows the external trigger to start analog acquisition"]
|
||||
#[inline(always)]
|
||||
pub fn ext_trig_en(&mut self) -> EXT_TRIG_EN_W {
|
||||
EXT_TRIG_EN_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 17 - ADC data acquisition for all enabled channel"]
|
||||
#[inline(always)]
|
||||
pub fn sweep_en(&mut self) -> SWEEP_EN_W {
|
||||
SWEEP_EN_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 16 - Enables the channel tag to be saved with the ADC data"]
|
||||
#[inline(always)]
|
||||
pub fn chan_tag_en(&mut self) -> CHAN_TAG_EN_W {
|
||||
CHAN_TAG_EN_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:15 - Enables the channel for data collection"]
|
||||
#[inline(always)]
|
||||
pub fn chan_en(&mut self) -> CHAN_EN_W {
|
||||
CHAN_EN_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ctrl](index.html) module"]
|
||||
pub struct CTRL_SPEC;
|
||||
impl crate::RegisterSpec for CTRL_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [ctrl::R](R) reader structure"]
|
||||
impl crate::Readable for CTRL_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [ctrl::W](W) writer structure"]
|
||||
impl crate::Writable for CTRL_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CTRL to value 0"]
|
||||
impl crate::Resettable for CTRL_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
91
va416xx/src/adc/fifo_clr.rs
Normal file
91
va416xx/src/adc/fifo_clr.rs
Normal file
@ -0,0 +1,91 @@
|
||||
#[doc = "Register `FIFO_CLR` reader"]
|
||||
pub struct R(crate::R<FIFO_CLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<FIFO_CLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<FIFO_CLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<FIFO_CLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `FIFO_CLR` writer"]
|
||||
pub struct W(crate::W<FIFO_CLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<FIFO_CLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<FIFO_CLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<FIFO_CLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_CLR` writer - Clears the ADC FIFO. Always reads 0"]
|
||||
pub struct FIFO_CLR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_CLR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Clears the ADC FIFO. Always reads 0"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_clr(&mut self) -> FIFO_CLR_W {
|
||||
FIFO_CLR_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "FIFO Clear\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [fifo_clr](index.html) module"]
|
||||
pub struct FIFO_CLR_SPEC;
|
||||
impl crate::RegisterSpec for FIFO_CLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [fifo_clr::R](R) reader structure"]
|
||||
impl crate::Readable for FIFO_CLR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [fifo_clr::W](W) writer structure"]
|
||||
impl crate::Writable for FIFO_CLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets FIFO_CLR to value 0"]
|
||||
impl crate::Resettable for FIFO_CLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
73
va416xx/src/adc/fifo_data.rs
Normal file
73
va416xx/src/adc/fifo_data.rs
Normal file
@ -0,0 +1,73 @@
|
||||
#[doc = "Register `FIFO_DATA` reader"]
|
||||
pub struct R(crate::R<FIFO_DATA_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<FIFO_DATA_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<FIFO_DATA_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<FIFO_DATA_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHAN_TAG` reader - If enabled, this will include the number of the channel corresponding to the measurement"]
|
||||
pub struct CHAN_TAG_R(crate::FieldReader<u8, u8>);
|
||||
impl CHAN_TAG_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
CHAN_TAG_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CHAN_TAG_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_DATA` reader - ADC acquisition data from the FIFO"]
|
||||
pub struct ADC_DATA_R(crate::FieldReader<u16, u16>);
|
||||
impl ADC_DATA_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
ADC_DATA_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ADC_DATA_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - If enabled, this will include the number of the channel corresponding to the measurement"]
|
||||
#[inline(always)]
|
||||
pub fn chan_tag(&self) -> CHAN_TAG_R {
|
||||
CHAN_TAG_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:11 - ADC acquisition data from the FIFO"]
|
||||
#[inline(always)]
|
||||
pub fn adc_data(&self) -> ADC_DATA_R {
|
||||
ADC_DATA_R::new((self.bits & 0x0fff) as u16)
|
||||
}
|
||||
}
|
||||
#[doc = "FIFO data\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [fifo_data](index.html) module"]
|
||||
pub struct FIFO_DATA_SPEC;
|
||||
impl crate::RegisterSpec for FIFO_DATA_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [fifo_data::R](R) reader structure"]
|
||||
impl crate::Readable for FIFO_DATA_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets FIFO_DATA to value 0"]
|
||||
impl crate::Resettable for FIFO_DATA_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
153
va416xx/src/adc/irq_clr.rs
Normal file
153
va416xx/src/adc/irq_clr.rs
Normal file
@ -0,0 +1,153 @@
|
||||
#[doc = "Register `IRQ_CLR` writer"]
|
||||
pub struct W(crate::W<IRQ_CLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<IRQ_CLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<IRQ_CLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<IRQ_CLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TRIG_ERROR` writer - Clears the trigger error interrupt status. Always reads 0"]
|
||||
pub struct TRIG_ERROR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TRIG_ERROR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_DONE` writer - Clears the ADC done interrupt status. Always reads 0"]
|
||||
pub struct ADC_DONE_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ADC_DONE_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_UFLOW` writer - Clears the FIFO underflow interrupt status. Always reads 0"]
|
||||
pub struct FIFO_UFLOW_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_UFLOW_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_OFLOW` writer - Clears the FIFO overflow interrupt status. Always reads 0"]
|
||||
pub struct FIFO_OFLOW_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_OFLOW_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 3 - Clears the trigger error interrupt status. Always reads 0"]
|
||||
#[inline(always)]
|
||||
pub fn trig_error(&mut self) -> TRIG_ERROR_W {
|
||||
TRIG_ERROR_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 2 - Clears the ADC done interrupt status. Always reads 0"]
|
||||
#[inline(always)]
|
||||
pub fn adc_done(&mut self) -> ADC_DONE_W {
|
||||
ADC_DONE_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 1 - Clears the FIFO underflow interrupt status. Always reads 0"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_uflow(&mut self) -> FIFO_UFLOW_W {
|
||||
FIFO_UFLOW_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 0 - Clears the FIFO overflow interrupt status. Always reads 0"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_oflow(&mut self) -> FIFO_OFLOW_W {
|
||||
FIFO_OFLOW_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Clear Interrupt\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_clr](index.html) module"]
|
||||
pub struct IRQ_CLR_SPEC;
|
||||
impl crate::RegisterSpec for IRQ_CLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [irq_clr::W](W) writer structure"]
|
||||
impl crate::Writable for IRQ_CLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets IRQ_CLR to value 0"]
|
||||
impl crate::Resettable for IRQ_CLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
395
va416xx/src/adc/irq_enb.rs
Normal file
395
va416xx/src/adc/irq_enb.rs
Normal file
@ -0,0 +1,395 @@
|
||||
#[doc = "Register `IRQ_ENB` reader"]
|
||||
pub struct R(crate::R<IRQ_ENB_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<IRQ_ENB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<IRQ_ENB_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<IRQ_ENB_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `IRQ_ENB` writer"]
|
||||
pub struct W(crate::W<IRQ_ENB_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<IRQ_ENB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<IRQ_ENB_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<IRQ_ENB_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
|
||||
pub struct FIFO_DEPTH_TRIG_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_DEPTH_TRIG_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_DEPTH_TRIG_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_DEPTH_TRIG_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_DEPTH_TRIG` writer - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
|
||||
pub struct FIFO_DEPTH_TRIG_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_DEPTH_TRIG_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TRIG_ERROR` reader - Enables the interrupt for a trigger error"]
|
||||
pub struct TRIG_ERROR_R(crate::FieldReader<bool, bool>);
|
||||
impl TRIG_ERROR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
TRIG_ERROR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TRIG_ERROR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TRIG_ERROR` writer - Enables the interrupt for a trigger error"]
|
||||
pub struct TRIG_ERROR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TRIG_ERROR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_DONE` reader - Enables the interrupt for an ADC data acquisition completion"]
|
||||
pub struct ADC_DONE_R(crate::FieldReader<bool, bool>);
|
||||
impl ADC_DONE_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
ADC_DONE_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ADC_DONE_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_DONE` writer - Enables the interrupt for an ADC data acquisition completion"]
|
||||
pub struct ADC_DONE_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ADC_DONE_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_UFLOW` reader - Enables the interrupt for a FIFO underflow"]
|
||||
pub struct FIFO_UFLOW_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_UFLOW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_UFLOW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_UFLOW_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_UFLOW` writer - Enables the interrupt for a FIFO underflow"]
|
||||
pub struct FIFO_UFLOW_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_UFLOW_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_OFLOW` reader - Enables the interrupt for a FIFO overflow"]
|
||||
pub struct FIFO_OFLOW_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_OFLOW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_OFLOW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_OFLOW_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_OFLOW` writer - Enables the interrupt for a FIFO overflow"]
|
||||
pub struct FIFO_OFLOW_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_OFLOW_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_FULL` reader - Enables the interrupt for FIFO full"]
|
||||
pub struct FIFO_FULL_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_FULL_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_FULL_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_FULL_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_FULL` writer - Enables the interrupt for FIFO full"]
|
||||
pub struct FIFO_FULL_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_FULL_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_EMPTY` reader - Enables the interrupt for FIFO empty"]
|
||||
pub struct FIFO_EMPTY_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_EMPTY_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_EMPTY_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_EMPTY_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_EMPTY` writer - Enables the interrupt for FIFO empty"]
|
||||
pub struct FIFO_EMPTY_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> FIFO_EMPTY_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[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) -> FIFO_DEPTH_TRIG_R {
|
||||
FIFO_DEPTH_TRIG_R::new(((self.bits >> 6) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enables the interrupt for a trigger error"]
|
||||
#[inline(always)]
|
||||
pub fn trig_error(&self) -> TRIG_ERROR_R {
|
||||
TRIG_ERROR_R::new(((self.bits >> 5) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
|
||||
#[inline(always)]
|
||||
pub fn adc_done(&self) -> ADC_DONE_R {
|
||||
ADC_DONE_R::new(((self.bits >> 4) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_uflow(&self) -> FIFO_UFLOW_R {
|
||||
FIFO_UFLOW_R::new(((self.bits >> 3) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_oflow(&self) -> FIFO_OFLOW_R {
|
||||
FIFO_OFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enables the interrupt for FIFO full"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_full(&self) -> FIFO_FULL_R {
|
||||
FIFO_FULL_R::new(((self.bits >> 1) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_empty(&self) -> FIFO_EMPTY_R {
|
||||
FIFO_EMPTY_R::new((self.bits & 0x01) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 6 - Enables the interrupt for the FIFO entry count meets or exceeds the trigger level"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_depth_trig(&mut self) -> FIFO_DEPTH_TRIG_W {
|
||||
FIFO_DEPTH_TRIG_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 5 - Enables the interrupt for a trigger error"]
|
||||
#[inline(always)]
|
||||
pub fn trig_error(&mut self) -> TRIG_ERROR_W {
|
||||
TRIG_ERROR_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 4 - Enables the interrupt for an ADC data acquisition completion"]
|
||||
#[inline(always)]
|
||||
pub fn adc_done(&mut self) -> ADC_DONE_W {
|
||||
ADC_DONE_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 3 - Enables the interrupt for a FIFO underflow"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_uflow(&mut self) -> FIFO_UFLOW_W {
|
||||
FIFO_UFLOW_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 2 - Enables the interrupt for a FIFO overflow"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_oflow(&mut self) -> FIFO_OFLOW_W {
|
||||
FIFO_OFLOW_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 1 - Enables the interrupt for FIFO full"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_full(&mut self) -> FIFO_FULL_W {
|
||||
FIFO_FULL_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 0 - Enables the interrupt for FIFO empty"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_empty(&mut self) -> FIFO_EMPTY_W {
|
||||
FIFO_EMPTY_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Interrupt Enable\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_enb](index.html) module"]
|
||||
pub struct IRQ_ENB_SPEC;
|
||||
impl crate::RegisterSpec for IRQ_ENB_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [irq_enb::R](R) reader structure"]
|
||||
impl crate::Readable for IRQ_ENB_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [irq_enb::W](W) writer structure"]
|
||||
impl crate::Writable for IRQ_ENB_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets IRQ_ENB to value 0"]
|
||||
impl crate::Resettable for IRQ_ENB_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
173
va416xx/src/adc/irq_end.rs
Normal file
173
va416xx/src/adc/irq_end.rs
Normal file
@ -0,0 +1,173 @@
|
||||
#[doc = "Register `IRQ_END` reader"]
|
||||
pub struct R(crate::R<IRQ_END_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<IRQ_END_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<IRQ_END_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<IRQ_END_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
|
||||
pub struct FIFO_DEPTH_TRIG_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_DEPTH_TRIG_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_DEPTH_TRIG_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_DEPTH_TRIG_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
|
||||
pub struct TRIG_ERROR_R(crate::FieldReader<bool, bool>);
|
||||
impl TRIG_ERROR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
TRIG_ERROR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TRIG_ERROR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done and the interrupt is enabled"]
|
||||
pub struct ADC_DONE_R(crate::FieldReader<bool, bool>);
|
||||
impl ADC_DONE_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
ADC_DONE_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ADC_DONE_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_UFLOW` reader - Indicates a FIFO underflow occurred and the interrupt is enabled"]
|
||||
pub struct FIFO_UFLOW_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_UFLOW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_UFLOW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_UFLOW_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred and the interrupt is enabled"]
|
||||
pub struct FIFO_OFLOW_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_OFLOW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_OFLOW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_OFLOW_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full and the interrupt is enabled"]
|
||||
pub struct FIFO_FULL_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_FULL_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_FULL_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_FULL_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty and the interrupt is enabled"]
|
||||
pub struct FIFO_EMPTY_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_EMPTY_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_EMPTY_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_EMPTY_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[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) -> FIFO_DEPTH_TRIG_R {
|
||||
FIFO_DEPTH_TRIG_R::new(((self.bits >> 6) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion and the interrupt is enabled"]
|
||||
#[inline(always)]
|
||||
pub fn trig_error(&self) -> TRIG_ERROR_R {
|
||||
TRIG_ERROR_R::new(((self.bits >> 5) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Indicates that a ADC conversion is done and the interrupt is enabled"]
|
||||
#[inline(always)]
|
||||
pub fn adc_done(&self) -> ADC_DONE_R {
|
||||
ADC_DONE_R::new(((self.bits >> 4) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Indicates a FIFO underflow occurred and the interrupt is enabled"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_uflow(&self) -> FIFO_UFLOW_R {
|
||||
FIFO_UFLOW_R::new(((self.bits >> 3) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Indicates a FIFO overflow occurred and the interrupt is enabled"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_oflow(&self) -> FIFO_OFLOW_R {
|
||||
FIFO_OFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Indicates the FIFO is full and the interrupt is enabled"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_full(&self) -> FIFO_FULL_R {
|
||||
FIFO_FULL_R::new(((self.bits >> 1) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 0 - Indicates the FIFO is empty and the interrupt is enabled"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_empty(&self) -> FIFO_EMPTY_R {
|
||||
FIFO_EMPTY_R::new((self.bits & 0x01) != 0)
|
||||
}
|
||||
}
|
||||
#[doc = "Enabled Interrupt Status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_end](index.html) module"]
|
||||
pub struct IRQ_END_SPEC;
|
||||
impl crate::RegisterSpec for IRQ_END_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [irq_end::R](R) reader structure"]
|
||||
impl crate::Readable for IRQ_END_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets IRQ_END to value 0"]
|
||||
impl crate::Resettable for IRQ_END_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
173
va416xx/src/adc/irq_raw.rs
Normal file
173
va416xx/src/adc/irq_raw.rs
Normal file
@ -0,0 +1,173 @@
|
||||
#[doc = "Register `IRQ_RAW` reader"]
|
||||
pub struct R(crate::R<IRQ_RAW_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<IRQ_RAW_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<IRQ_RAW_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<IRQ_RAW_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_DEPTH_TRIG` reader - Indicates the interrupt for the FIFO entry count meets or exceeds the trigger level"]
|
||||
pub struct FIFO_DEPTH_TRIG_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_DEPTH_TRIG_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_DEPTH_TRIG_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_DEPTH_TRIG_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TRIG_ERROR` reader - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
|
||||
pub struct TRIG_ERROR_R(crate::FieldReader<bool, bool>);
|
||||
impl TRIG_ERROR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
TRIG_ERROR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TRIG_ERROR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_DONE` reader - Indicates that a ADC conversion is done"]
|
||||
pub struct ADC_DONE_R(crate::FieldReader<bool, bool>);
|
||||
impl ADC_DONE_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
ADC_DONE_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ADC_DONE_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_UFLOW` reader - Indicates data was unavailable when a new trigger for ADC update is received"]
|
||||
pub struct FIFO_UFLOW_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_UFLOW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_UFLOW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_UFLOW_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_OFLOW` reader - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
|
||||
pub struct FIFO_OFLOW_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_OFLOW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_OFLOW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_OFLOW_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_FULL` reader - Indicates the FIFO is full"]
|
||||
pub struct FIFO_FULL_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_FULL_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_FULL_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_FULL_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_EMPTY` reader - Indicates the FIFO is empty"]
|
||||
pub struct FIFO_EMPTY_R(crate::FieldReader<bool, bool>);
|
||||
impl FIFO_EMPTY_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
FIFO_EMPTY_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_EMPTY_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[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) -> FIFO_DEPTH_TRIG_R {
|
||||
FIFO_DEPTH_TRIG_R::new(((self.bits >> 6) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Indicates a manual or external trigger occurred when the ADC was BUSY doing a conversion"]
|
||||
#[inline(always)]
|
||||
pub fn trig_error(&self) -> TRIG_ERROR_R {
|
||||
TRIG_ERROR_R::new(((self.bits >> 5) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Indicates that a ADC conversion is done"]
|
||||
#[inline(always)]
|
||||
pub fn adc_done(&self) -> ADC_DONE_R {
|
||||
ADC_DONE_R::new(((self.bits >> 4) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Indicates data was unavailable when a new trigger for ADC update is received"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_uflow(&self) -> FIFO_UFLOW_R {
|
||||
FIFO_UFLOW_R::new(((self.bits >> 3) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Indicates a FIFO overflow occurred (FIFO was full when new data was written)"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_oflow(&self) -> FIFO_OFLOW_R {
|
||||
FIFO_OFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Indicates the FIFO is full"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_full(&self) -> FIFO_FULL_R {
|
||||
FIFO_FULL_R::new(((self.bits >> 1) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 0 - Indicates the FIFO is empty"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_empty(&self) -> FIFO_EMPTY_R {
|
||||
FIFO_EMPTY_R::new((self.bits & 0x01) != 0)
|
||||
}
|
||||
}
|
||||
#[doc = "Raw Interrupt Status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irq_raw](index.html) module"]
|
||||
pub struct IRQ_RAW_SPEC;
|
||||
impl crate::RegisterSpec for IRQ_RAW_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [irq_raw::R](R) reader structure"]
|
||||
impl crate::Readable for IRQ_RAW_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets IRQ_RAW to value 0x01"]
|
||||
impl crate::Resettable for IRQ_RAW_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x01
|
||||
}
|
||||
}
|
31
va416xx/src/adc/perid.rs
Normal file
31
va416xx/src/adc/perid.rs
Normal file
@ -0,0 +1,31 @@
|
||||
#[doc = "Register `PERID` reader"]
|
||||
pub struct R(crate::R<PERID_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<PERID_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<PERID_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<PERID_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Peripheral ID Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [perid](index.html) module"]
|
||||
pub struct PERID_SPEC;
|
||||
impl crate::RegisterSpec for PERID_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [perid::R](R) reader structure"]
|
||||
impl crate::Readable for PERID_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets PERID to value 0x0019_07e9"]
|
||||
impl crate::Resettable for PERID_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x0019_07e9
|
||||
}
|
||||
}
|
103
va416xx/src/adc/rxfifoirqtrg.rs
Normal file
103
va416xx/src/adc/rxfifoirqtrg.rs
Normal file
@ -0,0 +1,103 @@
|
||||
#[doc = "Register `RXFIFOIRQTRG` reader"]
|
||||
pub struct R(crate::R<RXFIFOIRQTRG_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<RXFIFOIRQTRG_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<RXFIFOIRQTRG_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<RXFIFOIRQTRG_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `RXFIFOIRQTRG` writer"]
|
||||
pub struct W(crate::W<RXFIFOIRQTRG_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<RXFIFOIRQTRG_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<RXFIFOIRQTRG_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<RXFIFOIRQTRG_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `LEVEL` reader - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
|
||||
pub struct LEVEL_R(crate::FieldReader<u8, u8>);
|
||||
impl LEVEL_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
LEVEL_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for LEVEL_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `LEVEL` writer - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
|
||||
pub struct LEVEL_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> LEVEL_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x1f) | (value as u32 & 0x1f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 0:4 - Sets the FIFO_ENTRY_CNT value that asserts the FIFO_DEPTH_TRIG interrupt"]
|
||||
#[inline(always)]
|
||||
pub fn level(&self) -> LEVEL_R {
|
||||
LEVEL_R::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)]
|
||||
pub fn level(&mut self) -> LEVEL_W {
|
||||
LEVEL_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Receive FIFO Interrupt Trigger Value\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxfifoirqtrg](index.html) module"]
|
||||
pub struct RXFIFOIRQTRG_SPEC;
|
||||
impl crate::RegisterSpec for RXFIFOIRQTRG_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [rxfifoirqtrg::R](R) reader structure"]
|
||||
impl crate::Readable for RXFIFOIRQTRG_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [rxfifoirqtrg::W](W) writer structure"]
|
||||
impl crate::Writable for RXFIFOIRQTRG_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets RXFIFOIRQTRG to value 0x10"]
|
||||
impl crate::Resettable for RXFIFOIRQTRG_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x10
|
||||
}
|
||||
}
|
73
va416xx/src/adc/status.rs
Normal file
73
va416xx/src/adc/status.rs
Normal file
@ -0,0 +1,73 @@
|
||||
#[doc = "Register `STATUS` reader"]
|
||||
pub struct R(crate::R<STATUS_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<STATUS_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<STATUS_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<STATUS_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ADC_BUSY` reader - Indicates an ADC data acquisition is in process"]
|
||||
pub struct ADC_BUSY_R(crate::FieldReader<bool, bool>);
|
||||
impl ADC_BUSY_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
ADC_BUSY_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ADC_BUSY_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `FIFO_ENTRY_CNT` reader - Indicates the number of entries in the FIFO"]
|
||||
pub struct FIFO_ENTRY_CNT_R(crate::FieldReader<u8, u8>);
|
||||
impl FIFO_ENTRY_CNT_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
FIFO_ENTRY_CNT_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for FIFO_ENTRY_CNT_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 7 - Indicates an ADC data acquisition is in process"]
|
||||
#[inline(always)]
|
||||
pub fn adc_busy(&self) -> ADC_BUSY_R {
|
||||
ADC_BUSY_R::new(((self.bits >> 7) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:5 - Indicates the number of entries in the FIFO"]
|
||||
#[inline(always)]
|
||||
pub fn fifo_entry_cnt(&self) -> FIFO_ENTRY_CNT_R {
|
||||
FIFO_ENTRY_CNT_R::new((self.bits & 0x3f) as u8)
|
||||
}
|
||||
}
|
||||
#[doc = "Status\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [status](index.html) module"]
|
||||
pub struct STATUS_SPEC;
|
||||
impl crate::RegisterSpec for STATUS_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [status::R](R) reader structure"]
|
||||
impl crate::Readable for STATUS_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets STATUS to value 0"]
|
||||
impl crate::Resettable for STATUS_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
856
va416xx/src/can0.rs
Normal file
856
va416xx/src/can0.rs
Normal file
@ -0,0 +1,856 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct RegisterBlock {
|
||||
#[doc = "0x00 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb0: crate::Reg<cnstat_cmb0::CNSTAT_CMB0_SPEC>,
|
||||
#[doc = "0x04 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb0: crate::Reg<tstp_cmb0::TSTP_CMB0_SPEC>,
|
||||
#[doc = "0x08 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb0: crate::Reg<data3_cmb0::DATA3_CMB0_SPEC>,
|
||||
#[doc = "0x0c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb0: crate::Reg<data2_cmb0::DATA2_CMB0_SPEC>,
|
||||
#[doc = "0x10 - CAN Frame Data Word 1"]
|
||||
pub data1_cmb0: crate::Reg<data1_cmb0::DATA1_CMB0_SPEC>,
|
||||
#[doc = "0x14 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb0: crate::Reg<data0_cmb0::DATA0_CMB0_SPEC>,
|
||||
#[doc = "0x18 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb0: crate::Reg<id0_cmb0::ID0_CMB0_SPEC>,
|
||||
#[doc = "0x1c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb0: crate::Reg<id1_cmb0::ID1_CMB0_SPEC>,
|
||||
#[doc = "0x20 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb1: crate::Reg<cnstat_cmb1::CNSTAT_CMB1_SPEC>,
|
||||
#[doc = "0x24 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb1: crate::Reg<tstp_cmb1::TSTP_CMB1_SPEC>,
|
||||
#[doc = "0x28 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb1: crate::Reg<data3_cmb1::DATA3_CMB1_SPEC>,
|
||||
#[doc = "0x2c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb1: crate::Reg<data2_cmb1::DATA2_CMB1_SPEC>,
|
||||
#[doc = "0x30 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb1: crate::Reg<data1_cmb1::DATA1_CMB1_SPEC>,
|
||||
#[doc = "0x34 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb1: crate::Reg<data0_cmb1::DATA0_CMB1_SPEC>,
|
||||
#[doc = "0x38 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb1: crate::Reg<id0_cmb1::ID0_CMB1_SPEC>,
|
||||
#[doc = "0x3c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb1: crate::Reg<id1_cmb1::ID1_CMB1_SPEC>,
|
||||
#[doc = "0x40 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb2: crate::Reg<cnstat_cmb2::CNSTAT_CMB2_SPEC>,
|
||||
#[doc = "0x44 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb2: crate::Reg<tstp_cmb2::TSTP_CMB2_SPEC>,
|
||||
#[doc = "0x48 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb2: crate::Reg<data3_cmb2::DATA3_CMB2_SPEC>,
|
||||
#[doc = "0x4c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb2: crate::Reg<data2_cmb2::DATA2_CMB2_SPEC>,
|
||||
#[doc = "0x50 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb2: crate::Reg<data1_cmb2::DATA1_CMB2_SPEC>,
|
||||
#[doc = "0x54 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb2: crate::Reg<data0_cmb2::DATA0_CMB2_SPEC>,
|
||||
#[doc = "0x58 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb2: crate::Reg<id0_cmb2::ID0_CMB2_SPEC>,
|
||||
#[doc = "0x5c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb2: crate::Reg<id1_cmb2::ID1_CMB2_SPEC>,
|
||||
#[doc = "0x60 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb3: crate::Reg<cnstat_cmb3::CNSTAT_CMB3_SPEC>,
|
||||
#[doc = "0x64 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb3: crate::Reg<tstp_cmb3::TSTP_CMB3_SPEC>,
|
||||
#[doc = "0x68 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb3: crate::Reg<data3_cmb3::DATA3_CMB3_SPEC>,
|
||||
#[doc = "0x6c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb3: crate::Reg<data2_cmb3::DATA2_CMB3_SPEC>,
|
||||
#[doc = "0x70 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb3: crate::Reg<data1_cmb3::DATA1_CMB3_SPEC>,
|
||||
#[doc = "0x74 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb3: crate::Reg<data0_cmb3::DATA0_CMB3_SPEC>,
|
||||
#[doc = "0x78 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb3: crate::Reg<id0_cmb3::ID0_CMB3_SPEC>,
|
||||
#[doc = "0x7c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb3: crate::Reg<id1_cmb3::ID1_CMB3_SPEC>,
|
||||
#[doc = "0x80 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb4: crate::Reg<cnstat_cmb4::CNSTAT_CMB4_SPEC>,
|
||||
#[doc = "0x84 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb4: crate::Reg<tstp_cmb4::TSTP_CMB4_SPEC>,
|
||||
#[doc = "0x88 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb4: crate::Reg<data3_cmb4::DATA3_CMB4_SPEC>,
|
||||
#[doc = "0x8c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb4: crate::Reg<data2_cmb4::DATA2_CMB4_SPEC>,
|
||||
#[doc = "0x90 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb4: crate::Reg<data1_cmb4::DATA1_CMB4_SPEC>,
|
||||
#[doc = "0x94 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb4: crate::Reg<data0_cmb4::DATA0_CMB4_SPEC>,
|
||||
#[doc = "0x98 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb4: crate::Reg<id0_cmb4::ID0_CMB4_SPEC>,
|
||||
#[doc = "0x9c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb4: crate::Reg<id1_cmb4::ID1_CMB4_SPEC>,
|
||||
#[doc = "0xa0 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb5: crate::Reg<cnstat_cmb5::CNSTAT_CMB5_SPEC>,
|
||||
#[doc = "0xa4 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb5: crate::Reg<tstp_cmb5::TSTP_CMB5_SPEC>,
|
||||
#[doc = "0xa8 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb5: crate::Reg<data3_cmb5::DATA3_CMB5_SPEC>,
|
||||
#[doc = "0xac - CAN Frame Data Word 2"]
|
||||
pub data2_cmb5: crate::Reg<data2_cmb5::DATA2_CMB5_SPEC>,
|
||||
#[doc = "0xb0 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb5: crate::Reg<data1_cmb5::DATA1_CMB5_SPEC>,
|
||||
#[doc = "0xb4 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb5: crate::Reg<data0_cmb5::DATA0_CMB5_SPEC>,
|
||||
#[doc = "0xb8 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb5: crate::Reg<id0_cmb5::ID0_CMB5_SPEC>,
|
||||
#[doc = "0xbc - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb5: crate::Reg<id1_cmb5::ID1_CMB5_SPEC>,
|
||||
#[doc = "0xc0 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb6: crate::Reg<cnstat_cmb6::CNSTAT_CMB6_SPEC>,
|
||||
#[doc = "0xc4 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb6: crate::Reg<tstp_cmb6::TSTP_CMB6_SPEC>,
|
||||
#[doc = "0xc8 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb6: crate::Reg<data3_cmb6::DATA3_CMB6_SPEC>,
|
||||
#[doc = "0xcc - CAN Frame Data Word 2"]
|
||||
pub data2_cmb6: crate::Reg<data2_cmb6::DATA2_CMB6_SPEC>,
|
||||
#[doc = "0xd0 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb6: crate::Reg<data1_cmb6::DATA1_CMB6_SPEC>,
|
||||
#[doc = "0xd4 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb6: crate::Reg<data0_cmb6::DATA0_CMB6_SPEC>,
|
||||
#[doc = "0xd8 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb6: crate::Reg<id0_cmb6::ID0_CMB6_SPEC>,
|
||||
#[doc = "0xdc - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb6: crate::Reg<id1_cmb6::ID1_CMB6_SPEC>,
|
||||
#[doc = "0xe0 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb7: crate::Reg<cnstat_cmb7::CNSTAT_CMB7_SPEC>,
|
||||
#[doc = "0xe4 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb7: crate::Reg<tstp_cmb7::TSTP_CMB7_SPEC>,
|
||||
#[doc = "0xe8 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb7: crate::Reg<data3_cmb7::DATA3_CMB7_SPEC>,
|
||||
#[doc = "0xec - CAN Frame Data Word 2"]
|
||||
pub data2_cmb7: crate::Reg<data2_cmb7::DATA2_CMB7_SPEC>,
|
||||
#[doc = "0xf0 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb7: crate::Reg<data1_cmb7::DATA1_CMB7_SPEC>,
|
||||
#[doc = "0xf4 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb7: crate::Reg<data0_cmb7::DATA0_CMB7_SPEC>,
|
||||
#[doc = "0xf8 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb7: crate::Reg<id0_cmb7::ID0_CMB7_SPEC>,
|
||||
#[doc = "0xfc - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb7: crate::Reg<id1_cmb7::ID1_CMB7_SPEC>,
|
||||
#[doc = "0x100 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb8: crate::Reg<cnstat_cmb8::CNSTAT_CMB8_SPEC>,
|
||||
#[doc = "0x104 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb8: crate::Reg<tstp_cmb8::TSTP_CMB8_SPEC>,
|
||||
#[doc = "0x108 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb8: crate::Reg<data3_cmb8::DATA3_CMB8_SPEC>,
|
||||
#[doc = "0x10c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb8: crate::Reg<data2_cmb8::DATA2_CMB8_SPEC>,
|
||||
#[doc = "0x110 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb8: crate::Reg<data1_cmb8::DATA1_CMB8_SPEC>,
|
||||
#[doc = "0x114 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb8: crate::Reg<data0_cmb8::DATA0_CMB8_SPEC>,
|
||||
#[doc = "0x118 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb8: crate::Reg<id0_cmb8::ID0_CMB8_SPEC>,
|
||||
#[doc = "0x11c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb8: crate::Reg<id1_cmb8::ID1_CMB8_SPEC>,
|
||||
#[doc = "0x120 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb9: crate::Reg<cnstat_cmb9::CNSTAT_CMB9_SPEC>,
|
||||
#[doc = "0x124 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb9: crate::Reg<tstp_cmb9::TSTP_CMB9_SPEC>,
|
||||
#[doc = "0x128 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb9: crate::Reg<data3_cmb9::DATA3_CMB9_SPEC>,
|
||||
#[doc = "0x12c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb9: crate::Reg<data2_cmb9::DATA2_CMB9_SPEC>,
|
||||
#[doc = "0x130 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb9: crate::Reg<data1_cmb9::DATA1_CMB9_SPEC>,
|
||||
#[doc = "0x134 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb9: crate::Reg<data0_cmb9::DATA0_CMB9_SPEC>,
|
||||
#[doc = "0x138 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb9: crate::Reg<id0_cmb9::ID0_CMB9_SPEC>,
|
||||
#[doc = "0x13c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb9: crate::Reg<id1_cmb9::ID1_CMB9_SPEC>,
|
||||
#[doc = "0x140 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb10: crate::Reg<cnstat_cmb10::CNSTAT_CMB10_SPEC>,
|
||||
#[doc = "0x144 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb10: crate::Reg<tstp_cmb10::TSTP_CMB10_SPEC>,
|
||||
#[doc = "0x148 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb10: crate::Reg<data3_cmb10::DATA3_CMB10_SPEC>,
|
||||
#[doc = "0x14c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb10: crate::Reg<data2_cmb10::DATA2_CMB10_SPEC>,
|
||||
#[doc = "0x150 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb10: crate::Reg<data1_cmb10::DATA1_CMB10_SPEC>,
|
||||
#[doc = "0x154 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb10: crate::Reg<data0_cmb10::DATA0_CMB10_SPEC>,
|
||||
#[doc = "0x158 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb10: crate::Reg<id0_cmb10::ID0_CMB10_SPEC>,
|
||||
#[doc = "0x15c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb10: crate::Reg<id1_cmb10::ID1_CMB10_SPEC>,
|
||||
#[doc = "0x160 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb11: crate::Reg<cnstat_cmb11::CNSTAT_CMB11_SPEC>,
|
||||
#[doc = "0x164 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb11: crate::Reg<tstp_cmb11::TSTP_CMB11_SPEC>,
|
||||
#[doc = "0x168 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb11: crate::Reg<data3_cmb11::DATA3_CMB11_SPEC>,
|
||||
#[doc = "0x16c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb11: crate::Reg<data2_cmb11::DATA2_CMB11_SPEC>,
|
||||
#[doc = "0x170 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb11: crate::Reg<data1_cmb11::DATA1_CMB11_SPEC>,
|
||||
#[doc = "0x174 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb11: crate::Reg<data0_cmb11::DATA0_CMB11_SPEC>,
|
||||
#[doc = "0x178 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb11: crate::Reg<id0_cmb11::ID0_CMB11_SPEC>,
|
||||
#[doc = "0x17c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb11: crate::Reg<id1_cmb11::ID1_CMB11_SPEC>,
|
||||
#[doc = "0x180 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb12: crate::Reg<cnstat_cmb12::CNSTAT_CMB12_SPEC>,
|
||||
#[doc = "0x184 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb12: crate::Reg<tstp_cmb12::TSTP_CMB12_SPEC>,
|
||||
#[doc = "0x188 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb12: crate::Reg<data3_cmb12::DATA3_CMB12_SPEC>,
|
||||
#[doc = "0x18c - CAN Frame Data Word 2"]
|
||||
pub data2_cmb12: crate::Reg<data2_cmb12::DATA2_CMB12_SPEC>,
|
||||
#[doc = "0x190 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb12: crate::Reg<data1_cmb12::DATA1_CMB12_SPEC>,
|
||||
#[doc = "0x194 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb12: crate::Reg<data0_cmb12::DATA0_CMB12_SPEC>,
|
||||
#[doc = "0x198 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb12: crate::Reg<id0_cmb12::ID0_CMB12_SPEC>,
|
||||
#[doc = "0x19c - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb12: crate::Reg<id1_cmb12::ID1_CMB12_SPEC>,
|
||||
#[doc = "0x1a0 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb13: crate::Reg<cnstat_cmb13::CNSTAT_CMB13_SPEC>,
|
||||
#[doc = "0x1a4 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb13: crate::Reg<tstp_cmb13::TSTP_CMB13_SPEC>,
|
||||
#[doc = "0x1a8 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb13: crate::Reg<data3_cmb13::DATA3_CMB13_SPEC>,
|
||||
#[doc = "0x1ac - CAN Frame Data Word 2"]
|
||||
pub data2_cmb13: crate::Reg<data2_cmb13::DATA2_CMB13_SPEC>,
|
||||
#[doc = "0x1b0 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb13: crate::Reg<data1_cmb13::DATA1_CMB13_SPEC>,
|
||||
#[doc = "0x1b4 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb13: crate::Reg<data0_cmb13::DATA0_CMB13_SPEC>,
|
||||
#[doc = "0x1b8 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb13: crate::Reg<id0_cmb13::ID0_CMB13_SPEC>,
|
||||
#[doc = "0x1bc - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb13: crate::Reg<id1_cmb13::ID1_CMB13_SPEC>,
|
||||
#[doc = "0x1c0 - Buffer Status / Control Register"]
|
||||
pub cnstat_cmb14: crate::Reg<cnstat_cmb14::CNSTAT_CMB14_SPEC>,
|
||||
#[doc = "0x1c4 - CAN Frame Timestamp"]
|
||||
pub tstp_cmb14: crate::Reg<tstp_cmb14::TSTP_CMB14_SPEC>,
|
||||
#[doc = "0x1c8 - CAN Frame Data Word 3"]
|
||||
pub data3_cmb14: crate::Reg<data3_cmb14::DATA3_CMB14_SPEC>,
|
||||
#[doc = "0x1cc - CAN Frame Data Word 2"]
|
||||
pub data2_cmb14: crate::Reg<data2_cmb14::DATA2_CMB14_SPEC>,
|
||||
#[doc = "0x1d0 - CAN Frame Data Word 2"]
|
||||
pub data1_cmb14: crate::Reg<data1_cmb14::DATA1_CMB14_SPEC>,
|
||||
#[doc = "0x1d4 - CAN Frame Data Word 0"]
|
||||
pub data0_cmb14: crate::Reg<data0_cmb14::DATA0_CMB14_SPEC>,
|
||||
#[doc = "0x1d8 - CAN Frame Identifier Word 0"]
|
||||
pub id0_cmb14: crate::Reg<id0_cmb14::ID0_CMB14_SPEC>,
|
||||
#[doc = "0x1dc - CAN Frame Identifier Word 1"]
|
||||
pub id1_cmb14: crate::Reg<id1_cmb14::ID1_CMB14_SPEC>,
|
||||
#[doc = "0x1e0 - Buffer Status / Control Register"]
|
||||
pub cnstat_hcmb: crate::Reg<cnstat_hcmb::CNSTAT_HCMB_SPEC>,
|
||||
#[doc = "0x1e4 - CAN Frame Timestamp"]
|
||||
pub tstp_hcmb: crate::Reg<tstp_hcmb::TSTP_HCMB_SPEC>,
|
||||
#[doc = "0x1e8 - CAN Frame Data Word 3"]
|
||||
pub data3_hcmb: crate::Reg<data3_hcmb::DATA3_HCMB_SPEC>,
|
||||
#[doc = "0x1ec - CAN Frame Data Word 2"]
|
||||
pub data2_hcmb: crate::Reg<data2_hcmb::DATA2_HCMB_SPEC>,
|
||||
#[doc = "0x1f0 - CAN Frame Data Word 2"]
|
||||
pub data1_hcmb: crate::Reg<data1_hcmb::DATA1_HCMB_SPEC>,
|
||||
#[doc = "0x1f4 - CAN Frame Data Word 0"]
|
||||
pub data0_hcmb: crate::Reg<data0_hcmb::DATA0_HCMB_SPEC>,
|
||||
#[doc = "0x1f8 - CAN Frame Identifier Word 0"]
|
||||
pub id0_hcmb: crate::Reg<id0_hcmb::ID0_HCMB_SPEC>,
|
||||
#[doc = "0x1fc - CAN Frame Identifier Word 1"]
|
||||
pub id1_hcmb: crate::Reg<id1_hcmb::ID1_HCMB_SPEC>,
|
||||
#[doc = "0x200 - CAN Global Configuration Register"]
|
||||
pub cgcr: crate::Reg<cgcr::CGCR_SPEC>,
|
||||
#[doc = "0x204 - CAN Timing Register"]
|
||||
pub ctim: crate::Reg<ctim::CTIM_SPEC>,
|
||||
#[doc = "0x208 - CAN Global Mask Extension"]
|
||||
pub gmskx: crate::Reg<gmskx::GMSKX_SPEC>,
|
||||
#[doc = "0x20c - CAN Global Mask Base"]
|
||||
pub gmskb: crate::Reg<gmskb::GMSKB_SPEC>,
|
||||
#[doc = "0x210 - CAN Basic Mask Extension"]
|
||||
pub bmskx: crate::Reg<bmskx::BMSKX_SPEC>,
|
||||
#[doc = "0x214 - CAN Basic Mask Base"]
|
||||
pub bmskb: crate::Reg<bmskb::BMSKB_SPEC>,
|
||||
#[doc = "0x218 - CAN Interrupt Enable Register"]
|
||||
pub cien: crate::Reg<cien::CIEN_SPEC>,
|
||||
#[doc = "0x21c - CAN Interrupt Pending Register"]
|
||||
pub cipnd: crate::Reg<cipnd::CIPND_SPEC>,
|
||||
#[doc = "0x220 - CAN Interrupt Clear Register"]
|
||||
pub ciclr: crate::Reg<ciclr::CICLR_SPEC>,
|
||||
#[doc = "0x224 - CAN Interrupt Code Enable Register"]
|
||||
pub cicen: crate::Reg<cicen::CICEN_SPEC>,
|
||||
#[doc = "0x228 - CAN Status Pending Register"]
|
||||
pub cstpnd: crate::Reg<cstpnd::CSTPND_SPEC>,
|
||||
#[doc = "0x22c - CAN Error Counter Register"]
|
||||
pub canec: crate::Reg<canec::CANEC_SPEC>,
|
||||
#[doc = "0x230 - CAN Error Diagnostic Register"]
|
||||
pub cediag: crate::Reg<cediag::CEDIAG_SPEC>,
|
||||
#[doc = "0x234 - CAN Timer Register"]
|
||||
pub ctmr: crate::Reg<ctmr::CTMR_SPEC>,
|
||||
}
|
||||
#[doc = "CNSTAT_CMB0 register accessor: an alias for `Reg<CNSTAT_CMB0_SPEC>`"]
|
||||
pub type CNSTAT_CMB0 = crate::Reg<cnstat_cmb0::CNSTAT_CMB0_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb0;
|
||||
#[doc = "TSTP_CMB0 register accessor: an alias for `Reg<TSTP_CMB0_SPEC>`"]
|
||||
pub type TSTP_CMB0 = crate::Reg<tstp_cmb0::TSTP_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb0;
|
||||
#[doc = "DATA3_CMB0 register accessor: an alias for `Reg<DATA3_CMB0_SPEC>`"]
|
||||
pub type DATA3_CMB0 = crate::Reg<data3_cmb0::DATA3_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb0;
|
||||
#[doc = "DATA2_CMB0 register accessor: an alias for `Reg<DATA2_CMB0_SPEC>`"]
|
||||
pub type DATA2_CMB0 = crate::Reg<data2_cmb0::DATA2_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb0;
|
||||
#[doc = "DATA1_CMB0 register accessor: an alias for `Reg<DATA1_CMB0_SPEC>`"]
|
||||
pub type DATA1_CMB0 = crate::Reg<data1_cmb0::DATA1_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 1"]
|
||||
pub mod data1_cmb0;
|
||||
#[doc = "DATA0_CMB0 register accessor: an alias for `Reg<DATA0_CMB0_SPEC>`"]
|
||||
pub type DATA0_CMB0 = crate::Reg<data0_cmb0::DATA0_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb0;
|
||||
#[doc = "ID0_CMB0 register accessor: an alias for `Reg<ID0_CMB0_SPEC>`"]
|
||||
pub type ID0_CMB0 = crate::Reg<id0_cmb0::ID0_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb0;
|
||||
#[doc = "ID1_CMB0 register accessor: an alias for `Reg<ID1_CMB0_SPEC>`"]
|
||||
pub type ID1_CMB0 = crate::Reg<id1_cmb0::ID1_CMB0_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb0;
|
||||
#[doc = "CNSTAT_CMB1 register accessor: an alias for `Reg<CNSTAT_CMB1_SPEC>`"]
|
||||
pub type CNSTAT_CMB1 = crate::Reg<cnstat_cmb1::CNSTAT_CMB1_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb1;
|
||||
#[doc = "TSTP_CMB1 register accessor: an alias for `Reg<TSTP_CMB1_SPEC>`"]
|
||||
pub type TSTP_CMB1 = crate::Reg<tstp_cmb1::TSTP_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb1;
|
||||
#[doc = "DATA3_CMB1 register accessor: an alias for `Reg<DATA3_CMB1_SPEC>`"]
|
||||
pub type DATA3_CMB1 = crate::Reg<data3_cmb1::DATA3_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb1;
|
||||
#[doc = "DATA2_CMB1 register accessor: an alias for `Reg<DATA2_CMB1_SPEC>`"]
|
||||
pub type DATA2_CMB1 = crate::Reg<data2_cmb1::DATA2_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb1;
|
||||
#[doc = "DATA1_CMB1 register accessor: an alias for `Reg<DATA1_CMB1_SPEC>`"]
|
||||
pub type DATA1_CMB1 = crate::Reg<data1_cmb1::DATA1_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb1;
|
||||
#[doc = "DATA0_CMB1 register accessor: an alias for `Reg<DATA0_CMB1_SPEC>`"]
|
||||
pub type DATA0_CMB1 = crate::Reg<data0_cmb1::DATA0_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb1;
|
||||
#[doc = "ID0_CMB1 register accessor: an alias for `Reg<ID0_CMB1_SPEC>`"]
|
||||
pub type ID0_CMB1 = crate::Reg<id0_cmb1::ID0_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb1;
|
||||
#[doc = "ID1_CMB1 register accessor: an alias for `Reg<ID1_CMB1_SPEC>`"]
|
||||
pub type ID1_CMB1 = crate::Reg<id1_cmb1::ID1_CMB1_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb1;
|
||||
#[doc = "CNSTAT_CMB2 register accessor: an alias for `Reg<CNSTAT_CMB2_SPEC>`"]
|
||||
pub type CNSTAT_CMB2 = crate::Reg<cnstat_cmb2::CNSTAT_CMB2_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb2;
|
||||
#[doc = "TSTP_CMB2 register accessor: an alias for `Reg<TSTP_CMB2_SPEC>`"]
|
||||
pub type TSTP_CMB2 = crate::Reg<tstp_cmb2::TSTP_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb2;
|
||||
#[doc = "DATA3_CMB2 register accessor: an alias for `Reg<DATA3_CMB2_SPEC>`"]
|
||||
pub type DATA3_CMB2 = crate::Reg<data3_cmb2::DATA3_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb2;
|
||||
#[doc = "DATA2_CMB2 register accessor: an alias for `Reg<DATA2_CMB2_SPEC>`"]
|
||||
pub type DATA2_CMB2 = crate::Reg<data2_cmb2::DATA2_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb2;
|
||||
#[doc = "DATA1_CMB2 register accessor: an alias for `Reg<DATA1_CMB2_SPEC>`"]
|
||||
pub type DATA1_CMB2 = crate::Reg<data1_cmb2::DATA1_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb2;
|
||||
#[doc = "DATA0_CMB2 register accessor: an alias for `Reg<DATA0_CMB2_SPEC>`"]
|
||||
pub type DATA0_CMB2 = crate::Reg<data0_cmb2::DATA0_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb2;
|
||||
#[doc = "ID0_CMB2 register accessor: an alias for `Reg<ID0_CMB2_SPEC>`"]
|
||||
pub type ID0_CMB2 = crate::Reg<id0_cmb2::ID0_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb2;
|
||||
#[doc = "ID1_CMB2 register accessor: an alias for `Reg<ID1_CMB2_SPEC>`"]
|
||||
pub type ID1_CMB2 = crate::Reg<id1_cmb2::ID1_CMB2_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb2;
|
||||
#[doc = "CNSTAT_CMB3 register accessor: an alias for `Reg<CNSTAT_CMB3_SPEC>`"]
|
||||
pub type CNSTAT_CMB3 = crate::Reg<cnstat_cmb3::CNSTAT_CMB3_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb3;
|
||||
#[doc = "TSTP_CMB3 register accessor: an alias for `Reg<TSTP_CMB3_SPEC>`"]
|
||||
pub type TSTP_CMB3 = crate::Reg<tstp_cmb3::TSTP_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb3;
|
||||
#[doc = "DATA3_CMB3 register accessor: an alias for `Reg<DATA3_CMB3_SPEC>`"]
|
||||
pub type DATA3_CMB3 = crate::Reg<data3_cmb3::DATA3_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb3;
|
||||
#[doc = "DATA2_CMB3 register accessor: an alias for `Reg<DATA2_CMB3_SPEC>`"]
|
||||
pub type DATA2_CMB3 = crate::Reg<data2_cmb3::DATA2_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb3;
|
||||
#[doc = "DATA1_CMB3 register accessor: an alias for `Reg<DATA1_CMB3_SPEC>`"]
|
||||
pub type DATA1_CMB3 = crate::Reg<data1_cmb3::DATA1_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb3;
|
||||
#[doc = "DATA0_CMB3 register accessor: an alias for `Reg<DATA0_CMB3_SPEC>`"]
|
||||
pub type DATA0_CMB3 = crate::Reg<data0_cmb3::DATA0_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb3;
|
||||
#[doc = "ID0_CMB3 register accessor: an alias for `Reg<ID0_CMB3_SPEC>`"]
|
||||
pub type ID0_CMB3 = crate::Reg<id0_cmb3::ID0_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb3;
|
||||
#[doc = "ID1_CMB3 register accessor: an alias for `Reg<ID1_CMB3_SPEC>`"]
|
||||
pub type ID1_CMB3 = crate::Reg<id1_cmb3::ID1_CMB3_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb3;
|
||||
#[doc = "CNSTAT_CMB4 register accessor: an alias for `Reg<CNSTAT_CMB4_SPEC>`"]
|
||||
pub type CNSTAT_CMB4 = crate::Reg<cnstat_cmb4::CNSTAT_CMB4_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb4;
|
||||
#[doc = "TSTP_CMB4 register accessor: an alias for `Reg<TSTP_CMB4_SPEC>`"]
|
||||
pub type TSTP_CMB4 = crate::Reg<tstp_cmb4::TSTP_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb4;
|
||||
#[doc = "DATA3_CMB4 register accessor: an alias for `Reg<DATA3_CMB4_SPEC>`"]
|
||||
pub type DATA3_CMB4 = crate::Reg<data3_cmb4::DATA3_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb4;
|
||||
#[doc = "DATA2_CMB4 register accessor: an alias for `Reg<DATA2_CMB4_SPEC>`"]
|
||||
pub type DATA2_CMB4 = crate::Reg<data2_cmb4::DATA2_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb4;
|
||||
#[doc = "DATA1_CMB4 register accessor: an alias for `Reg<DATA1_CMB4_SPEC>`"]
|
||||
pub type DATA1_CMB4 = crate::Reg<data1_cmb4::DATA1_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb4;
|
||||
#[doc = "DATA0_CMB4 register accessor: an alias for `Reg<DATA0_CMB4_SPEC>`"]
|
||||
pub type DATA0_CMB4 = crate::Reg<data0_cmb4::DATA0_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb4;
|
||||
#[doc = "ID0_CMB4 register accessor: an alias for `Reg<ID0_CMB4_SPEC>`"]
|
||||
pub type ID0_CMB4 = crate::Reg<id0_cmb4::ID0_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb4;
|
||||
#[doc = "ID1_CMB4 register accessor: an alias for `Reg<ID1_CMB4_SPEC>`"]
|
||||
pub type ID1_CMB4 = crate::Reg<id1_cmb4::ID1_CMB4_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb4;
|
||||
#[doc = "CNSTAT_CMB5 register accessor: an alias for `Reg<CNSTAT_CMB5_SPEC>`"]
|
||||
pub type CNSTAT_CMB5 = crate::Reg<cnstat_cmb5::CNSTAT_CMB5_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb5;
|
||||
#[doc = "TSTP_CMB5 register accessor: an alias for `Reg<TSTP_CMB5_SPEC>`"]
|
||||
pub type TSTP_CMB5 = crate::Reg<tstp_cmb5::TSTP_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb5;
|
||||
#[doc = "DATA3_CMB5 register accessor: an alias for `Reg<DATA3_CMB5_SPEC>`"]
|
||||
pub type DATA3_CMB5 = crate::Reg<data3_cmb5::DATA3_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb5;
|
||||
#[doc = "DATA2_CMB5 register accessor: an alias for `Reg<DATA2_CMB5_SPEC>`"]
|
||||
pub type DATA2_CMB5 = crate::Reg<data2_cmb5::DATA2_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb5;
|
||||
#[doc = "DATA1_CMB5 register accessor: an alias for `Reg<DATA1_CMB5_SPEC>`"]
|
||||
pub type DATA1_CMB5 = crate::Reg<data1_cmb5::DATA1_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb5;
|
||||
#[doc = "DATA0_CMB5 register accessor: an alias for `Reg<DATA0_CMB5_SPEC>`"]
|
||||
pub type DATA0_CMB5 = crate::Reg<data0_cmb5::DATA0_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb5;
|
||||
#[doc = "ID0_CMB5 register accessor: an alias for `Reg<ID0_CMB5_SPEC>`"]
|
||||
pub type ID0_CMB5 = crate::Reg<id0_cmb5::ID0_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb5;
|
||||
#[doc = "ID1_CMB5 register accessor: an alias for `Reg<ID1_CMB5_SPEC>`"]
|
||||
pub type ID1_CMB5 = crate::Reg<id1_cmb5::ID1_CMB5_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb5;
|
||||
#[doc = "CNSTAT_CMB6 register accessor: an alias for `Reg<CNSTAT_CMB6_SPEC>`"]
|
||||
pub type CNSTAT_CMB6 = crate::Reg<cnstat_cmb6::CNSTAT_CMB6_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb6;
|
||||
#[doc = "TSTP_CMB6 register accessor: an alias for `Reg<TSTP_CMB6_SPEC>`"]
|
||||
pub type TSTP_CMB6 = crate::Reg<tstp_cmb6::TSTP_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb6;
|
||||
#[doc = "DATA3_CMB6 register accessor: an alias for `Reg<DATA3_CMB6_SPEC>`"]
|
||||
pub type DATA3_CMB6 = crate::Reg<data3_cmb6::DATA3_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb6;
|
||||
#[doc = "DATA2_CMB6 register accessor: an alias for `Reg<DATA2_CMB6_SPEC>`"]
|
||||
pub type DATA2_CMB6 = crate::Reg<data2_cmb6::DATA2_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb6;
|
||||
#[doc = "DATA1_CMB6 register accessor: an alias for `Reg<DATA1_CMB6_SPEC>`"]
|
||||
pub type DATA1_CMB6 = crate::Reg<data1_cmb6::DATA1_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb6;
|
||||
#[doc = "DATA0_CMB6 register accessor: an alias for `Reg<DATA0_CMB6_SPEC>`"]
|
||||
pub type DATA0_CMB6 = crate::Reg<data0_cmb6::DATA0_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb6;
|
||||
#[doc = "ID0_CMB6 register accessor: an alias for `Reg<ID0_CMB6_SPEC>`"]
|
||||
pub type ID0_CMB6 = crate::Reg<id0_cmb6::ID0_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb6;
|
||||
#[doc = "ID1_CMB6 register accessor: an alias for `Reg<ID1_CMB6_SPEC>`"]
|
||||
pub type ID1_CMB6 = crate::Reg<id1_cmb6::ID1_CMB6_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb6;
|
||||
#[doc = "CNSTAT_CMB7 register accessor: an alias for `Reg<CNSTAT_CMB7_SPEC>`"]
|
||||
pub type CNSTAT_CMB7 = crate::Reg<cnstat_cmb7::CNSTAT_CMB7_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb7;
|
||||
#[doc = "TSTP_CMB7 register accessor: an alias for `Reg<TSTP_CMB7_SPEC>`"]
|
||||
pub type TSTP_CMB7 = crate::Reg<tstp_cmb7::TSTP_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb7;
|
||||
#[doc = "DATA3_CMB7 register accessor: an alias for `Reg<DATA3_CMB7_SPEC>`"]
|
||||
pub type DATA3_CMB7 = crate::Reg<data3_cmb7::DATA3_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb7;
|
||||
#[doc = "DATA2_CMB7 register accessor: an alias for `Reg<DATA2_CMB7_SPEC>`"]
|
||||
pub type DATA2_CMB7 = crate::Reg<data2_cmb7::DATA2_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb7;
|
||||
#[doc = "DATA1_CMB7 register accessor: an alias for `Reg<DATA1_CMB7_SPEC>`"]
|
||||
pub type DATA1_CMB7 = crate::Reg<data1_cmb7::DATA1_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb7;
|
||||
#[doc = "DATA0_CMB7 register accessor: an alias for `Reg<DATA0_CMB7_SPEC>`"]
|
||||
pub type DATA0_CMB7 = crate::Reg<data0_cmb7::DATA0_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb7;
|
||||
#[doc = "ID0_CMB7 register accessor: an alias for `Reg<ID0_CMB7_SPEC>`"]
|
||||
pub type ID0_CMB7 = crate::Reg<id0_cmb7::ID0_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb7;
|
||||
#[doc = "ID1_CMB7 register accessor: an alias for `Reg<ID1_CMB7_SPEC>`"]
|
||||
pub type ID1_CMB7 = crate::Reg<id1_cmb7::ID1_CMB7_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb7;
|
||||
#[doc = "CNSTAT_CMB8 register accessor: an alias for `Reg<CNSTAT_CMB8_SPEC>`"]
|
||||
pub type CNSTAT_CMB8 = crate::Reg<cnstat_cmb8::CNSTAT_CMB8_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb8;
|
||||
#[doc = "TSTP_CMB8 register accessor: an alias for `Reg<TSTP_CMB8_SPEC>`"]
|
||||
pub type TSTP_CMB8 = crate::Reg<tstp_cmb8::TSTP_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb8;
|
||||
#[doc = "DATA3_CMB8 register accessor: an alias for `Reg<DATA3_CMB8_SPEC>`"]
|
||||
pub type DATA3_CMB8 = crate::Reg<data3_cmb8::DATA3_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb8;
|
||||
#[doc = "DATA2_CMB8 register accessor: an alias for `Reg<DATA2_CMB8_SPEC>`"]
|
||||
pub type DATA2_CMB8 = crate::Reg<data2_cmb8::DATA2_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb8;
|
||||
#[doc = "DATA1_CMB8 register accessor: an alias for `Reg<DATA1_CMB8_SPEC>`"]
|
||||
pub type DATA1_CMB8 = crate::Reg<data1_cmb8::DATA1_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb8;
|
||||
#[doc = "DATA0_CMB8 register accessor: an alias for `Reg<DATA0_CMB8_SPEC>`"]
|
||||
pub type DATA0_CMB8 = crate::Reg<data0_cmb8::DATA0_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb8;
|
||||
#[doc = "ID0_CMB8 register accessor: an alias for `Reg<ID0_CMB8_SPEC>`"]
|
||||
pub type ID0_CMB8 = crate::Reg<id0_cmb8::ID0_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb8;
|
||||
#[doc = "ID1_CMB8 register accessor: an alias for `Reg<ID1_CMB8_SPEC>`"]
|
||||
pub type ID1_CMB8 = crate::Reg<id1_cmb8::ID1_CMB8_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb8;
|
||||
#[doc = "CNSTAT_CMB9 register accessor: an alias for `Reg<CNSTAT_CMB9_SPEC>`"]
|
||||
pub type CNSTAT_CMB9 = crate::Reg<cnstat_cmb9::CNSTAT_CMB9_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb9;
|
||||
#[doc = "TSTP_CMB9 register accessor: an alias for `Reg<TSTP_CMB9_SPEC>`"]
|
||||
pub type TSTP_CMB9 = crate::Reg<tstp_cmb9::TSTP_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb9;
|
||||
#[doc = "DATA3_CMB9 register accessor: an alias for `Reg<DATA3_CMB9_SPEC>`"]
|
||||
pub type DATA3_CMB9 = crate::Reg<data3_cmb9::DATA3_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb9;
|
||||
#[doc = "DATA2_CMB9 register accessor: an alias for `Reg<DATA2_CMB9_SPEC>`"]
|
||||
pub type DATA2_CMB9 = crate::Reg<data2_cmb9::DATA2_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb9;
|
||||
#[doc = "DATA1_CMB9 register accessor: an alias for `Reg<DATA1_CMB9_SPEC>`"]
|
||||
pub type DATA1_CMB9 = crate::Reg<data1_cmb9::DATA1_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb9;
|
||||
#[doc = "DATA0_CMB9 register accessor: an alias for `Reg<DATA0_CMB9_SPEC>`"]
|
||||
pub type DATA0_CMB9 = crate::Reg<data0_cmb9::DATA0_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb9;
|
||||
#[doc = "ID0_CMB9 register accessor: an alias for `Reg<ID0_CMB9_SPEC>`"]
|
||||
pub type ID0_CMB9 = crate::Reg<id0_cmb9::ID0_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb9;
|
||||
#[doc = "ID1_CMB9 register accessor: an alias for `Reg<ID1_CMB9_SPEC>`"]
|
||||
pub type ID1_CMB9 = crate::Reg<id1_cmb9::ID1_CMB9_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb9;
|
||||
#[doc = "CNSTAT_CMB10 register accessor: an alias for `Reg<CNSTAT_CMB10_SPEC>`"]
|
||||
pub type CNSTAT_CMB10 = crate::Reg<cnstat_cmb10::CNSTAT_CMB10_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb10;
|
||||
#[doc = "TSTP_CMB10 register accessor: an alias for `Reg<TSTP_CMB10_SPEC>`"]
|
||||
pub type TSTP_CMB10 = crate::Reg<tstp_cmb10::TSTP_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb10;
|
||||
#[doc = "DATA3_CMB10 register accessor: an alias for `Reg<DATA3_CMB10_SPEC>`"]
|
||||
pub type DATA3_CMB10 = crate::Reg<data3_cmb10::DATA3_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb10;
|
||||
#[doc = "DATA2_CMB10 register accessor: an alias for `Reg<DATA2_CMB10_SPEC>`"]
|
||||
pub type DATA2_CMB10 = crate::Reg<data2_cmb10::DATA2_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb10;
|
||||
#[doc = "DATA1_CMB10 register accessor: an alias for `Reg<DATA1_CMB10_SPEC>`"]
|
||||
pub type DATA1_CMB10 = crate::Reg<data1_cmb10::DATA1_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb10;
|
||||
#[doc = "DATA0_CMB10 register accessor: an alias for `Reg<DATA0_CMB10_SPEC>`"]
|
||||
pub type DATA0_CMB10 = crate::Reg<data0_cmb10::DATA0_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb10;
|
||||
#[doc = "ID0_CMB10 register accessor: an alias for `Reg<ID0_CMB10_SPEC>`"]
|
||||
pub type ID0_CMB10 = crate::Reg<id0_cmb10::ID0_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb10;
|
||||
#[doc = "ID1_CMB10 register accessor: an alias for `Reg<ID1_CMB10_SPEC>`"]
|
||||
pub type ID1_CMB10 = crate::Reg<id1_cmb10::ID1_CMB10_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb10;
|
||||
#[doc = "CNSTAT_CMB11 register accessor: an alias for `Reg<CNSTAT_CMB11_SPEC>`"]
|
||||
pub type CNSTAT_CMB11 = crate::Reg<cnstat_cmb11::CNSTAT_CMB11_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb11;
|
||||
#[doc = "TSTP_CMB11 register accessor: an alias for `Reg<TSTP_CMB11_SPEC>`"]
|
||||
pub type TSTP_CMB11 = crate::Reg<tstp_cmb11::TSTP_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb11;
|
||||
#[doc = "DATA3_CMB11 register accessor: an alias for `Reg<DATA3_CMB11_SPEC>`"]
|
||||
pub type DATA3_CMB11 = crate::Reg<data3_cmb11::DATA3_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb11;
|
||||
#[doc = "DATA2_CMB11 register accessor: an alias for `Reg<DATA2_CMB11_SPEC>`"]
|
||||
pub type DATA2_CMB11 = crate::Reg<data2_cmb11::DATA2_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb11;
|
||||
#[doc = "DATA1_CMB11 register accessor: an alias for `Reg<DATA1_CMB11_SPEC>`"]
|
||||
pub type DATA1_CMB11 = crate::Reg<data1_cmb11::DATA1_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb11;
|
||||
#[doc = "DATA0_CMB11 register accessor: an alias for `Reg<DATA0_CMB11_SPEC>`"]
|
||||
pub type DATA0_CMB11 = crate::Reg<data0_cmb11::DATA0_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb11;
|
||||
#[doc = "ID0_CMB11 register accessor: an alias for `Reg<ID0_CMB11_SPEC>`"]
|
||||
pub type ID0_CMB11 = crate::Reg<id0_cmb11::ID0_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb11;
|
||||
#[doc = "ID1_CMB11 register accessor: an alias for `Reg<ID1_CMB11_SPEC>`"]
|
||||
pub type ID1_CMB11 = crate::Reg<id1_cmb11::ID1_CMB11_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb11;
|
||||
#[doc = "CNSTAT_CMB12 register accessor: an alias for `Reg<CNSTAT_CMB12_SPEC>`"]
|
||||
pub type CNSTAT_CMB12 = crate::Reg<cnstat_cmb12::CNSTAT_CMB12_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb12;
|
||||
#[doc = "TSTP_CMB12 register accessor: an alias for `Reg<TSTP_CMB12_SPEC>`"]
|
||||
pub type TSTP_CMB12 = crate::Reg<tstp_cmb12::TSTP_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb12;
|
||||
#[doc = "DATA3_CMB12 register accessor: an alias for `Reg<DATA3_CMB12_SPEC>`"]
|
||||
pub type DATA3_CMB12 = crate::Reg<data3_cmb12::DATA3_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb12;
|
||||
#[doc = "DATA2_CMB12 register accessor: an alias for `Reg<DATA2_CMB12_SPEC>`"]
|
||||
pub type DATA2_CMB12 = crate::Reg<data2_cmb12::DATA2_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb12;
|
||||
#[doc = "DATA1_CMB12 register accessor: an alias for `Reg<DATA1_CMB12_SPEC>`"]
|
||||
pub type DATA1_CMB12 = crate::Reg<data1_cmb12::DATA1_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb12;
|
||||
#[doc = "DATA0_CMB12 register accessor: an alias for `Reg<DATA0_CMB12_SPEC>`"]
|
||||
pub type DATA0_CMB12 = crate::Reg<data0_cmb12::DATA0_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb12;
|
||||
#[doc = "ID0_CMB12 register accessor: an alias for `Reg<ID0_CMB12_SPEC>`"]
|
||||
pub type ID0_CMB12 = crate::Reg<id0_cmb12::ID0_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb12;
|
||||
#[doc = "ID1_CMB12 register accessor: an alias for `Reg<ID1_CMB12_SPEC>`"]
|
||||
pub type ID1_CMB12 = crate::Reg<id1_cmb12::ID1_CMB12_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb12;
|
||||
#[doc = "CNSTAT_CMB13 register accessor: an alias for `Reg<CNSTAT_CMB13_SPEC>`"]
|
||||
pub type CNSTAT_CMB13 = crate::Reg<cnstat_cmb13::CNSTAT_CMB13_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb13;
|
||||
#[doc = "TSTP_CMB13 register accessor: an alias for `Reg<TSTP_CMB13_SPEC>`"]
|
||||
pub type TSTP_CMB13 = crate::Reg<tstp_cmb13::TSTP_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb13;
|
||||
#[doc = "DATA3_CMB13 register accessor: an alias for `Reg<DATA3_CMB13_SPEC>`"]
|
||||
pub type DATA3_CMB13 = crate::Reg<data3_cmb13::DATA3_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb13;
|
||||
#[doc = "DATA2_CMB13 register accessor: an alias for `Reg<DATA2_CMB13_SPEC>`"]
|
||||
pub type DATA2_CMB13 = crate::Reg<data2_cmb13::DATA2_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb13;
|
||||
#[doc = "DATA1_CMB13 register accessor: an alias for `Reg<DATA1_CMB13_SPEC>`"]
|
||||
pub type DATA1_CMB13 = crate::Reg<data1_cmb13::DATA1_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb13;
|
||||
#[doc = "DATA0_CMB13 register accessor: an alias for `Reg<DATA0_CMB13_SPEC>`"]
|
||||
pub type DATA0_CMB13 = crate::Reg<data0_cmb13::DATA0_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb13;
|
||||
#[doc = "ID0_CMB13 register accessor: an alias for `Reg<ID0_CMB13_SPEC>`"]
|
||||
pub type ID0_CMB13 = crate::Reg<id0_cmb13::ID0_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb13;
|
||||
#[doc = "ID1_CMB13 register accessor: an alias for `Reg<ID1_CMB13_SPEC>`"]
|
||||
pub type ID1_CMB13 = crate::Reg<id1_cmb13::ID1_CMB13_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb13;
|
||||
#[doc = "CNSTAT_CMB14 register accessor: an alias for `Reg<CNSTAT_CMB14_SPEC>`"]
|
||||
pub type CNSTAT_CMB14 = crate::Reg<cnstat_cmb14::CNSTAT_CMB14_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_cmb14;
|
||||
#[doc = "TSTP_CMB14 register accessor: an alias for `Reg<TSTP_CMB14_SPEC>`"]
|
||||
pub type TSTP_CMB14 = crate::Reg<tstp_cmb14::TSTP_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_cmb14;
|
||||
#[doc = "DATA3_CMB14 register accessor: an alias for `Reg<DATA3_CMB14_SPEC>`"]
|
||||
pub type DATA3_CMB14 = crate::Reg<data3_cmb14::DATA3_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_cmb14;
|
||||
#[doc = "DATA2_CMB14 register accessor: an alias for `Reg<DATA2_CMB14_SPEC>`"]
|
||||
pub type DATA2_CMB14 = crate::Reg<data2_cmb14::DATA2_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_cmb14;
|
||||
#[doc = "DATA1_CMB14 register accessor: an alias for `Reg<DATA1_CMB14_SPEC>`"]
|
||||
pub type DATA1_CMB14 = crate::Reg<data1_cmb14::DATA1_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_cmb14;
|
||||
#[doc = "DATA0_CMB14 register accessor: an alias for `Reg<DATA0_CMB14_SPEC>`"]
|
||||
pub type DATA0_CMB14 = crate::Reg<data0_cmb14::DATA0_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_cmb14;
|
||||
#[doc = "ID0_CMB14 register accessor: an alias for `Reg<ID0_CMB14_SPEC>`"]
|
||||
pub type ID0_CMB14 = crate::Reg<id0_cmb14::ID0_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_cmb14;
|
||||
#[doc = "ID1_CMB14 register accessor: an alias for `Reg<ID1_CMB14_SPEC>`"]
|
||||
pub type ID1_CMB14 = crate::Reg<id1_cmb14::ID1_CMB14_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_cmb14;
|
||||
#[doc = "CNSTAT_HCMB register accessor: an alias for `Reg<CNSTAT_HCMB_SPEC>`"]
|
||||
pub type CNSTAT_HCMB = crate::Reg<cnstat_hcmb::CNSTAT_HCMB_SPEC>;
|
||||
#[doc = "Buffer Status / Control Register"]
|
||||
pub mod cnstat_hcmb;
|
||||
#[doc = "TSTP_HCMB register accessor: an alias for `Reg<TSTP_HCMB_SPEC>`"]
|
||||
pub type TSTP_HCMB = crate::Reg<tstp_hcmb::TSTP_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Timestamp"]
|
||||
pub mod tstp_hcmb;
|
||||
#[doc = "DATA3_HCMB register accessor: an alias for `Reg<DATA3_HCMB_SPEC>`"]
|
||||
pub type DATA3_HCMB = crate::Reg<data3_hcmb::DATA3_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 3"]
|
||||
pub mod data3_hcmb;
|
||||
#[doc = "DATA2_HCMB register accessor: an alias for `Reg<DATA2_HCMB_SPEC>`"]
|
||||
pub type DATA2_HCMB = crate::Reg<data2_hcmb::DATA2_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data2_hcmb;
|
||||
#[doc = "DATA1_HCMB register accessor: an alias for `Reg<DATA1_HCMB_SPEC>`"]
|
||||
pub type DATA1_HCMB = crate::Reg<data1_hcmb::DATA1_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 2"]
|
||||
pub mod data1_hcmb;
|
||||
#[doc = "DATA0_HCMB register accessor: an alias for `Reg<DATA0_HCMB_SPEC>`"]
|
||||
pub type DATA0_HCMB = crate::Reg<data0_hcmb::DATA0_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Data Word 0"]
|
||||
pub mod data0_hcmb;
|
||||
#[doc = "ID0_HCMB register accessor: an alias for `Reg<ID0_HCMB_SPEC>`"]
|
||||
pub type ID0_HCMB = crate::Reg<id0_hcmb::ID0_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 0"]
|
||||
pub mod id0_hcmb;
|
||||
#[doc = "ID1_HCMB register accessor: an alias for `Reg<ID1_HCMB_SPEC>`"]
|
||||
pub type ID1_HCMB = crate::Reg<id1_hcmb::ID1_HCMB_SPEC>;
|
||||
#[doc = "CAN Frame Identifier Word 1"]
|
||||
pub mod id1_hcmb;
|
||||
#[doc = "CGCR register accessor: an alias for `Reg<CGCR_SPEC>`"]
|
||||
pub type CGCR = crate::Reg<cgcr::CGCR_SPEC>;
|
||||
#[doc = "CAN Global Configuration Register"]
|
||||
pub mod cgcr;
|
||||
#[doc = "CTIM register accessor: an alias for `Reg<CTIM_SPEC>`"]
|
||||
pub type CTIM = crate::Reg<ctim::CTIM_SPEC>;
|
||||
#[doc = "CAN Timing Register"]
|
||||
pub mod ctim;
|
||||
#[doc = "GMSKX register accessor: an alias for `Reg<GMSKX_SPEC>`"]
|
||||
pub type GMSKX = crate::Reg<gmskx::GMSKX_SPEC>;
|
||||
#[doc = "CAN Global Mask Extension"]
|
||||
pub mod gmskx;
|
||||
#[doc = "GMSKB register accessor: an alias for `Reg<GMSKB_SPEC>`"]
|
||||
pub type GMSKB = crate::Reg<gmskb::GMSKB_SPEC>;
|
||||
#[doc = "CAN Global Mask Base"]
|
||||
pub mod gmskb;
|
||||
#[doc = "BMSKX register accessor: an alias for `Reg<BMSKX_SPEC>`"]
|
||||
pub type BMSKX = crate::Reg<bmskx::BMSKX_SPEC>;
|
||||
#[doc = "CAN Basic Mask Extension"]
|
||||
pub mod bmskx;
|
||||
#[doc = "BMSKB register accessor: an alias for `Reg<BMSKB_SPEC>`"]
|
||||
pub type BMSKB = crate::Reg<bmskb::BMSKB_SPEC>;
|
||||
#[doc = "CAN Basic Mask Base"]
|
||||
pub mod bmskb;
|
||||
#[doc = "CIEN register accessor: an alias for `Reg<CIEN_SPEC>`"]
|
||||
pub type CIEN = crate::Reg<cien::CIEN_SPEC>;
|
||||
#[doc = "CAN Interrupt Enable Register"]
|
||||
pub mod cien;
|
||||
#[doc = "CIPND register accessor: an alias for `Reg<CIPND_SPEC>`"]
|
||||
pub type CIPND = crate::Reg<cipnd::CIPND_SPEC>;
|
||||
#[doc = "CAN Interrupt Pending Register"]
|
||||
pub mod cipnd;
|
||||
#[doc = "CICLR register accessor: an alias for `Reg<CICLR_SPEC>`"]
|
||||
pub type CICLR = crate::Reg<ciclr::CICLR_SPEC>;
|
||||
#[doc = "CAN Interrupt Clear Register"]
|
||||
pub mod ciclr;
|
||||
#[doc = "CICEN register accessor: an alias for `Reg<CICEN_SPEC>`"]
|
||||
pub type CICEN = crate::Reg<cicen::CICEN_SPEC>;
|
||||
#[doc = "CAN Interrupt Code Enable Register"]
|
||||
pub mod cicen;
|
||||
#[doc = "CSTPND register accessor: an alias for `Reg<CSTPND_SPEC>`"]
|
||||
pub type CSTPND = crate::Reg<cstpnd::CSTPND_SPEC>;
|
||||
#[doc = "CAN Status Pending Register"]
|
||||
pub mod cstpnd;
|
||||
#[doc = "CANEC register accessor: an alias for `Reg<CANEC_SPEC>`"]
|
||||
pub type CANEC = crate::Reg<canec::CANEC_SPEC>;
|
||||
#[doc = "CAN Error Counter Register"]
|
||||
pub mod canec;
|
||||
#[doc = "CEDIAG register accessor: an alias for `Reg<CEDIAG_SPEC>`"]
|
||||
pub type CEDIAG = crate::Reg<cediag::CEDIAG_SPEC>;
|
||||
#[doc = "CAN Error Diagnostic Register"]
|
||||
pub mod cediag;
|
||||
#[doc = "CTMR register accessor: an alias for `Reg<CTMR_SPEC>`"]
|
||||
pub type CTMR = crate::Reg<ctmr::CTMR_SPEC>;
|
||||
#[doc = "CAN Timer Register"]
|
||||
pub mod ctmr;
|
254
va416xx/src/can0/bmskb.rs
Normal file
254
va416xx/src/can0/bmskb.rs
Normal file
@ -0,0 +1,254 @@
|
||||
#[doc = "Register `BMSKB` reader"]
|
||||
pub struct R(crate::R<BMSKB_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<BMSKB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<BMSKB_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<BMSKB_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `BMSKB` writer"]
|
||||
pub struct W(crate::W<BMSKB_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<BMSKB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<BMSKB_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<BMSKB_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BM1` reader - BM\\[28:18\\]
|
||||
- ID\\[10:0\\]
|
||||
in standard, ID\\[28:18\\]
|
||||
in extended"]
|
||||
pub struct BM1_R(crate::FieldReader<u16, u16>);
|
||||
impl BM1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
BM1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BM1_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BM1` writer - BM\\[28:18\\]
|
||||
- ID\\[10:0\\]
|
||||
in standard, ID\\[28:18\\]
|
||||
in extended"]
|
||||
pub struct BM1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BM1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x07ff << 5)) | ((value as u32 & 0x07ff) << 5);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RTR` reader - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
|
||||
pub struct RTR_R(crate::FieldReader<bool, bool>);
|
||||
impl RTR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
RTR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for RTR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RTR` writer - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
|
||||
pub struct RTR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> RTR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IDE` reader - Identifier Extension Bit"]
|
||||
pub struct IDE_R(crate::FieldReader<bool, bool>);
|
||||
impl IDE_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
IDE_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for IDE_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IDE` writer - Identifier Extension Bit"]
|
||||
pub struct IDE_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> IDE_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BM0` reader - BM\\[17:15\\]
|
||||
- Unused in standard, ID\\[17:15\\]
|
||||
in extended"]
|
||||
pub struct BM0_R(crate::FieldReader<u8, u8>);
|
||||
impl BM0_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BM0_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BM0_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BM0` writer - BM\\[17:15\\]
|
||||
- Unused in standard, ID\\[17:15\\]
|
||||
in extended"]
|
||||
pub struct BM0_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BM0_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x07) | (value as u32 & 0x07);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 5:15 - BM\\[28:18\\]
|
||||
- ID\\[10:0\\]
|
||||
in standard, ID\\[28:18\\]
|
||||
in extended"]
|
||||
#[inline(always)]
|
||||
pub fn bm1(&self) -> BM1_R {
|
||||
BM1_R::new(((self.bits >> 5) & 0x07ff) as u16)
|
||||
}
|
||||
#[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
|
||||
#[inline(always)]
|
||||
pub fn rtr(&self) -> RTR_R {
|
||||
RTR_R::new(((self.bits >> 4) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Identifier Extension Bit"]
|
||||
#[inline(always)]
|
||||
pub fn ide(&self) -> IDE_R {
|
||||
IDE_R::new(((self.bits >> 3) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:2 - BM\\[17:15\\]
|
||||
- Unused in standard, ID\\[17:15\\]
|
||||
in extended"]
|
||||
#[inline(always)]
|
||||
pub fn bm0(&self) -> BM0_R {
|
||||
BM0_R::new((self.bits & 0x07) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 5:15 - BM\\[28:18\\]
|
||||
- ID\\[10:0\\]
|
||||
in standard, ID\\[28:18\\]
|
||||
in extended"]
|
||||
#[inline(always)]
|
||||
pub fn bm1(&mut self) -> BM1_W {
|
||||
BM1_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 4 - Remote Transmission Request in Standard, Substitute Remote Request (SRR) in extended"]
|
||||
#[inline(always)]
|
||||
pub fn rtr(&mut self) -> RTR_W {
|
||||
RTR_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 3 - Identifier Extension Bit"]
|
||||
#[inline(always)]
|
||||
pub fn ide(&mut self) -> IDE_W {
|
||||
IDE_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:2 - BM\\[17:15\\]
|
||||
- Unused in standard, ID\\[17:15\\]
|
||||
in extended"]
|
||||
#[inline(always)]
|
||||
pub fn bm0(&mut self) -> BM0_W {
|
||||
BM0_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Basic Mask Base\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [bmskb](index.html) module"]
|
||||
pub struct BMSKB_SPEC;
|
||||
impl crate::RegisterSpec for BMSKB_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [bmskb::R](R) reader structure"]
|
||||
impl crate::Readable for BMSKB_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [bmskb::W](W) writer structure"]
|
||||
impl crate::Writable for BMSKB_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets BMSKB to value 0"]
|
||||
impl crate::Resettable for BMSKB_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
158
va416xx/src/can0/bmskx.rs
Normal file
158
va416xx/src/can0/bmskx.rs
Normal file
@ -0,0 +1,158 @@
|
||||
#[doc = "Register `BMSKX` reader"]
|
||||
pub struct R(crate::R<BMSKX_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<BMSKX_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<BMSKX_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<BMSKX_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `BMSKX` writer"]
|
||||
pub struct W(crate::W<BMSKX_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<BMSKX_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<BMSKX_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<BMSKX_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BM` reader - BM\\[14:0\\]
|
||||
used when an extended frame is received. ID\\[14:0\\]
|
||||
in extended, unused standard"]
|
||||
pub struct BM_R(crate::FieldReader<u16, u16>);
|
||||
impl BM_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
BM_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BM_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BM` writer - BM\\[14:0\\]
|
||||
used when an extended frame is received. ID\\[14:0\\]
|
||||
in extended, unused standard"]
|
||||
pub struct BM_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BM_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x7fff << 1)) | ((value as u32 & 0x7fff) << 1);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `XRTR` reader - Extended Remote transmission Request Bit"]
|
||||
pub struct XRTR_R(crate::FieldReader<bool, bool>);
|
||||
impl XRTR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
XRTR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for XRTR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `XRTR` writer - Extended Remote transmission Request Bit"]
|
||||
pub struct XRTR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> XRTR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[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) -> BM_R {
|
||||
BM_R::new(((self.bits >> 1) & 0x7fff) as u16)
|
||||
}
|
||||
#[doc = "Bit 0 - Extended Remote transmission Request Bit"]
|
||||
#[inline(always)]
|
||||
pub fn xrtr(&self) -> XRTR_R {
|
||||
XRTR_R::new((self.bits & 0x01) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[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(&mut self) -> BM_W {
|
||||
BM_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 0 - Extended Remote transmission Request Bit"]
|
||||
#[inline(always)]
|
||||
pub fn xrtr(&mut self) -> XRTR_W {
|
||||
XRTR_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Basic Mask Extension\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [bmskx](index.html) module"]
|
||||
pub struct BMSKX_SPEC;
|
||||
impl crate::RegisterSpec for BMSKX_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [bmskx::R](R) reader structure"]
|
||||
impl crate::Readable for BMSKX_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [bmskx::W](W) writer structure"]
|
||||
impl crate::Writable for BMSKX_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets BMSKX to value 0"]
|
||||
impl crate::Resettable for BMSKX_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/canec.rs
Normal file
140
va416xx/src/can0/canec.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `CANEC` reader"]
|
||||
pub struct R(crate::R<CANEC_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CANEC_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CANEC_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CANEC_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CANEC` writer"]
|
||||
pub struct W(crate::W<CANEC_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CANEC_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CANEC_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CANEC_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REC` reader - Receive Error Counter"]
|
||||
pub struct REC_R(crate::FieldReader<u8, u8>);
|
||||
impl REC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
REC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for REC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REC` writer - Receive Error Counter"]
|
||||
pub struct REC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> REC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TEC` reader - Transmit Error Counter"]
|
||||
pub struct TEC_R(crate::FieldReader<u8, u8>);
|
||||
impl TEC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
TEC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TEC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TEC` writer - Transmit Error Counter"]
|
||||
pub struct TEC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TEC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Receive Error Counter"]
|
||||
#[inline(always)]
|
||||
pub fn rec(&self) -> REC_R {
|
||||
REC_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Transmit Error Counter"]
|
||||
#[inline(always)]
|
||||
pub fn tec(&self) -> TEC_R {
|
||||
TEC_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Receive Error Counter"]
|
||||
#[inline(always)]
|
||||
pub fn rec(&mut self) -> REC_W {
|
||||
REC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Transmit Error Counter"]
|
||||
#[inline(always)]
|
||||
pub fn tec(&mut self) -> TEC_W {
|
||||
TEC_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Error Counter Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [canec](index.html) module"]
|
||||
pub struct CANEC_SPEC;
|
||||
impl crate::RegisterSpec for CANEC_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [canec::R](R) reader structure"]
|
||||
impl crate::Readable for CANEC_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [canec::W](W) writer structure"]
|
||||
impl crate::Writable for CANEC_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CANEC to value 0"]
|
||||
impl crate::Resettable for CANEC_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
375
va416xx/src/can0/cediag.rs
Normal file
375
va416xx/src/can0/cediag.rs
Normal file
@ -0,0 +1,375 @@
|
||||
#[doc = "Register `CEDIAG` reader"]
|
||||
pub struct R(crate::R<CEDIAG_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CEDIAG_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CEDIAG_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CEDIAG_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CEDIAG` writer"]
|
||||
pub struct W(crate::W<CEDIAG_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CEDIAG_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CEDIAG_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CEDIAG_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DRIVE` reader - Drive"]
|
||||
pub struct DRIVE_R(crate::FieldReader<bool, bool>);
|
||||
impl DRIVE_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
DRIVE_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DRIVE_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DRIVE` writer - Drive"]
|
||||
pub struct DRIVE_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DRIVE_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `MON` reader - Monitor"]
|
||||
pub struct MON_R(crate::FieldReader<bool, bool>);
|
||||
impl MON_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
MON_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for MON_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `MON` writer - Monitor"]
|
||||
pub struct MON_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> MON_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CRC` reader - CRC"]
|
||||
pub struct CRC_R(crate::FieldReader<bool, bool>);
|
||||
impl CRC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
CRC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CRC_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CRC` writer - CRC"]
|
||||
pub struct CRC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CRC_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `STUFF` reader - Stuff Error"]
|
||||
pub struct STUFF_R(crate::FieldReader<bool, bool>);
|
||||
impl STUFF_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
STUFF_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for STUFF_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `STUFF` writer - Stuff Error"]
|
||||
pub struct STUFF_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> STUFF_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TXE` reader - Transmit Error"]
|
||||
pub struct TXE_R(crate::FieldReader<bool, bool>);
|
||||
impl TXE_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
TXE_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TXE_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TXE` writer - Transmit Error"]
|
||||
pub struct TXE_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TXE_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EBID` reader - Error Bit Identifier"]
|
||||
pub struct EBID_R(crate::FieldReader<u8, u8>);
|
||||
impl EBID_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
EBID_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EBID_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EBID` writer - Error Bit Identifier"]
|
||||
pub struct EBID_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EBID_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x3f << 4)) | ((value as u32 & 0x3f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EFID` reader - Error Field Identifier"]
|
||||
pub struct EFID_R(crate::FieldReader<u8, u8>);
|
||||
impl EFID_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
EFID_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EFID_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EFID` writer - Error Field Identifier"]
|
||||
pub struct EFID_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EFID_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 14 - Drive"]
|
||||
#[inline(always)]
|
||||
pub fn drive(&self) -> DRIVE_R {
|
||||
DRIVE_R::new(((self.bits >> 14) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 13 - Monitor"]
|
||||
#[inline(always)]
|
||||
pub fn mon(&self) -> MON_R {
|
||||
MON_R::new(((self.bits >> 13) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 12 - CRC"]
|
||||
#[inline(always)]
|
||||
pub fn crc(&self) -> CRC_R {
|
||||
CRC_R::new(((self.bits >> 12) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 11 - Stuff Error"]
|
||||
#[inline(always)]
|
||||
pub fn stuff(&self) -> STUFF_R {
|
||||
STUFF_R::new(((self.bits >> 11) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 10 - Transmit Error"]
|
||||
#[inline(always)]
|
||||
pub fn txe(&self) -> TXE_R {
|
||||
TXE_R::new(((self.bits >> 10) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 4:9 - Error Bit Identifier"]
|
||||
#[inline(always)]
|
||||
pub fn ebid(&self) -> EBID_R {
|
||||
EBID_R::new(((self.bits >> 4) & 0x3f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Error Field Identifier"]
|
||||
#[inline(always)]
|
||||
pub fn efid(&self) -> EFID_R {
|
||||
EFID_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 14 - Drive"]
|
||||
#[inline(always)]
|
||||
pub fn drive(&mut self) -> DRIVE_W {
|
||||
DRIVE_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 13 - Monitor"]
|
||||
#[inline(always)]
|
||||
pub fn mon(&mut self) -> MON_W {
|
||||
MON_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 12 - CRC"]
|
||||
#[inline(always)]
|
||||
pub fn crc(&mut self) -> CRC_W {
|
||||
CRC_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 11 - Stuff Error"]
|
||||
#[inline(always)]
|
||||
pub fn stuff(&mut self) -> STUFF_W {
|
||||
STUFF_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 10 - Transmit Error"]
|
||||
#[inline(always)]
|
||||
pub fn txe(&mut self) -> TXE_W {
|
||||
TXE_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:9 - Error Bit Identifier"]
|
||||
#[inline(always)]
|
||||
pub fn ebid(&mut self) -> EBID_W {
|
||||
EBID_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Error Field Identifier"]
|
||||
#[inline(always)]
|
||||
pub fn efid(&mut self) -> EFID_W {
|
||||
EFID_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Error Diagnostic Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cediag](index.html) module"]
|
||||
pub struct CEDIAG_SPEC;
|
||||
impl crate::RegisterSpec for CEDIAG_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cediag::R](R) reader structure"]
|
||||
impl crate::Readable for CEDIAG_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cediag::W](W) writer structure"]
|
||||
impl crate::Writable for CEDIAG_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CEDIAG to value 0"]
|
||||
impl crate::Resettable for CEDIAG_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
630
va416xx/src/can0/cgcr.rs
Normal file
630
va416xx/src/can0/cgcr.rs
Normal file
@ -0,0 +1,630 @@
|
||||
#[doc = "Register `CGCR` reader"]
|
||||
pub struct R(crate::R<CGCR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CGCR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CGCR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CGCR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CGCR` writer"]
|
||||
pub struct W(crate::W<CGCR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CGCR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CGCR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CGCR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EIT` reader - Error Interrupt Type"]
|
||||
pub struct EIT_R(crate::FieldReader<bool, bool>);
|
||||
impl EIT_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
EIT_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EIT_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EIT` writer - Error Interrupt Type"]
|
||||
pub struct EIT_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EIT_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DIAGEN` reader - Diagnostic Enable"]
|
||||
pub struct DIAGEN_R(crate::FieldReader<bool, bool>);
|
||||
impl DIAGEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
DIAGEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DIAGEN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DIAGEN` writer - Diagnostic Enable"]
|
||||
pub struct DIAGEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DIAGEN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `INTERNAL` reader - Internal"]
|
||||
pub struct INTERNAL_R(crate::FieldReader<bool, bool>);
|
||||
impl INTERNAL_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
INTERNAL_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for INTERNAL_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `INTERNAL` writer - Internal"]
|
||||
pub struct INTERNAL_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> INTERNAL_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `LOOPBACK` reader - Loopback"]
|
||||
pub struct LOOPBACK_R(crate::FieldReader<bool, bool>);
|
||||
impl LOOPBACK_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
LOOPBACK_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for LOOPBACK_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `LOOPBACK` writer - Loopback"]
|
||||
pub struct LOOPBACK_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> LOOPBACK_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IGNACK` reader - Ignore Acknowledge"]
|
||||
pub struct IGNACK_R(crate::FieldReader<bool, bool>);
|
||||
impl IGNACK_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
IGNACK_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for IGNACK_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IGNACK` writer - Ignore Acknowledge"]
|
||||
pub struct IGNACK_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> IGNACK_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `LO` reader - Listen Only"]
|
||||
pub struct LO_R(crate::FieldReader<bool, bool>);
|
||||
impl LO_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
LO_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for LO_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `LO` writer - Listen Only"]
|
||||
pub struct LO_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> LO_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DDIR` reader - Data Direction"]
|
||||
pub struct DDIR_R(crate::FieldReader<bool, bool>);
|
||||
impl DDIR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
DDIR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DDIR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DDIR` writer - Data Direction"]
|
||||
pub struct DDIR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DDIR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TSTPEN` reader - Time Sync Enable"]
|
||||
pub struct TSTPEN_R(crate::FieldReader<bool, bool>);
|
||||
impl TSTPEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
TSTPEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TSTPEN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TSTPEN` writer - Time Sync Enable"]
|
||||
pub struct TSTPEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TSTPEN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BUFFLOCK` reader - Buffer Lock"]
|
||||
pub struct BUFFLOCK_R(crate::FieldReader<bool, bool>);
|
||||
impl BUFFLOCK_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
BUFFLOCK_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BUFFLOCK_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BUFFLOCK` writer - Buffer Lock"]
|
||||
pub struct BUFFLOCK_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BUFFLOCK_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CTX` reader - RW,Control Transmit"]
|
||||
pub struct CTX_R(crate::FieldReader<bool, bool>);
|
||||
impl CTX_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
CTX_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CTX_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CTX` writer - RW,Control Transmit"]
|
||||
pub struct CTX_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CTX_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CRX` reader - RW,Control Receive"]
|
||||
pub struct CRX_R(crate::FieldReader<bool, bool>);
|
||||
impl CRX_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
CRX_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CRX_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CRX` writer - RW,Control Receive"]
|
||||
pub struct CRX_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CRX_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CANEN` reader - CAN Enable"]
|
||||
pub struct CANEN_R(crate::FieldReader<bool, bool>);
|
||||
impl CANEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
CANEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CANEN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CANEN` writer - CAN Enable"]
|
||||
pub struct CANEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> CANEN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 11 - Error Interrupt Type"]
|
||||
#[inline(always)]
|
||||
pub fn eit(&self) -> EIT_R {
|
||||
EIT_R::new(((self.bits >> 11) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 10 - Diagnostic Enable"]
|
||||
#[inline(always)]
|
||||
pub fn diagen(&self) -> DIAGEN_R {
|
||||
DIAGEN_R::new(((self.bits >> 10) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 9 - Internal"]
|
||||
#[inline(always)]
|
||||
pub fn internal(&self) -> INTERNAL_R {
|
||||
INTERNAL_R::new(((self.bits >> 9) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 8 - Loopback"]
|
||||
#[inline(always)]
|
||||
pub fn loopback(&self) -> LOOPBACK_R {
|
||||
LOOPBACK_R::new(((self.bits >> 8) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Ignore Acknowledge"]
|
||||
#[inline(always)]
|
||||
pub fn ignack(&self) -> IGNACK_R {
|
||||
IGNACK_R::new(((self.bits >> 7) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Listen Only"]
|
||||
#[inline(always)]
|
||||
pub fn lo(&self) -> LO_R {
|
||||
LO_R::new(((self.bits >> 6) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Data Direction"]
|
||||
#[inline(always)]
|
||||
pub fn ddir(&self) -> DDIR_R {
|
||||
DDIR_R::new(((self.bits >> 5) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Time Sync Enable"]
|
||||
#[inline(always)]
|
||||
pub fn tstpen(&self) -> TSTPEN_R {
|
||||
TSTPEN_R::new(((self.bits >> 4) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Buffer Lock"]
|
||||
#[inline(always)]
|
||||
pub fn bufflock(&self) -> BUFFLOCK_R {
|
||||
BUFFLOCK_R::new(((self.bits >> 3) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - RW,Control Transmit"]
|
||||
#[inline(always)]
|
||||
pub fn ctx(&self) -> CTX_R {
|
||||
CTX_R::new(((self.bits >> 2) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - RW,Control Receive"]
|
||||
#[inline(always)]
|
||||
pub fn crx(&self) -> CRX_R {
|
||||
CRX_R::new(((self.bits >> 1) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bit 0 - CAN Enable"]
|
||||
#[inline(always)]
|
||||
pub fn canen(&self) -> CANEN_R {
|
||||
CANEN_R::new((self.bits & 0x01) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 11 - Error Interrupt Type"]
|
||||
#[inline(always)]
|
||||
pub fn eit(&mut self) -> EIT_W {
|
||||
EIT_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 10 - Diagnostic Enable"]
|
||||
#[inline(always)]
|
||||
pub fn diagen(&mut self) -> DIAGEN_W {
|
||||
DIAGEN_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 9 - Internal"]
|
||||
#[inline(always)]
|
||||
pub fn internal(&mut self) -> INTERNAL_W {
|
||||
INTERNAL_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 8 - Loopback"]
|
||||
#[inline(always)]
|
||||
pub fn loopback(&mut self) -> LOOPBACK_W {
|
||||
LOOPBACK_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 7 - Ignore Acknowledge"]
|
||||
#[inline(always)]
|
||||
pub fn ignack(&mut self) -> IGNACK_W {
|
||||
IGNACK_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 6 - Listen Only"]
|
||||
#[inline(always)]
|
||||
pub fn lo(&mut self) -> LO_W {
|
||||
LO_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 5 - Data Direction"]
|
||||
#[inline(always)]
|
||||
pub fn ddir(&mut self) -> DDIR_W {
|
||||
DDIR_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 4 - Time Sync Enable"]
|
||||
#[inline(always)]
|
||||
pub fn tstpen(&mut self) -> TSTPEN_W {
|
||||
TSTPEN_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 3 - Buffer Lock"]
|
||||
#[inline(always)]
|
||||
pub fn bufflock(&mut self) -> BUFFLOCK_W {
|
||||
BUFFLOCK_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 2 - RW,Control Transmit"]
|
||||
#[inline(always)]
|
||||
pub fn ctx(&mut self) -> CTX_W {
|
||||
CTX_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 1 - RW,Control Receive"]
|
||||
#[inline(always)]
|
||||
pub fn crx(&mut self) -> CRX_W {
|
||||
CRX_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 0 - CAN Enable"]
|
||||
#[inline(always)]
|
||||
pub fn canen(&mut self) -> CANEN_W {
|
||||
CANEN_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Global Configuration Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cgcr](index.html) module"]
|
||||
pub struct CGCR_SPEC;
|
||||
impl crate::RegisterSpec for CGCR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cgcr::R](R) reader structure"]
|
||||
impl crate::Readable for CGCR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cgcr::W](W) writer structure"]
|
||||
impl crate::Writable for CGCR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CGCR to value 0"]
|
||||
impl crate::Resettable for CGCR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
150
va416xx/src/can0/cicen.rs
Normal file
150
va416xx/src/can0/cicen.rs
Normal file
@ -0,0 +1,150 @@
|
||||
#[doc = "Register `CICEN` reader"]
|
||||
pub struct R(crate::R<CICEN_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CICEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CICEN_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CICEN_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CICEN` writer"]
|
||||
pub struct W(crate::W<CICEN_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CICEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CICEN_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CICEN_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EICEN` reader - Error Interrupt Code Enable"]
|
||||
pub struct EICEN_R(crate::FieldReader<bool, bool>);
|
||||
impl EICEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
EICEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EICEN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EICEN` writer - Error Interrupt Code Enable"]
|
||||
pub struct EICEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EICEN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ICEN` reader - Buffer Interrupt Code Enable\\[14:0\\]"]
|
||||
pub struct ICEN_R(crate::FieldReader<u16, u16>);
|
||||
impl ICEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
ICEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ICEN_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ICEN` writer - Buffer Interrupt Code Enable\\[14:0\\]"]
|
||||
pub struct ICEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ICEN_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 15 - Error Interrupt Code Enable"]
|
||||
#[inline(always)]
|
||||
pub fn eicen(&self) -> EICEN_R {
|
||||
EICEN_R::new(((self.bits >> 15) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn icen(&self) -> ICEN_R {
|
||||
ICEN_R::new((self.bits & 0x7fff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 15 - Error Interrupt Code Enable"]
|
||||
#[inline(always)]
|
||||
pub fn eicen(&mut self) -> EICEN_W {
|
||||
EICEN_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Code Enable\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn icen(&mut self) -> ICEN_W {
|
||||
ICEN_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Interrupt Code Enable Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cicen](index.html) module"]
|
||||
pub struct CICEN_SPEC;
|
||||
impl crate::RegisterSpec for CICEN_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cicen::R](R) reader structure"]
|
||||
impl crate::Readable for CICEN_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cicen::W](W) writer structure"]
|
||||
impl crate::Writable for CICEN_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CICEN to value 0"]
|
||||
impl crate::Resettable for CICEN_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
150
va416xx/src/can0/ciclr.rs
Normal file
150
va416xx/src/can0/ciclr.rs
Normal file
@ -0,0 +1,150 @@
|
||||
#[doc = "Register `CICLR` reader"]
|
||||
pub struct R(crate::R<CICLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CICLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CICLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CICLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CICLR` writer"]
|
||||
pub struct W(crate::W<CICLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CICLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CICLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CICLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EICLR` reader - Error Interrupt Clear"]
|
||||
pub struct EICLR_R(crate::FieldReader<bool, bool>);
|
||||
impl EICLR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
EICLR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EICLR_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EICLR` writer - Error Interrupt Clear"]
|
||||
pub struct EICLR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EICLR_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ICLR` reader - Buffer Interrupt Clear\\[14:0\\]"]
|
||||
pub struct ICLR_R(crate::FieldReader<u16, u16>);
|
||||
impl ICLR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
ICLR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ICLR_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ICLR` writer - Buffer Interrupt Clear\\[14:0\\]"]
|
||||
pub struct ICLR_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ICLR_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 15 - Error Interrupt Clear"]
|
||||
#[inline(always)]
|
||||
pub fn eiclr(&self) -> EICLR_R {
|
||||
EICLR_R::new(((self.bits >> 15) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn iclr(&self) -> ICLR_R {
|
||||
ICLR_R::new((self.bits & 0x7fff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 15 - Error Interrupt Clear"]
|
||||
#[inline(always)]
|
||||
pub fn eiclr(&mut self) -> EICLR_W {
|
||||
EICLR_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Clear\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn iclr(&mut self) -> ICLR_W {
|
||||
ICLR_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Interrupt Clear Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ciclr](index.html) module"]
|
||||
pub struct CICLR_SPEC;
|
||||
impl crate::RegisterSpec for CICLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [ciclr::R](R) reader structure"]
|
||||
impl crate::Readable for CICLR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [ciclr::W](W) writer structure"]
|
||||
impl crate::Writable for CICLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CICLR to value 0"]
|
||||
impl crate::Resettable for CICLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
150
va416xx/src/can0/cien.rs
Normal file
150
va416xx/src/can0/cien.rs
Normal file
@ -0,0 +1,150 @@
|
||||
#[doc = "Register `CIEN` reader"]
|
||||
pub struct R(crate::R<CIEN_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CIEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CIEN_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CIEN_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CIEN` writer"]
|
||||
pub struct W(crate::W<CIEN_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CIEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CIEN_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CIEN_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EIEN` reader - Error Interrupt Enable"]
|
||||
pub struct EIEN_R(crate::FieldReader<bool, bool>);
|
||||
impl EIEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
EIEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EIEN_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EIEN` writer - Error Interrupt Enable"]
|
||||
pub struct EIEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EIEN_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IEN` reader - Buffer Interrupt Enable\\[14:0\\]"]
|
||||
pub struct IEN_R(crate::FieldReader<u16, u16>);
|
||||
impl IEN_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
IEN_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for IEN_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IEN` writer - Buffer Interrupt Enable\\[14:0\\]"]
|
||||
pub struct IEN_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> IEN_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 15 - Error Interrupt Enable"]
|
||||
#[inline(always)]
|
||||
pub fn eien(&self) -> EIEN_R {
|
||||
EIEN_R::new(((self.bits >> 15) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn ien(&self) -> IEN_R {
|
||||
IEN_R::new((self.bits & 0x7fff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 15 - Error Interrupt Enable"]
|
||||
#[inline(always)]
|
||||
pub fn eien(&mut self) -> EIEN_W {
|
||||
EIEN_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Enable\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn ien(&mut self) -> IEN_W {
|
||||
IEN_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Interrupt Enable Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cien](index.html) module"]
|
||||
pub struct CIEN_SPEC;
|
||||
impl crate::RegisterSpec for CIEN_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cien::R](R) reader structure"]
|
||||
impl crate::Readable for CIEN_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cien::W](W) writer structure"]
|
||||
impl crate::Writable for CIEN_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CIEN to value 0"]
|
||||
impl crate::Resettable for CIEN_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
150
va416xx/src/can0/cipnd.rs
Normal file
150
va416xx/src/can0/cipnd.rs
Normal file
@ -0,0 +1,150 @@
|
||||
#[doc = "Register `CIPND` reader"]
|
||||
pub struct R(crate::R<CIPND_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CIPND_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CIPND_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CIPND_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CIPND` writer"]
|
||||
pub struct W(crate::W<CIPND_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CIPND_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CIPND_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CIPND_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EIPND` reader - Error Interrupt Pending"]
|
||||
pub struct EIPND_R(crate::FieldReader<bool, bool>);
|
||||
impl EIPND_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
EIPND_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for EIPND_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EIPND` writer - Error Interrupt Pending"]
|
||||
pub struct EIPND_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> EIPND_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IPND` reader - Buffer Interrupt Pending\\[14:0\\]"]
|
||||
pub struct IPND_R(crate::FieldReader<u16, u16>);
|
||||
impl IPND_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
IPND_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for IPND_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IPND` writer - Buffer Interrupt Pending\\[14:0\\]"]
|
||||
pub struct IPND_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> IPND_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u16) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x7fff) | (value as u32 & 0x7fff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 15 - Error Interrupt Pending"]
|
||||
#[inline(always)]
|
||||
pub fn eipnd(&self) -> EIPND_R {
|
||||
EIPND_R::new(((self.bits >> 15) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn ipnd(&self) -> IPND_R {
|
||||
IPND_R::new((self.bits & 0x7fff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 15 - Error Interrupt Pending"]
|
||||
#[inline(always)]
|
||||
pub fn eipnd(&mut self) -> EIPND_W {
|
||||
EIPND_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:14 - Buffer Interrupt Pending\\[14:0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn ipnd(&mut self) -> IPND_W {
|
||||
IPND_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Interrupt Pending Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cipnd](index.html) module"]
|
||||
pub struct CIPND_SPEC;
|
||||
impl crate::RegisterSpec for CIPND_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cipnd::R](R) reader structure"]
|
||||
impl crate::Readable for CIPND_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cipnd::W](W) writer structure"]
|
||||
impl crate::Writable for CIPND_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CIPND to value 0"]
|
||||
impl crate::Resettable for CIPND_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb0.rs
Normal file
177
va416xx/src/can0/cnstat_cmb0.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB0` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB0_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB0_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB0_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB0` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB0_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB0_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB0_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb0](index.html) module"]
|
||||
pub struct CNSTAT_CMB0_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB0_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb0::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB0_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb0::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB0_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB0 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB0_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb1.rs
Normal file
177
va416xx/src/can0/cnstat_cmb1.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB1` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB1_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB1_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB1_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB1` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB1_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB1_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB1_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb1](index.html) module"]
|
||||
pub struct CNSTAT_CMB1_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB1_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb1::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB1_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb1::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB1_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB1 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB1_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb10.rs
Normal file
177
va416xx/src/can0/cnstat_cmb10.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB10` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB10_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB10_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB10_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB10` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB10_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB10_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB10_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb10](index.html) module"]
|
||||
pub struct CNSTAT_CMB10_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB10_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb10::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB10_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb10::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB10_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB10 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB10_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb11.rs
Normal file
177
va416xx/src/can0/cnstat_cmb11.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB11` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB11_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB11_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB11_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB11` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB11_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB11_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB11_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb11](index.html) module"]
|
||||
pub struct CNSTAT_CMB11_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB11_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb11::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB11_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb11::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB11_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB11 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB11_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb12.rs
Normal file
177
va416xx/src/can0/cnstat_cmb12.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB12` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB12_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB12_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB12_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB12` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB12_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB12_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB12_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb12](index.html) module"]
|
||||
pub struct CNSTAT_CMB12_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB12_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb12::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB12_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb12::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB12_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB12 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB12_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb13.rs
Normal file
177
va416xx/src/can0/cnstat_cmb13.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB13` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB13_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB13_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB13_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB13` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB13_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB13_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB13_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb13](index.html) module"]
|
||||
pub struct CNSTAT_CMB13_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB13_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb13::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB13_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb13::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB13_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB13 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB13_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb14.rs
Normal file
177
va416xx/src/can0/cnstat_cmb14.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB14` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB14_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB14_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB14_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB14` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB14_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB14_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB14_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb14](index.html) module"]
|
||||
pub struct CNSTAT_CMB14_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB14_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb14::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB14_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb14::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB14_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB14 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB14_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb2.rs
Normal file
177
va416xx/src/can0/cnstat_cmb2.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB2` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB2_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB2_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB2_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB2` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB2_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB2_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB2_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb2](index.html) module"]
|
||||
pub struct CNSTAT_CMB2_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB2_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb2::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB2_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb2::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB2_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB2 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB2_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb3.rs
Normal file
177
va416xx/src/can0/cnstat_cmb3.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB3` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB3_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB3_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB3_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB3` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB3_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB3_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB3_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb3](index.html) module"]
|
||||
pub struct CNSTAT_CMB3_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB3_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb3::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB3_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb3::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB3_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB3 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB3_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb4.rs
Normal file
177
va416xx/src/can0/cnstat_cmb4.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB4` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB4_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB4_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB4_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB4` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB4_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB4_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB4_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb4](index.html) module"]
|
||||
pub struct CNSTAT_CMB4_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB4_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb4::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB4_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb4::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB4_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB4 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB4_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb5.rs
Normal file
177
va416xx/src/can0/cnstat_cmb5.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB5` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB5_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB5_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB5_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB5` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB5_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB5_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB5_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb5](index.html) module"]
|
||||
pub struct CNSTAT_CMB5_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB5_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb5::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB5_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb5::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB5_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB5 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB5_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb6.rs
Normal file
177
va416xx/src/can0/cnstat_cmb6.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB6` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB6_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB6_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB6_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB6` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB6_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB6_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB6_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb6](index.html) module"]
|
||||
pub struct CNSTAT_CMB6_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB6_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb6::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB6_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb6::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB6_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB6 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB6_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb7.rs
Normal file
177
va416xx/src/can0/cnstat_cmb7.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB7` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB7_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB7_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB7_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB7_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB7` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB7_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB7_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB7_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB7_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb7](index.html) module"]
|
||||
pub struct CNSTAT_CMB7_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB7_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb7::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB7_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb7::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB7_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB7 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB7_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb8.rs
Normal file
177
va416xx/src/can0/cnstat_cmb8.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB8` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB8_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB8_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB8_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB8_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB8` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB8_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB8_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB8_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB8_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb8](index.html) module"]
|
||||
pub struct CNSTAT_CMB8_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB8_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb8::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB8_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb8::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB8_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB8 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB8_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_cmb9.rs
Normal file
177
va416xx/src/can0/cnstat_cmb9.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_CMB9` reader"]
|
||||
pub struct R(crate::R<CNSTAT_CMB9_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_CMB9_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_CMB9_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_CMB9_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_CMB9` writer"]
|
||||
pub struct W(crate::W<CNSTAT_CMB9_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_CMB9_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_CMB9_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_CMB9_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_cmb9](index.html) module"]
|
||||
pub struct CNSTAT_CMB9_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_CMB9_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_cmb9::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_CMB9_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_cmb9::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_CMB9_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_CMB9 to value 0"]
|
||||
impl crate::Resettable for CNSTAT_CMB9_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
177
va416xx/src/can0/cnstat_hcmb.rs
Normal file
177
va416xx/src/can0/cnstat_hcmb.rs
Normal file
@ -0,0 +1,177 @@
|
||||
#[doc = "Register `CNSTAT_HCMB` reader"]
|
||||
pub struct R(crate::R<CNSTAT_HCMB_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CNSTAT_HCMB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CNSTAT_HCMB_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CNSTAT_HCMB_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CNSTAT_HCMB` writer"]
|
||||
pub struct W(crate::W<CNSTAT_HCMB_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CNSTAT_HCMB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CNSTAT_HCMB_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CNSTAT_HCMB_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` reader - Data Length Code"]
|
||||
pub struct DLC_R(crate::FieldReader<u8, u8>);
|
||||
impl DLC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
DLC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for DLC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `DLC` writer - Data Length Code"]
|
||||
pub struct DLC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> DLC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 12)) | ((value as u32 & 0x0f) << 12);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` reader - Transmit Priority Code"]
|
||||
pub struct PRI_R(crate::FieldReader<u8, u8>);
|
||||
impl PRI_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PRI_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PRI_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRI` writer - Transmit Priority Code"]
|
||||
pub struct PRI_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PRI_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 4)) | ((value as u32 & 0x0f) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` reader - Buffer Status"]
|
||||
pub struct ST_R(crate::FieldReader<u8, u8>);
|
||||
impl ST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
ST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for ST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `ST` writer - Buffer Status"]
|
||||
pub struct ST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> ST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&self) -> DLC_R {
|
||||
DLC_R::new(((self.bits >> 12) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&self) -> PRI_R {
|
||||
PRI_R::new(((self.bits >> 4) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&self) -> ST_R {
|
||||
ST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 12:15 - Data Length Code"]
|
||||
#[inline(always)]
|
||||
pub fn dlc(&mut self) -> DLC_W {
|
||||
DLC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 4:7 - Transmit Priority Code"]
|
||||
#[inline(always)]
|
||||
pub fn pri(&mut self) -> PRI_W {
|
||||
PRI_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Buffer Status"]
|
||||
#[inline(always)]
|
||||
pub fn st(&mut self) -> ST_W {
|
||||
ST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Buffer Status / Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cnstat_hcmb](index.html) module"]
|
||||
pub struct CNSTAT_HCMB_SPEC;
|
||||
impl crate::RegisterSpec for CNSTAT_HCMB_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cnstat_hcmb::R](R) reader structure"]
|
||||
impl crate::Readable for CNSTAT_HCMB_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cnstat_hcmb::W](W) writer structure"]
|
||||
impl crate::Writable for CNSTAT_HCMB_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CNSTAT_HCMB to value 0"]
|
||||
impl crate::Resettable for CNSTAT_HCMB_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
187
va416xx/src/can0/cstpnd.rs
Normal file
187
va416xx/src/can0/cstpnd.rs
Normal file
@ -0,0 +1,187 @@
|
||||
#[doc = "Register `CSTPND` reader"]
|
||||
pub struct R(crate::R<CSTPND_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CSTPND_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CSTPND_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CSTPND_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CSTPND` writer"]
|
||||
pub struct W(crate::W<CSTPND_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CSTPND_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CSTPND_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CSTPND_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `NS` reader - CAN Node Status"]
|
||||
pub struct NS_R(crate::FieldReader<u8, u8>);
|
||||
impl NS_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
NS_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for NS_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `NS` writer - CAN Node Status"]
|
||||
pub struct NS_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> NS_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x07 << 5)) | ((value as u32 & 0x07) << 5);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IRQ` reader - Interrupt Request portion of Interrupt Code"]
|
||||
pub struct IRQ_R(crate::FieldReader<bool, bool>);
|
||||
impl IRQ_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: bool) -> Self {
|
||||
IRQ_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for IRQ_R {
|
||||
type Target = crate::FieldReader<bool, bool>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IRQ` writer - Interrupt Request portion of Interrupt Code"]
|
||||
pub struct IRQ_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> IRQ_W<'a> {
|
||||
#[doc = r"Sets the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn set_bit(self) -> &'a mut W {
|
||||
self.bit(true)
|
||||
}
|
||||
#[doc = r"Clears the field bit"]
|
||||
#[inline(always)]
|
||||
pub fn clear_bit(self) -> &'a mut W {
|
||||
self.bit(false)
|
||||
}
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub fn bit(self, value: bool) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IST` reader - Interrupt Source portion of Interrupt Code"]
|
||||
pub struct IST_R(crate::FieldReader<u8, u8>);
|
||||
impl IST_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
IST_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for IST_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `IST` writer - Interrupt Source portion of Interrupt Code"]
|
||||
pub struct IST_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> IST_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x0f) | (value as u32 & 0x0f);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 5:7 - CAN Node Status"]
|
||||
#[inline(always)]
|
||||
pub fn ns(&self) -> NS_R {
|
||||
NS_R::new(((self.bits >> 5) & 0x07) as u8)
|
||||
}
|
||||
#[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
|
||||
#[inline(always)]
|
||||
pub fn irq(&self) -> IRQ_R {
|
||||
IRQ_R::new(((self.bits >> 4) & 0x01) != 0)
|
||||
}
|
||||
#[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
|
||||
#[inline(always)]
|
||||
pub fn ist(&self) -> IST_R {
|
||||
IST_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 5:7 - CAN Node Status"]
|
||||
#[inline(always)]
|
||||
pub fn ns(&mut self) -> NS_W {
|
||||
NS_W { w: self }
|
||||
}
|
||||
#[doc = "Bit 4 - Interrupt Request portion of Interrupt Code"]
|
||||
#[inline(always)]
|
||||
pub fn irq(&mut self) -> IRQ_W {
|
||||
IRQ_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:3 - Interrupt Source portion of Interrupt Code"]
|
||||
#[inline(always)]
|
||||
pub fn ist(&mut self) -> IST_W {
|
||||
IST_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Status Pending Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cstpnd](index.html) module"]
|
||||
pub struct CSTPND_SPEC;
|
||||
impl crate::RegisterSpec for CSTPND_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cstpnd::R](R) reader structure"]
|
||||
impl crate::Readable for CSTPND_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cstpnd::W](W) writer structure"]
|
||||
impl crate::Writable for CSTPND_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CSTPND to value 0"]
|
||||
impl crate::Resettable for CSTPND_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
214
va416xx/src/can0/ctim.rs
Normal file
214
va416xx/src/can0/ctim.rs
Normal file
@ -0,0 +1,214 @@
|
||||
#[doc = "Register `CTIM` reader"]
|
||||
pub struct R(crate::R<CTIM_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CTIM_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CTIM_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CTIM_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CTIM` writer"]
|
||||
pub struct W(crate::W<CTIM_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CTIM_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CTIM_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CTIM_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PSC` reader - Prescaler Configuration"]
|
||||
pub struct PSC_R(crate::FieldReader<u8, u8>);
|
||||
impl PSC_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
PSC_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for PSC_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PSC` writer - Prescaler Configuration"]
|
||||
pub struct PSC_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> PSC_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x7f << 9)) | ((value as u32 & 0x7f) << 9);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `SJW` reader - Synchronization Jump Width"]
|
||||
pub struct SJW_R(crate::FieldReader<u8, u8>);
|
||||
impl SJW_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
SJW_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for SJW_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `SJW` writer - Synchronization Jump Width"]
|
||||
pub struct SJW_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> SJW_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x03 << 7)) | ((value as u32 & 0x03) << 7);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TSEG1` reader - Time Segment 1"]
|
||||
pub struct TSEG1_R(crate::FieldReader<u8, u8>);
|
||||
impl TSEG1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
TSEG1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TSEG1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TSEG1` writer - Time Segment 1"]
|
||||
pub struct TSEG1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TSEG1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0x0f << 3)) | ((value as u32 & 0x0f) << 3);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TSEG2` reader - Time Segment 2"]
|
||||
pub struct TSEG2_R(crate::FieldReader<u8, u8>);
|
||||
impl TSEG2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
TSEG2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for TSEG2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TSEG2` writer - Time Segment 2"]
|
||||
pub struct TSEG2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> TSEG2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0x07) | (value as u32 & 0x07);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 9:15 - Prescaler Configuration"]
|
||||
#[inline(always)]
|
||||
pub fn psc(&self) -> PSC_R {
|
||||
PSC_R::new(((self.bits >> 9) & 0x7f) as u8)
|
||||
}
|
||||
#[doc = "Bits 7:8 - Synchronization Jump Width"]
|
||||
#[inline(always)]
|
||||
pub fn sjw(&self) -> SJW_R {
|
||||
SJW_R::new(((self.bits >> 7) & 0x03) as u8)
|
||||
}
|
||||
#[doc = "Bits 3:6 - Time Segment 1"]
|
||||
#[inline(always)]
|
||||
pub fn tseg1(&self) -> TSEG1_R {
|
||||
TSEG1_R::new(((self.bits >> 3) & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:2 - Time Segment 2"]
|
||||
#[inline(always)]
|
||||
pub fn tseg2(&self) -> TSEG2_R {
|
||||
TSEG2_R::new((self.bits & 0x07) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 9:15 - Prescaler Configuration"]
|
||||
#[inline(always)]
|
||||
pub fn psc(&mut self) -> PSC_W {
|
||||
PSC_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 7:8 - Synchronization Jump Width"]
|
||||
#[inline(always)]
|
||||
pub fn sjw(&mut self) -> SJW_W {
|
||||
SJW_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 3:6 - Time Segment 1"]
|
||||
#[inline(always)]
|
||||
pub fn tseg1(&mut self) -> TSEG1_W {
|
||||
TSEG1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:2 - Time Segment 2"]
|
||||
#[inline(always)]
|
||||
pub fn tseg2(&mut self) -> TSEG2_W {
|
||||
TSEG2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Timing Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ctim](index.html) module"]
|
||||
pub struct CTIM_SPEC;
|
||||
impl crate::RegisterSpec for CTIM_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [ctim::R](R) reader structure"]
|
||||
impl crate::Readable for CTIM_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [ctim::W](W) writer structure"]
|
||||
impl crate::Writable for CTIM_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CTIM to value 0"]
|
||||
impl crate::Resettable for CTIM_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
86
va416xx/src/can0/ctmr.rs
Normal file
86
va416xx/src/can0/ctmr.rs
Normal file
@ -0,0 +1,86 @@
|
||||
#[doc = "Register `CTMR` reader"]
|
||||
pub struct R(crate::R<CTMR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CTMR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CTMR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CTMR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CTMR` writer"]
|
||||
pub struct W(crate::W<CTMR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CTMR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<CTMR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CTMR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CTMR` reader - Time Stamp Counter"]
|
||||
pub struct CTMR_R(crate::FieldReader<u16, u16>);
|
||||
impl CTMR_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u16) -> Self {
|
||||
CTMR_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for CTMR_R {
|
||||
type Target = crate::FieldReader<u16, u16>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 0:15 - Time Stamp Counter"]
|
||||
#[inline(always)]
|
||||
pub fn ctmr(&self) -> CTMR_R {
|
||||
CTMR_R::new((self.bits & 0xffff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Timer Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ctmr](index.html) module"]
|
||||
pub struct CTMR_SPEC;
|
||||
impl crate::RegisterSpec for CTMR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [ctmr::R](R) reader structure"]
|
||||
impl crate::Readable for CTMR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [ctmr::W](W) writer structure"]
|
||||
impl crate::Writable for CTMR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CTMR to value 0"]
|
||||
impl crate::Resettable for CTMR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb0.rs
Normal file
140
va416xx/src/can0/data0_cmb0.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB0` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB0_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB0_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB0_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB0` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB0_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB0_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB0_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb0](index.html) module"]
|
||||
pub struct DATA0_CMB0_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB0_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb0::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB0_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb0::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB0_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB0 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB0_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb1.rs
Normal file
140
va416xx/src/can0/data0_cmb1.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB1` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB1_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB1_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB1_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB1` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB1_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB1_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB1_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb1](index.html) module"]
|
||||
pub struct DATA0_CMB1_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB1_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb1::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB1_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb1::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB1_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB1 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB1_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb10.rs
Normal file
140
va416xx/src/can0/data0_cmb10.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB10` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB10_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB10_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB10_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB10` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB10_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB10_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB10_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb10](index.html) module"]
|
||||
pub struct DATA0_CMB10_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB10_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb10::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB10_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb10::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB10_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB10 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB10_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb11.rs
Normal file
140
va416xx/src/can0/data0_cmb11.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB11` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB11_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB11_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB11_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB11` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB11_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB11_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB11_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb11](index.html) module"]
|
||||
pub struct DATA0_CMB11_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB11_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb11::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB11_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb11::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB11_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB11 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB11_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb12.rs
Normal file
140
va416xx/src/can0/data0_cmb12.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB12` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB12_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB12_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB12_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB12` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB12_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB12_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB12_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb12](index.html) module"]
|
||||
pub struct DATA0_CMB12_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB12_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb12::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB12_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb12::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB12_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB12 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB12_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb13.rs
Normal file
140
va416xx/src/can0/data0_cmb13.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB13` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB13_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB13_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB13_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB13` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB13_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB13_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB13_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb13](index.html) module"]
|
||||
pub struct DATA0_CMB13_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB13_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb13::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB13_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb13::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB13_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB13 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB13_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb14.rs
Normal file
140
va416xx/src/can0/data0_cmb14.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB14` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB14_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB14_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB14_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB14` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB14_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB14_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB14_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb14](index.html) module"]
|
||||
pub struct DATA0_CMB14_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB14_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb14::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB14_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb14::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB14_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB14 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB14_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb2.rs
Normal file
140
va416xx/src/can0/data0_cmb2.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB2` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB2_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB2_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB2_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB2` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB2_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB2_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB2_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb2](index.html) module"]
|
||||
pub struct DATA0_CMB2_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB2_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb2::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB2_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb2::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB2_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB2 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB2_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb3.rs
Normal file
140
va416xx/src/can0/data0_cmb3.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB3` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB3_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB3_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB3_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB3` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB3_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB3_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB3_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb3](index.html) module"]
|
||||
pub struct DATA0_CMB3_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB3_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb3::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB3_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb3::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB3_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB3 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB3_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb4.rs
Normal file
140
va416xx/src/can0/data0_cmb4.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB4` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB4_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB4_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB4_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB4` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB4_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB4_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB4_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb4](index.html) module"]
|
||||
pub struct DATA0_CMB4_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB4_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb4::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB4_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb4::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB4_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB4 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB4_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb5.rs
Normal file
140
va416xx/src/can0/data0_cmb5.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB5` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB5_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB5_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB5_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB5` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB5_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB5_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB5_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb5](index.html) module"]
|
||||
pub struct DATA0_CMB5_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB5_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb5::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB5_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb5::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB5_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB5 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB5_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb6.rs
Normal file
140
va416xx/src/can0/data0_cmb6.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB6` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB6_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB6_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB6_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB6` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB6_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB6_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB6_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb6](index.html) module"]
|
||||
pub struct DATA0_CMB6_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB6_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb6::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB6_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb6::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB6_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB6 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB6_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb7.rs
Normal file
140
va416xx/src/can0/data0_cmb7.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB7` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB7_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB7_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB7_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB7_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB7` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB7_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB7_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB7_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB7_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb7](index.html) module"]
|
||||
pub struct DATA0_CMB7_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB7_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb7::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB7_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb7::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB7_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB7 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB7_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb8.rs
Normal file
140
va416xx/src/can0/data0_cmb8.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB8` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB8_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB8_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB8_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB8_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB8` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB8_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB8_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB8_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB8_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb8](index.html) module"]
|
||||
pub struct DATA0_CMB8_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB8_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb8::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB8_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb8::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB8_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB8 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB8_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_cmb9.rs
Normal file
140
va416xx/src/can0/data0_cmb9.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_CMB9` reader"]
|
||||
pub struct R(crate::R<DATA0_CMB9_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_CMB9_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_CMB9_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_CMB9_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_CMB9` writer"]
|
||||
pub struct W(crate::W<DATA0_CMB9_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_CMB9_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_CMB9_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_CMB9_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_cmb9](index.html) module"]
|
||||
pub struct DATA0_CMB9_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_CMB9_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_cmb9::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_CMB9_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_cmb9::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_CMB9_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_CMB9 to value 0"]
|
||||
impl crate::Resettable for DATA0_CMB9_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data0_hcmb.rs
Normal file
140
va416xx/src/can0/data0_hcmb.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA0_HCMB` reader"]
|
||||
pub struct R(crate::R<DATA0_HCMB_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA0_HCMB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA0_HCMB_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA0_HCMB_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA0_HCMB` writer"]
|
||||
pub struct W(crate::W<DATA0_HCMB_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA0_HCMB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA0_HCMB_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA0_HCMB_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` reader - Data Byte 1"]
|
||||
pub struct BYTE1_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE1_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE1_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE1_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE1` writer - Data Byte 1"]
|
||||
pub struct BYTE1_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE1_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` reader - Data Byte 2"]
|
||||
pub struct BYTE2_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE2_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE2_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE2_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE2` writer - Data Byte 2"]
|
||||
pub struct BYTE2_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE2_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&self) -> BYTE1_R {
|
||||
BYTE1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&self) -> BYTE2_R {
|
||||
BYTE2_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn byte1(&mut self) -> BYTE1_W {
|
||||
BYTE1_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn byte2(&mut self) -> BYTE2_W {
|
||||
BYTE2_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data0_hcmb](index.html) module"]
|
||||
pub struct DATA0_HCMB_SPEC;
|
||||
impl crate::RegisterSpec for DATA0_HCMB_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data0_hcmb::R](R) reader structure"]
|
||||
impl crate::Readable for DATA0_HCMB_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data0_hcmb::W](W) writer structure"]
|
||||
impl crate::Writable for DATA0_HCMB_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA0_HCMB to value 0"]
|
||||
impl crate::Resettable for DATA0_HCMB_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb0.rs
Normal file
140
va416xx/src/can0/data1_cmb0.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB0` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB0_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB0_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB0_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB0` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB0_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB0_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB0_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 1\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb0](index.html) module"]
|
||||
pub struct DATA1_CMB0_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB0_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb0::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB0_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb0::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB0_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB0 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB0_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb1.rs
Normal file
140
va416xx/src/can0/data1_cmb1.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB1` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB1_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB1_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB1_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB1` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB1_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB1_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB1_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb1](index.html) module"]
|
||||
pub struct DATA1_CMB1_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB1_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb1::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB1_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb1::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB1_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB1 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB1_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb10.rs
Normal file
140
va416xx/src/can0/data1_cmb10.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB10` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB10_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB10_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB10_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB10` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB10_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB10_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB10_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb10](index.html) module"]
|
||||
pub struct DATA1_CMB10_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB10_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb10::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB10_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb10::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB10_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB10 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB10_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb11.rs
Normal file
140
va416xx/src/can0/data1_cmb11.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB11` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB11_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB11_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB11_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB11` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB11_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB11_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB11_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb11](index.html) module"]
|
||||
pub struct DATA1_CMB11_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB11_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb11::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB11_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb11::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB11_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB11 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB11_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb12.rs
Normal file
140
va416xx/src/can0/data1_cmb12.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB12` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB12_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB12_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB12_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB12` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB12_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB12_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB12_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb12](index.html) module"]
|
||||
pub struct DATA1_CMB12_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB12_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb12::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB12_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb12::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB12_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB12 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB12_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb13.rs
Normal file
140
va416xx/src/can0/data1_cmb13.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB13` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB13_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB13_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB13_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB13` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB13_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB13_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB13_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb13](index.html) module"]
|
||||
pub struct DATA1_CMB13_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB13_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb13::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB13_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb13::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB13_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB13 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB13_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb14.rs
Normal file
140
va416xx/src/can0/data1_cmb14.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB14` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB14_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB14_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB14_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB14` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB14_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB14_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB14_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb14](index.html) module"]
|
||||
pub struct DATA1_CMB14_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB14_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb14::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB14_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb14::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB14_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB14 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB14_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb2.rs
Normal file
140
va416xx/src/can0/data1_cmb2.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB2` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB2_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB2_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB2_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB2` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB2_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB2_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB2_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb2](index.html) module"]
|
||||
pub struct DATA1_CMB2_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB2_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb2::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB2_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb2::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB2_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB2 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB2_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb3.rs
Normal file
140
va416xx/src/can0/data1_cmb3.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB3` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB3_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB3_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB3_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB3` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB3_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB3_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB3_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb3](index.html) module"]
|
||||
pub struct DATA1_CMB3_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB3_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb3::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB3_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb3::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB3_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB3 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB3_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb4.rs
Normal file
140
va416xx/src/can0/data1_cmb4.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB4` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB4_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB4_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB4_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB4` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB4_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB4_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB4_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb4](index.html) module"]
|
||||
pub struct DATA1_CMB4_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB4_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb4::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB4_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb4::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB4_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB4 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB4_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb5.rs
Normal file
140
va416xx/src/can0/data1_cmb5.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB5` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB5_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB5_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB5_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB5` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB5_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB5_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB5_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb5](index.html) module"]
|
||||
pub struct DATA1_CMB5_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB5_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb5::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB5_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb5::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB5_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB5 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB5_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb6.rs
Normal file
140
va416xx/src/can0/data1_cmb6.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB6` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB6_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB6_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB6_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB6` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB6_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB6_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB6_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb6](index.html) module"]
|
||||
pub struct DATA1_CMB6_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB6_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb6::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB6_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb6::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB6_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB6 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB6_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb7.rs
Normal file
140
va416xx/src/can0/data1_cmb7.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB7` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB7_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB7_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB7_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB7_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB7` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB7_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB7_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB7_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB7_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb7](index.html) module"]
|
||||
pub struct DATA1_CMB7_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB7_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb7::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB7_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb7::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB7_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB7 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB7_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb8.rs
Normal file
140
va416xx/src/can0/data1_cmb8.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB8` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB8_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB8_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB8_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB8_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB8` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB8_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB8_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB8_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB8_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb8](index.html) module"]
|
||||
pub struct DATA1_CMB8_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB8_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb8::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB8_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb8::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB8_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB8 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB8_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_cmb9.rs
Normal file
140
va416xx/src/can0/data1_cmb9.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_CMB9` reader"]
|
||||
pub struct R(crate::R<DATA1_CMB9_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_CMB9_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_CMB9_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_CMB9_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_CMB9` writer"]
|
||||
pub struct W(crate::W<DATA1_CMB9_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_CMB9_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_CMB9_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_CMB9_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_cmb9](index.html) module"]
|
||||
pub struct DATA1_CMB9_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_CMB9_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_cmb9::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_CMB9_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_cmb9::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_CMB9_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_CMB9 to value 0"]
|
||||
impl crate::Resettable for DATA1_CMB9_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data1_hcmb.rs
Normal file
140
va416xx/src/can0/data1_hcmb.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA1_HCMB` reader"]
|
||||
pub struct R(crate::R<DATA1_HCMB_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA1_HCMB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA1_HCMB_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA1_HCMB_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA1_HCMB` writer"]
|
||||
pub struct W(crate::W<DATA1_HCMB_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA1_HCMB_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA1_HCMB_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA1_HCMB_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` reader - Data Byte 3"]
|
||||
pub struct BYTE3_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE3_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE3_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE3_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE3` writer - Data Byte 3"]
|
||||
pub struct BYTE3_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE3_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` reader - Data Byte 4"]
|
||||
pub struct BYTE4_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE4_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE4_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE4_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE4` writer - Data Byte 4"]
|
||||
pub struct BYTE4_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE4_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&self) -> BYTE3_R {
|
||||
BYTE3_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&self) -> BYTE4_R {
|
||||
BYTE4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn byte3(&mut self) -> BYTE3_W {
|
||||
BYTE3_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn byte4(&mut self) -> BYTE4_W {
|
||||
BYTE4_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data1_hcmb](index.html) module"]
|
||||
pub struct DATA1_HCMB_SPEC;
|
||||
impl crate::RegisterSpec for DATA1_HCMB_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data1_hcmb::R](R) reader structure"]
|
||||
impl crate::Readable for DATA1_HCMB_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data1_hcmb::W](W) writer structure"]
|
||||
impl crate::Writable for DATA1_HCMB_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA1_HCMB to value 0"]
|
||||
impl crate::Resettable for DATA1_HCMB_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb0.rs
Normal file
140
va416xx/src/can0/data2_cmb0.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB0` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB0_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB0_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB0_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB0` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB0_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB0_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB0_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb0](index.html) module"]
|
||||
pub struct DATA2_CMB0_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB0_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb0::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB0_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb0::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB0_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB0 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB0_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb1.rs
Normal file
140
va416xx/src/can0/data2_cmb1.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB1` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB1_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB1_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB1_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB1` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB1_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB1_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB1_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb1](index.html) module"]
|
||||
pub struct DATA2_CMB1_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB1_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb1::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB1_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb1::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB1_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB1 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB1_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb10.rs
Normal file
140
va416xx/src/can0/data2_cmb10.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB10` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB10_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB10_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB10_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB10` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB10_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB10_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB10_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB10_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb10](index.html) module"]
|
||||
pub struct DATA2_CMB10_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB10_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb10::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB10_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb10::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB10_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB10 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB10_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb11.rs
Normal file
140
va416xx/src/can0/data2_cmb11.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB11` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB11_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB11_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB11_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB11` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB11_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB11_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB11_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB11_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb11](index.html) module"]
|
||||
pub struct DATA2_CMB11_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB11_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb11::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB11_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb11::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB11_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB11 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB11_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb12.rs
Normal file
140
va416xx/src/can0/data2_cmb12.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB12` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB12_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB12_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB12_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB12` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB12_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB12_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB12_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB12_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb12](index.html) module"]
|
||||
pub struct DATA2_CMB12_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB12_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb12::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB12_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb12::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB12_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB12 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB12_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb13.rs
Normal file
140
va416xx/src/can0/data2_cmb13.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB13` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB13_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB13_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB13_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB13` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB13_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB13_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB13_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB13_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb13](index.html) module"]
|
||||
pub struct DATA2_CMB13_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB13_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb13::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB13_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb13::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB13_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB13 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB13_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb14.rs
Normal file
140
va416xx/src/can0/data2_cmb14.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB14` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB14_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB14_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB14_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB14` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB14_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB14_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB14_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB14_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb14](index.html) module"]
|
||||
pub struct DATA2_CMB14_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB14_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb14::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB14_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb14::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB14_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB14 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB14_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb2.rs
Normal file
140
va416xx/src/can0/data2_cmb2.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB2` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB2_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB2_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB2_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB2` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB2_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB2_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB2_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb2](index.html) module"]
|
||||
pub struct DATA2_CMB2_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB2_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb2::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB2_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb2::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB2_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB2 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB2_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb3.rs
Normal file
140
va416xx/src/can0/data2_cmb3.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB3` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB3_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB3_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB3_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB3` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB3_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB3_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB3_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb3](index.html) module"]
|
||||
pub struct DATA2_CMB3_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB3_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb3::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB3_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb3::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB3_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB3 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB3_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb4.rs
Normal file
140
va416xx/src/can0/data2_cmb4.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB4` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB4_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB4_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB4_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB4` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB4_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB4_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB4_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB4_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb4](index.html) module"]
|
||||
pub struct DATA2_CMB4_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB4_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb4::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB4_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb4::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB4_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB4 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB4_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb5.rs
Normal file
140
va416xx/src/can0/data2_cmb5.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB5` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB5_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB5_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB5_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB5` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB5_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB5_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB5_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB5_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb5](index.html) module"]
|
||||
pub struct DATA2_CMB5_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB5_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb5::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB5_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb5::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB5_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB5 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB5_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
140
va416xx/src/can0/data2_cmb6.rs
Normal file
140
va416xx/src/can0/data2_cmb6.rs
Normal file
@ -0,0 +1,140 @@
|
||||
#[doc = "Register `DATA2_CMB6` reader"]
|
||||
pub struct R(crate::R<DATA2_CMB6_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<DATA2_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<DATA2_CMB6_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<DATA2_CMB6_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `DATA2_CMB6` writer"]
|
||||
pub struct W(crate::W<DATA2_CMB6_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<DATA2_CMB6_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<DATA2_CMB6_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<DATA2_CMB6_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` reader - Data Byte 5"]
|
||||
pub struct BYTE5_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE5_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE5_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE5_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE5` writer - Data Byte 5"]
|
||||
pub struct BYTE5_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE5_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !(0xff << 8)) | ((value as u32 & 0xff) << 8);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` reader - Data Byte 6"]
|
||||
pub struct BYTE6_R(crate::FieldReader<u8, u8>);
|
||||
impl BYTE6_R {
|
||||
#[inline(always)]
|
||||
pub(crate) fn new(bits: u8) -> Self {
|
||||
BYTE6_R(crate::FieldReader::new(bits))
|
||||
}
|
||||
}
|
||||
impl core::ops::Deref for BYTE6_R {
|
||||
type Target = crate::FieldReader<u8, u8>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `BYTE6` writer - Data Byte 6"]
|
||||
pub struct BYTE6_W<'a> {
|
||||
w: &'a mut W,
|
||||
}
|
||||
impl<'a> BYTE6_W<'a> {
|
||||
#[doc = r"Writes raw bits to the field"]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
||||
self.w.bits = (self.w.bits & !0xff) | (value as u32 & 0xff);
|
||||
self.w
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&self) -> BYTE5_R {
|
||||
BYTE5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&self) -> BYTE6_R {
|
||||
BYTE6_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 8:15 - Data Byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn byte5(&mut self) -> BYTE5_W {
|
||||
BYTE5_W { w: self }
|
||||
}
|
||||
#[doc = "Bits 0:7 - Data Byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn byte6(&mut self) -> BYTE6_W {
|
||||
BYTE6_W { w: self }
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "CAN Frame Data Word 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data2_cmb6](index.html) module"]
|
||||
pub struct DATA2_CMB6_SPEC;
|
||||
impl crate::RegisterSpec for DATA2_CMB6_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [data2_cmb6::R](R) reader structure"]
|
||||
impl crate::Readable for DATA2_CMB6_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [data2_cmb6::W](W) writer structure"]
|
||||
impl crate::Writable for DATA2_CMB6_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets DATA2_CMB6 to value 0"]
|
||||
impl crate::Resettable for DATA2_CMB6_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user