Browse Source

Talk as presented plus example source for MSP432 blinky light demo

master
Levi Pearson 3 years ago
parent
commit
4499e75a92
  1. 10
      .gitignore
  2. 61
      EmbeddedRust.md
  3. BIN
      EmbeddedRust.pdf
  4. 33
      example-source/msp432-app/.cargo/config
  5. 5
      example-source/msp432-app/.gitignore
  6. 31
      example-source/msp432-app/Cargo.toml
  7. 129
      example-source/msp432-app/README.md
  8. 18
      example-source/msp432-app/build.rs
  9. 37
      example-source/msp432-app/memory.x
  10. 6
      example-source/msp432-app/openocd.cfg
  11. 35
      example-source/msp432-app/openocd.gdb
  12. 96
      example-source/msp432-app/original-examples/crash.rs
  13. 37
      example-source/msp432-app/original-examples/exception.rs
  14. 20
      example-source/msp432-app/original-examples/hello.rs
  15. 33
      example-source/msp432-app/original-examples/itm.rs
  16. 28
      example-source/msp432-app/original-examples/panic.rs
  17. 57
      example-source/msp432-app/original-examples/test_on_host.rs
  18. 81
      example-source/msp432-app/src/main.rs
  19. 1
      example-source/msp432-app/upload.sh
  20. 3
      example-source/msp432-hal/.gitignore
  21. 19
      example-source/msp432-hal/Cargo.toml
  22. 63
      example-source/msp432-hal/src/cs.rs
  23. 74
      example-source/msp432-hal/src/delay.rs
  24. 22
      example-source/msp432-hal/src/gpio.rs
  25. 26
      example-source/msp432-hal/src/lib.rs
  26. 3
      example-source/msp432-hal/src/prelude.rs
  27. 117
      example-source/msp432-hal/src/time.rs
  28. 3
      example-source/msp432p401r/.gitignore
  29. 17
      example-source/msp432p401r/Cargo.toml
  30. 42237
      example-source/msp432p401r/MSP432P401R.svd
  31. 16
      example-source/msp432p401r/build.rs
  32. 42
      example-source/msp432p401r/device.x
  33. 125
      example-source/msp432p401r/src/adc14.rs
  34. 2045
      example-source/msp432p401r/src/adc14/adc14clrifgr0.rs
  35. 442
      example-source/msp432p401r/src/adc14/adc14clrifgr1.rs
  36. 2095
      example-source/msp432p401r/src/adc14/adc14ctl0.rs
  37. 1296
      example-source/msp432p401r/src/adc14/adc14ctl1.rs
  38. 105
      example-source/msp432p401r/src/adc14/adc14hi0.rs
  39. 105
      example-source/msp432p401r/src/adc14/adc14hi1.rs
  40. 3872
      example-source/msp432p401r/src/adc14/adc14ier0.rs
  41. 778
      example-source/msp432p401r/src/adc14/adc14ier1.rs
  42. 1812
      example-source/msp432p401r/src/adc14/adc14ifgr0.rs
  43. 356
      example-source/msp432p401r/src/adc14/adc14ifgr1.rs
  44. 796
      example-source/msp432p401r/src/adc14/adc14iv.rs
  45. 105
      example-source/msp432p401r/src/adc14/adc14lo0.rs
  46. 105
      example-source/msp432p401r/src/adc14/adc14lo1.rs
  47. 1289
      example-source/msp432p401r/src/adc14/adc14mctl.rs
  48. 105
      example-source/msp432p401r/src/adc14/adc14mem.rs
  49. 68
      example-source/msp432p401r/src/aes256.rs
  50. 1051
      example-source/msp432p401r/src/aes256/aesactl0.rs
  51. 105
      example-source/msp432p401r/src/aes256/aesactl1.rs
  52. 69
      example-source/msp432p401r/src/aes256/aesadin.rs
  53. 69
      example-source/msp432p401r/src/aes256/aesadout.rs
  54. 69
      example-source/msp432p401r/src/aes256/aesakey.rs
  55. 540
      example-source/msp432p401r/src/aes256/aesastat.rs
  56. 69
      example-source/msp432p401r/src/aes256/aesaxdin.rs
  57. 69
      example-source/msp432p401r/src/aes256/aesaxin.rs
  58. 13
      example-source/msp432p401r/src/captio0.rs
  59. 783
      example-source/msp432p401r/src/captio0/captiox_ctl.rs
  60. 13
      example-source/msp432p401r/src/captio1.rs
  61. 783
      example-source/msp432p401r/src/captio1/captiox_ctl.rs
  62. 53
      example-source/msp432p401r/src/comp_e0.rs
  63. 982
      example-source/msp432p401r/src/comp_e0/cex_ctl0.rs
  64. 1271
      example-source/msp432p401r/src/comp_e0/cex_ctl1.rs
  65. 1798
      example-source/msp432p401r/src/comp_e0/cex_ctl2.rs
  66. 1968
      example-source/msp432p401r/src/comp_e0/cex_ctl3.rs
  67. 778
      example-source/msp432p401r/src/comp_e0/cex_int.rs
  68. 88
      example-source/msp432p401r/src/comp_e0/cex_iv.rs
  69. 53
      example-source/msp432p401r/src/comp_e1.rs
  70. 982
      example-source/msp432p401r/src/comp_e1/cex_ctl0.rs
  71. 1271
      example-source/msp432p401r/src/comp_e1/cex_ctl1.rs
  72. 1798
      example-source/msp432p401r/src/comp_e1/cex_ctl2.rs
  73. 1968
      example-source/msp432p401r/src/comp_e1/cex_ctl3.rs
  74. 778
      example-source/msp432p401r/src/comp_e1/cex_int.rs
  75. 88
      example-source/msp432p401r/src/comp_e1/cex_iv.rs
  76. 89
      example-source/msp432p401r/src/crc32.rs
  77. 105
      example-source/msp432p401r/src/crc32/crc16di.rs
  78. 105
      example-source/msp432p401r/src/crc32/crc16dirb.rs
  79. 105
      example-source/msp432p401r/src/crc32/crc16inires.rs
  80. 105
      example-source/msp432p401r/src/crc32/crc16resr.rs
  81. 105
      example-source/msp432p401r/src/crc32/crc32di.rs
  82. 105
      example-source/msp432p401r/src/crc32/crc32dirb.rs
  83. 105
      example-source/msp432p401r/src/crc32/crc32inires_hi.rs
  84. 105
      example-source/msp432p401r/src/crc32/crc32inires_lo.rs
  85. 105
      example-source/msp432p401r/src/crc32/crc32resr_hi.rs
  86. 105
      example-source/msp432p401r/src/crc32/crc32resr_lo.rs
  87. 114
      example-source/msp432p401r/src/cs.rs
  88. 1016
      example-source/msp432p401r/src/cs/csclken.rs
  89. 722
      example-source/msp432p401r/src/cs/csclrifg.rs
  90. 514
      example-source/msp432p401r/src/cs/csctl0.rs
  91. 1611
      example-source/msp432p401r/src/cs/csctl1.rs
  92. 1102
      example-source/msp432p401r/src/cs/csctl2.rs
  93. 1018
      example-source/msp432p401r/src/cs/csctl3.rs
  94. 146
      example-source/msp432p401r/src/cs/csdcoercal0.rs
  95. 105
      example-source/msp432p401r/src/cs/csdcoercal1.rs
  96. 1373
      example-source/msp432p401r/src/cs/csie.rs
  97. 692
      example-source/msp432p401r/src/cs/csifg.rs
  98. 105
      example-source/msp432p401r/src/cs/cskey.rs
  99. 722
      example-source/msp432p401r/src/cs/cssetifg.rs
  100. 1196
      example-source/msp432p401r/src/cs/csstat.rs
  101. Some files were not shown because too many files have changed in this diff Show More

10
.gitignore vendored

@ -0,0 +1,10 @@ @@ -0,0 +1,10 @@
*.aux
*.out
*.log
*.toc
*.nav
*.vrb
*.snm
*.swp
body.tex
head.tex

61
EmbeddedRust.md

@ -12,7 +12,7 @@ I am: @@ -12,7 +12,7 @@ I am:
+ A very experienced embedded systems programmer
+ A moderately experienced Rustacean
+ Relatively new at the combination
+ Pretty new at the combination
## Questions to answer
@ -32,26 +32,23 @@ I am: @@ -32,26 +32,23 @@ I am:
## Examples
+ A digital scale's control system
+ The engine management computer in a car
+ The management controller in a hard drive
+ The disk controller in a hard drive
+ A factory process control computer
## They are everywhere
+ Microcontrollers start in the ~$0.01 price range
+ They can be as small as a grain of rice
+ They are in credit cards and SIM cards
+ They are also often off-the-shelf Windows boxes
## Microcontrollers
+ Computers specialized for embedded control duty
+ Single-chip computers specialized for embedded control
+ Much wider variety of architecture
+ Integrated peripherals:
- Memory (RAM/Flash)
- Timers
- Sensors
- Communication bus interfaces
@ -69,12 +66,9 @@ I am: @@ -69,12 +66,9 @@ I am:
## Why not other safe languages?
+ Real-time response requirements
+ Resource (often RAM/Flash) constraints
+ Memory layout and representation control
+ Perception
+ Perception (no one thinks of Ada)
## Big wins
@ -94,7 +88,7 @@ I am: @@ -94,7 +88,7 @@ I am:
+ `gdb` built for the target arch for debugging
+ `openocd` to drive the programmer/debugger module
## Embedded-wg resources
## Embedded-wg
+ Embedded Rust Book
+ Awesome / Not-Yet-Awesome Lists
@ -102,3 +96,44 @@ I am: @@ -102,3 +96,44 @@ I am:
+ `embedded-hal` and HAL Crates
+ Board Support Crates
+ `rtfm` "Real-Time For The Masses" framework
## Levels of maturity
+ Compiler back-ends for ARM and some other architectures are solid
+ Much work is now possible with stable Rust
+ Some patterns for safety are well-defined, others are still experimental
+ Patterns for modular, reusable code are still in progress
+ Ferrous Systems - works with **embedded-wg** and provides training/support
# Where to start?
## Emulation!
+ QEMU emulates a pair of ARM Cortex-M3 evaluation boards
+ The `ml3s6965` board has a minimal peripheral support crate
+ Both the Embedded Book and RTFM Book walk through starting with it
## Development boards
+ Vendor-developed boards can be expensive, but have nice components
+ Many hobbyist-oriented boards are available, usually cheaper!
+ Cheap knock-offs of open-hardware boards are *really* cheap
+ Stay away from AVR-architecture Arduino-style boards for now!
+ Risc-V and MSP-430 have llvm support, but not as much community support
## Sensors, actuators, etc.
+ Many boards have LEDs, buttons, capacitive touch, etc.
+ Adafruit, Sparkfun, Pololu have interesting, well-designed break-outs
+ Lots of cheap stuff from China, of varying quality!
+ Salvage from old electronics junk
# Time left?
## Discussion/Demos
+ General or rust-specific embedded Q&A
+ Walk-through tool + qemu install and first program
+ Look at some example code
+ Interest in future workshop w/real hardware?

BIN
EmbeddedRust.pdf

Binary file not shown.

33
example-source/msp432-app/.cargo/config

@ -0,0 +1,33 @@ @@ -0,0 +1,33 @@
#[target.thumbv7m-none-eabi]
# uncomment this to make `cargo run` execute programs on QEMU
# runner = "qemu-system-arm -cpu cortex-m3 -machine lm3s6965evb -nographic -semihosting-config enable=on,target=native -kernel"
[target.'cfg(all(target_arch = "arm", target_os = "none"))']
# uncomment ONE of these three option to make `cargo run` start a GDB session
# which option to pick depends on your system
# runner = "arm-none-eabi-gdb -q -x openocd.gdb"
runner = "gdb-multiarch -q -x openocd.gdb"
# runner = "gdb -q -x openocd.gdb"
rustflags = [
# LLD (shipped with the Rust toolchain) is used as the default linker
"-C", "link-arg=-Tlink.x",
# if you run into problems with LLD switch to the GNU linker by commenting out
# this line
# "-C", "linker=arm-none-eabi-ld",
# if you need to link to pre-compiled C libraries provided by a C toolchain
# use GCC as the linker by commenting out both lines above and then
# uncommenting the three lines below
# "-C", "linker=arm-none-eabi-gcc",
# "-C", "link-arg=-Wl,-Tlink.x",
# "-C", "link-arg=-nostartfiles",
]
[build]
# Pick ONE of these compilation targets
# target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0+
# target = "thumbv7m-none-eabi" # Cortex-M3
# target = "thumbv7em-none-eabi" # Cortex-M4 and Cortex-M7 (no FPU)
target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)

5
example-source/msp432-app/.gitignore vendored

@ -0,0 +1,5 @@ @@ -0,0 +1,5 @@
**/*.rs.bk
.#*
.gdb_history
Cargo.lock
target/

31
example-source/msp432-app/Cargo.toml

@ -0,0 +1,31 @@ @@ -0,0 +1,31 @@
[package]
authors = ["Levi Pearson <levipearson@gmail.com>"]
edition = "2018"
readme = "README.md"
name = "msp432-app"
version = "0.1.0"
[dependencies]
cortex-m = "0.5.8"
cortex-m-rt = "0.6.5"
cortex-m-semihosting = "0.3.2"
panic-halt = "0.2.0"
panic-semihosting = "*"
msp432p401r = { path = "../msp432p401r", features = ["rt"] }
# Uncomment for the panic example.
# panic-itm = "0.4.0"
# Uncomment for the allocator example.
# alloc-cortex-m = "0.3.5"
# this lets you use `cargo fix`!
[[bin]]
name = "msp432-app"
test = false
bench = false
[profile.release]
codegen-units = 1 # better optimizations
debug = true # symbols are nice and they don't increase the size on Flash
lto = true # better optimizations

129
example-source/msp432-app/README.md

@ -0,0 +1,129 @@ @@ -0,0 +1,129 @@
# `cortex-m-quickstart`
> A template for building applications for ARM Cortex-M microcontrollers
This project is developed and maintained by the [Cortex-M team][team].
## Dependencies
To build embedded programs using this template you'll need:
- Rust 1.31, 1.30-beta, nightly-2018-09-13 or a newer toolchain. e.g. `rustup
default beta`
- The `cargo generate` subcommand. [Installation
instructions](https://github.com/ashleygwilliams/cargo-generate#installation).
- `rust-std` components (pre-compiled `core` crate) for the ARM Cortex-M
targets. Run:
``` console
$ rustup target add thumbv6m-none-eabi thumbv7m-none-eabi thumbv7em-none-eabi thumbv7em-none-eabihf
```
## Using this template
**NOTE**: This is the very short version that only covers building programs. For
the long version, which additionally covers flashing, running and debugging
programs, check [the embedded Rust book][book].
[book]: https://rust-embedded.github.io/book
0. Before we begin you need to identify some characteristics of the target
device as these will be used to configure the project:
- The ARM core. e.g. Cortex-M3.
- Does the ARM core include an FPU? Cortex-M4**F** and Cortex-M7**F** cores do.
- How much Flash memory and RAM does the target device has? e.g. 256 KiB of
Flash and 32 KiB of RAM.
- Where are Flash memory and RAM mapped in the address space? e.g. RAM is
commonly located at address `0x2000_0000`.
You can find this information in the data sheet or the reference manual of your
device.
In this example we'll be using the STM32F3DISCOVERY. This board contains an
STM32F303VCT6 microcontroller. This microcontroller has:
- A Cortex-M4F core that includes a single precision FPU
- 256 KiB of Flash located at address 0x0800_0000.
- 40 KiB of RAM located at address 0x2000_0000. (There's another RAM region but
for simplicity we'll ignore it).
1. Instantiate the template.
``` console
$ cargo generate --git https://github.com/rust-embedded/cortex-m-quickstart
Project Name: app
Creating project called `app`...
Done! New project created /tmp/app
$ cd app
```
2. Set a default compilation target. There are four options as mentioned at the
bottom of `.cargo/config`. For the STM32F303VCT6, which has a Cortex-M4F
core, we'll pick the `thumbv7em-none-eabihf` target.
``` console
$ tail -n6 .cargo/config
```
``` toml
[build]
# Pick ONE of these compilation targets
# target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0+
# target = "thumbv7m-none-eabi" # Cortex-M3
# target = "thumbv7em-none-eabi" # Cortex-M4 and Cortex-M7 (no FPU)
target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
```
3. Enter the memory region information into the `memory.x` file.
``` console
$ cat memory.x
/* Linker script for the STM32F303VCT6 */
MEMORY
{
/* NOTE 1 K = 1 KiBi = 1024 bytes */
FLASH : ORIGIN = 0x08000000, LENGTH = 256K
RAM : ORIGIN = 0x20000000, LENGTH = 40K
}
```
4. Build the template application or one of the examples.
``` console
$ cargo build
```
# License
This template is licensed under either of
- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
http://www.apache.org/licenses/LICENSE-2.0)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
at your option.
## Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
## Code of Conduct
Contribution to this crate is organized under the terms of the [Rust Code of
Conduct][CoC], the maintainer of this crate, the [Cortex-M team][team], promises
to intervene to uphold that code of conduct.
[CoC]: https://www.rust-lang.org/policies/code-of-conduct
[team]: https://github.com/rust-embedded/wg#the-cortex-m-team

18
example-source/msp432-app/build.rs

@ -0,0 +1,18 @@ @@ -0,0 +1,18 @@
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::PathBuf;
fn main() {
// Put the linker script somewhere the linker can find it
let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
File::create(out.join("memory.x"))
.unwrap()
.write_all(include_bytes!("memory.x"))
.unwrap();
println!("cargo:rustc-link-search={}", out.display());
// Only re-run the build script when memory.x is changed,
// instead of when any part of the source code changes.
println!("cargo:rerun-if-changed=memory.x");
}

37
example-source/msp432-app/memory.x

@ -0,0 +1,37 @@ @@ -0,0 +1,37 @@
MEMORY
{
/* NOTE 1 K = 1 KiBi = 1024 bytes */
/* Code Zone - 0x00000000 to 0x1FFFFFFF */
FLASH : ORIGIN = 0x00000000, LENGTH = 256K
RAM_ALIAS : ORIGIN = 0x01000000, LENGTH = 64K
ROM : ORIGIN = 0x02000000, LENGTH = 32K
/* SRAM Region - 0x00000000 to 0x003FFFFF */
RAM : ORIGIN = 0x20000000, LENGTH = 64K
RAM_BITBAND : ORIGIN = 0x22000000, LENGTH = 1024K
}
/* This is where the call stack will be allocated. */
/* The stack is of the full descending type. */
/* You may want to use this variable to locate the call stack and static
variables in different memory regions. Below is shown the default value */
/* _stack_start = ORIGIN(RAM) + LENGTH(RAM); */
/* You can use this symbol to customize the location of the .text section */
/* If omitted the .text section will be placed right after the .vector_table
section */
/* This is required only on microcontrollers that store some configuration right
after the vector table */
/* _stext = ORIGIN(FLASH) + 0x400; */
/* Example of putting non-initialized variables into custom RAM locations. */
/* This assumes you have defined a region RAM2 above, and in the Rust
sources added the attribute `#[link_section = ".ram2bss"]` to the data
you want to place there. */
/* Note that the section will not be zero-initialized by the runtime! */
/* SECTIONS {
.ram2bss (NOLOAD) : ALIGN(4) {
*(.ram2bss);
. = ALIGN(4);
} > RAM2
} INSERT AFTER .bss;
*/

6
example-source/msp432-app/openocd.cfg

@ -0,0 +1,6 @@ @@ -0,0 +1,6 @@
# OpenOCD configuration for the MSP432P401R LaunchPad
source [find interface/xds110.cfg]
adapter_khz 2500
transport select swd
source [find target/ti_msp432.cfg]

35
example-source/msp432-app/openocd.gdb

@ -0,0 +1,35 @@ @@ -0,0 +1,35 @@
target extended-remote :3333
# print demangled symbols
set print asm-demangle on
# set backtrace limit to not have infinite backtrace loops
set backtrace limit 32
# detect unhandled exceptions, hard faults and panics
break DefaultHandler
break HardFault
break rust_begin_unwind
# *try* to stop at the user entry point (it might be gone due to inlining)
break main
monitor arm semihosting enable
# # send captured ITM to the file itm.fifo
# # (the microcontroller SWO pin must be connected to the programmer SWO pin)
# # 8000000 must match the core clock frequency
# monitor tpiu config internal itm.txt uart off 8000000
# # OR: make the microcontroller SWO pin output compatible with UART (8N1)
# # 8000000 must match the core clock frequency
# # 2000000 is the frequency of the SWO pin
# monitor tpiu config external uart off 8000000 2000000
# # enable ITM port 0
# monitor itm port 0 on
#load
# start the process but immediately halt the processor
#stepi

96
example-source/msp432-app/original-examples/crash.rs

@ -0,0 +1,96 @@ @@ -0,0 +1,96 @@
//! Debugging a crash (exception)
//!
//! Most crash conditions trigger a hard fault exception, whose handler is defined via
//! `exception!(HardFault, ..)`. The `HardFault` handler has access to the exception frame, a
//! snapshot of the CPU registers at the moment of the exception.
//!
//! This program crashes and the `HardFault` handler prints to the console the contents of the
//! `ExceptionFrame` and then triggers a breakpoint. From that breakpoint one can see the backtrace
//! that led to the exception.
//!
//! ``` text
//! (gdb) continue
//! Program received signal SIGTRAP, Trace/breakpoint trap.
//! __bkpt () at asm/bkpt.s:3
//! 3 bkpt
//!
//! (gdb) backtrace
//! #0 __bkpt () at asm/bkpt.s:3
//! #1 0x080030b4 in cortex_m::asm::bkpt () at $$/cortex-m-0.5.0/src/asm.rs:19
//! #2 rust_begin_unwind (args=..., file=..., line=99, col=5) at $$/panic-semihosting-0.2.0/src/lib.rs:87
//! #3 0x08001d06 in core::panicking::panic_fmt () at libcore/panicking.rs:71
//! #4 0x080004a6 in crash::hard_fault (ef=0x20004fa0) at examples/crash.rs:99
//! #5 0x08000548 in UserHardFault (ef=0x20004fa0) at <exception macros>:10
//! #6 0x0800093a in HardFault () at asm.s:5
//! Backtrace stopped: previous frame identical to this frame (corrupt stack?)
//! ```
//!
//! In the console output one will find the state of the Program Counter (PC) register at the time
//! of the exception.
//!
//! ``` text
//! panicked at 'HardFault at ExceptionFrame {
//! r0: 0x2fffffff,
//! r1: 0x2fffffff,
//! r2: 0x080051d4,
//! r3: 0x080051d4,
//! r12: 0x20000000,
//! lr: 0x08000435,
//! pc: 0x08000ab6,
//! xpsr: 0x61000000
//! }', examples/crash.rs:106:5
//! ```
//!
//! This register contains the address of the instruction that caused the exception. In GDB one can
//! disassemble the program around this address to observe the instruction that caused the
//! exception.
//!
//! ``` text
//! (gdb) disassemble/m 0x08000ab6
//! Dump of assembler code for function core::ptr::read_volatile:
//! 451 pub unsafe fn read_volatile<T>(src: *const T) -> T {
//! 0x08000aae <+0>: sub sp, #16
//! 0x08000ab0 <+2>: mov r1, r0
//! 0x08000ab2 <+4>: str r0, [sp, #8]
//!
//! 452 intrinsics::volatile_load(src)
//! 0x08000ab4 <+6>: ldr r0, [sp, #8]
//! -> 0x08000ab6 <+8>: ldr r0, [r0, #0]
//! 0x08000ab8 <+10>: str r0, [sp, #12]
//! 0x08000aba <+12>: ldr r0, [sp, #12]
//! 0x08000abc <+14>: str r1, [sp, #4]
//! 0x08000abe <+16>: str r0, [sp, #0]
//! 0x08000ac0 <+18>: b.n 0x8000ac2 <core::ptr::read_volatile+20>
//!
//! 453 }
//! 0x08000ac2 <+20>: ldr r0, [sp, #0]
//! 0x08000ac4 <+22>: add sp, #16
//! 0x08000ac6 <+24>: bx lr
//!
//! End of assembler dump.
//! ```
//!
//! `ldr r0, [r0, #0]` caused the exception. This instruction tried to load (read) a 32-bit word
//! from the address stored in the register `r0`. Looking again at the contents of `ExceptionFrame`
//! we see that the `r0` contained the address `0x2FFF_FFFF` when this instruction was executed.
//!
//! ---
#![no_main]
#![no_std]
extern crate panic_halt;
use core::ptr;
use cortex_m_rt::entry;
#[entry]
fn main() -> ! {
unsafe {
// read an address outside of the RAM region; this causes a HardFault exception
ptr::read_volatile(0x2FFF_FFFF as *const u32);
}
loop {}
}

37
example-source/msp432-app/original-examples/exception.rs

@ -0,0 +1,37 @@ @@ -0,0 +1,37 @@
//! Overriding an exception handler
//!
//! You can override an exception handler using the [`#[exception]`][1] attribute.
//!
//! [1]: https://rust-embedded.github.io/cortex-m-rt/0.6.1/cortex_m_rt_macros/fn.exception.html
//!
//! ---
#![deny(unsafe_code)]
#![no_main]
#![no_std]
extern crate panic_halt;
use cortex_m::peripheral::syst::SystClkSource;
use cortex_m::Peripherals;
use cortex_m_rt::{entry, exception};
use cortex_m_semihosting::hprint;
#[entry]
fn main() -> ! {
let p = Peripherals::take().unwrap();
let mut syst = p.SYST;
// configures the system timer to trigger a SysTick exception every second
syst.set_clock_source(SystClkSource::Core);
syst.set_reload(8_000_000); // period = 1s
syst.enable_counter();
syst.enable_interrupt();
loop {}
}
#[exception]
fn SysTick() {
hprint!(".").unwrap();
}

20
example-source/msp432-app/original-examples/hello.rs

@ -0,0 +1,20 @@ @@ -0,0 +1,20 @@
//! Prints "Hello, world!" on the host console using semihosting
#![no_main]
#![no_std]
extern crate panic_halt;
use cortex_m_rt::entry;
use cortex_m_semihosting::{debug, hprintln};
#[entry]
fn main() -> ! {
hprintln!("Hello, world!").unwrap();
// exit QEMU
// NOTE do not run this on hardware; it can corrupt OpenOCD state
debug::exit(debug::EXIT_SUCCESS);
loop {}
}

33
example-source/msp432-app/original-examples/itm.rs

@ -0,0 +1,33 @@ @@ -0,0 +1,33 @@
//! Sends "Hello, world!" through the ITM port 0
//!
//! ITM is much faster than semihosting. Like 4 orders of magnitude or so.
//!
//! **NOTE** Cortex-M0 chips don't support ITM.
//!
//! You'll have to connect the microcontroller's SWO pin to the SWD interface. Note that some
//! development boards don't provide this option.
//!
//! You'll need [`itmdump`] to receive the message on the host plus you'll need to uncomment two
//! `monitor` commands in the `.gdbinit` file.
//!
//! [`itmdump`]: https://docs.rs/itm/0.2.1/itm/
//!
//! ---
#![no_main]
#![no_std]
extern crate panic_halt;
use cortex_m::{iprintln, Peripherals};
use cortex_m_rt::entry;
#[entry]
fn main() -> ! {
let mut p = Peripherals::take().unwrap();
let stim = &mut p.ITM.stim[0];
iprintln!(stim, "Hello, world!");
loop {}
}

28
example-source/msp432-app/original-examples/panic.rs

@ -0,0 +1,28 @@ @@ -0,0 +1,28 @@
//! Changing the panicking behavior
//!
//! The easiest way to change the panicking behavior is to use a different [panic handler crate][0].
//!
//! [0]: https://crates.io/keywords/panic-impl
#![no_main]
#![no_std]
// Pick one of these panic handlers:
// `panic!` halts execution; the panic message is ignored
extern crate panic_halt;
// Reports panic messages to the host stderr using semihosting
// NOTE to use this you need to uncomment the `panic-semihosting` dependency in Cargo.toml
// extern crate panic_semihosting;
// Logs panic messages using the ITM (Instrumentation Trace Macrocell)
// NOTE to use this you need to uncomment the `panic-itm` dependency in Cargo.toml
// extern crate panic_itm;
use cortex_m_rt::entry;
#[entry]
fn main() -> ! {
panic!("Oops")
}

57
example-source/msp432-app/original-examples/test_on_host.rs

@ -0,0 +1,57 @@ @@ -0,0 +1,57 @@
//! Conditionally compiling tests with std and our executable with no_std.
//!
//! Rust's built in unit testing framework requires the standard library,
//! but we need to build our final executable with no_std.
//! The testing framework also generates a `main` method, so we need to only use the `#[entry]`
//! annotation when building our final image.
//! For more information on why this example works, see this excellent blog post.
//! https://os.phil-opp.com/unit-testing/
//!
//! Running this example:
//!
//! Ensure there are no targets specified under `[build]` in `.cargo/config`
//! In order to make this work, we lose the convenience of having a default target that isn't the
//! host.
//!
//! cargo build --example test_on_host --target thumbv7m-none-eabi
//! cargo test --example test_on_host
#![cfg_attr(test, allow(unused_imports))]
#![cfg_attr(not(test), no_std)]
#![cfg_attr(not(test), no_main)]
// pick a panicking behavior
#[cfg(not(test))]
extern crate panic_halt; // you can put a breakpoint on `rust_begin_unwind` to catch panics
// extern crate panic_abort; // requires nightly
// extern crate panic_itm; // logs messages over ITM; requires ITM support
// extern crate panic_semihosting; // logs messages to the host stderr; requires a debugger
use cortex_m::asm;
use cortex_m_rt::entry;
#[cfg(not(test))]
#[entry]
fn main() -> ! {
asm::nop(); // To not have main optimize to abort in release mode, remove when you add code
loop {
// your code goes here
}
}
fn add(a: i32, b: i32) -> i32 {
a + b
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn foo() {
println!("tests work!");
assert!(2 == add(1,1));
}
}

81
example-source/msp432-app/src/main.rs

@ -0,0 +1,81 @@ @@ -0,0 +1,81 @@
#![no_std]
#![no_main]
// pick a panicking behavior
extern crate panic_halt; // you can put a breakpoint on `rust_begin_unwind` to catch panics
// extern crate panic_abort; // requires nightly
// extern crate panic_itm; // logs messages over ITM; requires ITM support
// extern crate panic_semihosting; // logs messages to the host stderr; requires a debugger
use cortex_m::{self, peripheral::syst::SystClkSource};
use cortex_m_rt::entry;
use msp432p401r;
use core::num::Wrapping;
const PIN0: u8 = (1u8 << 0);
const PIN1: u8 = (1u8 << 1);
const PIN2: u8 = (1u8 << 2);
//const PIN3: u8 = (1u8 << 3);
const PIN4: u8 = (1u8 << 4);
//const PIN5: u8 = (1u8 << 5);
//const PIN6: u8 = (1u8 << 6);
//const PIN7: u8 = (1u8 << 7);
const WDOG_PWORD: u8 = 0x5a;
#[entry]
fn main() -> ! {
let cp = cortex_m::Peripherals::take().unwrap();
let p = msp432p401r::Peripherals::take().unwrap();
let mut syst = cp.SYST;
let wdt = p.WDT_A;
let dio = p.DIO;
// disable watchdog timer
wdt.wdtctl.write(|w| unsafe {
w.wdtpw().bits(WDOG_PWORD)
.wdthold().wdthold_1()
});
// configure the system timer to wrap around every ~1 second
syst.set_clock_source(SystClkSource::Core);
syst.set_reload(20_000);
syst.enable_counter();
// configure digital IO pins
dio.padir.modify(|_r, w| unsafe {
w.p1dir().bits(PIN0)
.p2dir().bits(PIN0 | PIN1 | PIN2)
});
// Enable pull-up on P1.4 switch
dio.paren.modify(|_r, w| unsafe { w.p1ren().bits(PIN4) });
dio.pads.modify(|_r, w| unsafe { w.p1ds().bits(PIN4) });
// Turn on LED1 on P1.0 and enable pull-up on P1.1 switch
dio.paout.write(|w| unsafe {
w.p1out().bits(PIN0 | PIN4)
.p2out().bits(0)
});
let mut count: Wrapping<u16> = Wrapping(0);
let mut input: u8;
loop {
while !syst.has_wrapped() {}
// The button pulls the input to GND
input = (dio.pain.read().p1in().bits() & PIN4) >> 4;
count += Wrapping(1);
let _led1: u8 = ((count.0 & 0x0100) >> 8) as u8;
let led2: u8 = ((count.0 & 0b0000_0111_0000_0000) >> 8) as u8;
// toggle LEDs
dio.paout.write(|w| unsafe {
w.p1out().bits(input | PIN4)
.p2out().bits(led2)
});
}
}

1
example-source/msp432-app/upload.sh

@ -0,0 +1 @@ @@ -0,0 +1 @@
sudo /home/levi/energia-1.6.10E18/hardware/tools/DSLite/DebugServer/bin/DSLite load --config /home/levi/energia-1.6.10E18/hardware/tools/DSLite/MSP_EXP432P401R.ccxml --file ~/Projects/Rust/msp432-app/target/thumbv7em-none-eabihf/debug/msp432-app

3
example-source/msp432-hal/.gitignore vendored

@ -0,0 +1,3 @@ @@ -0,0 +1,3 @@
/target
**/*.rs.bk
Cargo.lock

19
example-source/msp432-hal/Cargo.toml

@ -0,0 +1,19 @@ @@ -0,0 +1,19 @@
[package]
name = "msp432-hal"
version = "0.1.0"
authors = ["Levi Pearson <levipearson@gmail.com>"]
categories = ["embedded", "hardware-support", "no-std"]
description = "HAL for the TI MSP432 family of microcontrollers"
keywords = ["arm", "cortex-m", "msp432", "hal"]
edition = "2018"
[dependencies]
cortex-m = "0.5"
embedded-hal = "0.2"
nb = "0.1"
msp432p401r = { path = "../msp432p401r" }
void = { version = "1.0", default-features = false }
cast = { version = "0.2", default-features = false }
[features]
rt = ["msp432p401r/rt"]

63
example-source/msp432-hal/src/cs.rs

@ -0,0 +1,63 @@ @@ -0,0 +1,63 @@
//! Clock System
use core::cmp;
use pac::{cs, CS};
use crate::time::Hertz;
/// Extension trait that constrains the `CS` peripheral
pub trait CsExt {
/// Constrains the `CS` peripheral so that it plays nicely with other abstractions
fn constrain(self) -> Cs;
}
impl CsExt for CS {
fn constrain(self) -> Cs {
Cs {
}
}
}
/*
+--------+-----------------------+---------------+-------------------------------------+
| Clock | Default Clock Source | Default Clock | Description |
| | | Frequency | |
+========+=======================+===============+=====================================+
| MCLK | DCO | 3 MHz | Master Clock - Sources CPU and |
| | | | peripherals |
+--------+-----------------------+---------------+-------------------------------------+
| HSMCLK | DCO | 3 MHz | Subsystem Master Clock - Sources |
| | | | peripherals |
+--------+-----------------------+---------------+-------------------------------------+
| SMCLK | DCO | 3 MHz | Low-speed subsystem master clock - |
| | | | Sources peripherals |
+--------+-----------------------+---------------+-------------------------------------+
| ACLK | LFXT (or REFO if no | 32.768 kHz | Auxiliary clock - Sources |
| | crystal present) | | peripherals |
+--------+-----------------------+---------------+-------------------------------------+
| BCLK | LFXT (or REFO if no | 32.768 kHz | Low-speed backup domain clock - |
| | crystal present) | | Sources LPM peripherals |
+--------+-----------------------+---------------+-------------------------------------+
*/
pub struct Cs {
}
/// Frozen clock frequencies
///
/// This value holds the current clocks frequencies and indicates that they can
/// no longer be changed
#[derive(Clone, Copy)]
pub struct Clocks {
sysclk: Hertz,
}
impl Clocks {
/// Returns the system (core) frequency
pub fn sysclk(&self) -> Hertz {
self.sysclk
}
}

74
example-source/msp432-hal/src/delay.rs

@ -0,0 +1,74 @@ @@ -0,0 +1,74 @@
//! Delays
use cast::u32;
use cortex_m::peripheral::syst::SystClkSource;
use cortex_m::peripheral::SYST;
use hal::blocking::delay::{DelayMs, DelayUs};
use crate::cs::Clocks;
/// System timer (SysTick) as a delay provider
pub struct Delay {
clocks: Clocks,
syst: SYST,
}
impl Delay {
/// Configure the system timer (SysTick) as a delay provider
pub fn new(mut syst: SYST, clocks: Clocks) -> Self {
syst.set_clock_source(SystClkSource::Core);
Delay { syst, clocks }
}
/// Release the system timer (SysTick) resource
pub fn free(self) -> SYST {
self.syst
}
}
impl DelayMs<u32> for Delay {
fn delay_ms(&mut self, ms: u32) {
self.delay_us(ms * 1_000);
}
}
impl DelayMs<u16> for Delay {
fn delay_ms(&mut self, ms: u16) {
self.delay_ms(u32(ms));
}
}
impl DelayMs<u8> for Delay {
fn delay_ms(&mut self, ms: u8) {
self.delay_ms(u32(ms));
}
}
impl DelayUs<u32> for Delay {
fn delay_us(&mut self, us: u32) {
let rvr = us * (self.clocks.sysclk().0 / 1_000_000);
assert!(rvr < (1 << 24));
self.syst.set_reload(rvr);
self.syst.clear_current();
self.syst.enable_counter();
while !self.syst.has_wrapped() {}
self.syst.disable_counter();
}
}
impl DelayUs<u16> for Delay {
fn delay_us(&mut self, us: u16) {
self.delay_us(u32(us));
}
}
impl DelayUs<u8> for Delay {
fn delay_us(&mut self, us: u8) {
self.delay_us(u32(us));
}
}

22
example-source/msp432-hal/src/gpio.rs

@ -0,0 +1,22 @@ @@ -0,0 +1,22 @@
//! General Purpose Input / Output
use pac::DIO;
use core::marker::PhantomData;
use hal::digital::OutputPin;
pub trait GpioExt {
type Parts;
/// Consume and split the device into its constituent parts
fn split(self) -> Self::Parts;
}
/// Represents a pin configured for input.
pub struct Input<MODE> {
_mode: PhantomData<MODE>,
}
/// Represents a pin configured for output.
pub struct Output<MODE> {
_mode: PhantomData<MODE>,
}

26
example-source/msp432-hal/src/lib.rs

@ -0,0 +1,26 @@ @@ -0,0 +1,26 @@
//! HAL for the MSP432 family of microcontrollers
//!
//! This is an implementation of the [`embedded-hal`] traits for the MSP432 family of
//! microcontrollers.
//!
//! [`embedded-hal`]: https://github.com/japaric/embedded-hal
//!
//! # Usage
//!
//! To build applications (binary crates) using this crate follow the [cortex-m-quickstart]
//! instructions and add this crate as a dependency in step number 5 and make sure you enable the
//! "rt" Cargo feature of this crate.
//!
//! [cortex-m-quickstart]: https://docs.rs/cortex-m-quickstart/~0.3
#![warn(missing_docs)]
#![no_std]
extern crate embedded_hal as hal;
extern crate msp432p401r as pac;
pub mod prelude;
pub mod gpio;
pub mod delay;
pub mod cs;
pub mod time;

3
example-source/msp432-hal/src/prelude.rs

@ -0,0 +1,3 @@ @@ -0,0 +1,3 @@
//! Prelude
pub use hal::prelude::*;

117
example-source/msp432-hal/src/time.rs

@ -0,0 +1,117 @@ @@ -0,0 +1,117 @@
//! Time units
use cortex_m::peripheral::DWT;
use crate::cs::Clocks;
/// Bits per seconds
#[derive(Clone, Copy)]
pub struct Bps(pub u32);
/// Hertz
#[derive(Clone, Copy)]
pub struct Hertz(pub u32);
/// KiloHertz
#[derive(Clone, Copy)]
pub struct KiloHertz(pub u32);
/// MegaHertz
#[derive(Clone, Copy)]
pub struct MegaHertz(pub u32);
/// Extension trait to add convenience methods to `u32`
pub trait U32Ext {
/// Wrap in `Bps`
fn bps(self) -> Bps;
/// Wrap in `Hertz`
fn hz(self) -> Hertz;
/// Wrap in `KiloHertz`
fn khz(self) -> KiloHertz;
/// Wrap in `MegaHertz`
fn mhz(self) -> MegaHertz;
}
impl U32Ext for u32 {
fn bps(self) -> Bps {
Bps(self)
}
fn hz(self) -> Hertz {
Hertz(self)
}
fn khz(self) -> KiloHertz {
KiloHertz(self)
}
fn mhz(self) -> MegaHertz {
MegaHertz(self)
}
}
impl Into<Hertz> for KiloHertz {
fn into(self) -> Hertz {
Hertz(self.0 * 1_000)
}
}
impl Into<Hertz> for MegaHertz {
fn into(self) -> Hertz {
Hertz(self.0 * 1_000_000)
}
}
impl Into<KiloHertz> for MegaHertz {
fn into(self) -> KiloHertz {
KiloHertz(self.0 * 1_000)
}
}
/// A monotonic nondecreasing timer
#[derive(Clone, Copy)]
pub struct MonoTimer {
frequency: Hertz,
}
impl MonoTimer {
/// Create a new monotonic timer
pub fn new(mut dwt: DWT, clocks: Clocks) -> Self {
dwt.enable_cycle_counter();
// can't stop or reset CYCCNT
drop(dwt);
MonoTimer {
frequency: clocks.sysclk(),
}
}
/// Return the frequency at which the timer is operating
pub fn frequency(&self) -> Hertz {
self.frequency
}
/// Returns an `Instant` corresponding to "now"
pub fn now(&self) -> Instant {
Instant {
now: DWT::get_cycle_count(),
}
}
}
/// A measurement from a monotonically nondecreasing clock
#[derive(Clone, Copy)]
pub struct Instant {
now: u32,
}
impl Instant {
/// Ticks elapsed since the `Instant` was created
pub fn elapsed(&self) -> u32 {
DWT::get_cycle_count().wrapping_sub(self.now)
}
}

3
example-source/msp432p401r/.gitignore vendored

@ -0,0 +1,3 @@ @@ -0,0 +1,3 @@
/target
**/*.rs.bk
Cargo.lock

17
example-source/msp432p401r/Cargo.toml

@ -0,0 +1,17 @@ @@ -0,0 +1,17 @@
[package]
name = "msp432p401r"
version = "0.1.0"
authors = ["Levi Pearson <levipearson@gmail.com>"]
edition = "2018"
[dependencies]
bare-metal = "0.2.0"
cortex-m = "0.5.8"
vcell = "0.1.0"
[dependencies.cortex-m-rt]
optional = true
version = "0.6.5"
[features]
rt = ["cortex-m-rt/device"]

42237
example-source/msp432p401r/MSP432P401R.svd

File diff suppressed because it is too large Load Diff

16
example-source/msp432p401r/build.rs

@ -0,0 +1,16 @@ @@ -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");
}

42
example-source/msp432p401r/device.x

@ -0,0 +1,42 @@ @@ -0,0 +1,42 @@
PROVIDE(PSS_IRQ = DefaultHandler);
PROVIDE(CS_IRQ = DefaultHandler);
PROVIDE(PCM_IRQ = DefaultHandler);
PROVIDE(WDT_A_IRQ = DefaultHandler);
PROVIDE(FPU_IRQ = DefaultHandler);
PROVIDE(FLCTL_IRQ = DefaultHandler);
PROVIDE(COMP_E0_IRQ = DefaultHandler);
PROVIDE(COMP_E1_IRQ = DefaultHandler);
PROVIDE(TA0_0_IRQ = DefaultHandler);
PROVIDE(TA0_N_IRQ = DefaultHandler);
PROVIDE(TA1_0_IRQ = DefaultHandler);
PROVIDE(TA1_N_IRQ = DefaultHandler);
PROVIDE(TA2_0_IRQ = DefaultHandler);
PROVIDE(TA2_N_IRQ = DefaultHandler);
PROVIDE(TA3_0_IRQ = DefaultHandler);
PROVIDE(TA3_N_IRQ = DefaultHandler);
PROVIDE(EUSCIA0_IRQ = DefaultHandler);
PROVIDE(EUSCIA1_IRQ = DefaultHandler);
PROVIDE(EUSCIA2_IRQ = DefaultHandler);
PROVIDE(EUSCIA3_IRQ = DefaultHandler);
PROVIDE(EUSCIB0_IRQ = DefaultHandler);
PROVIDE(EUSCIB1_IRQ = DefaultHandler);
PROVIDE(EUSCIB2_IRQ = DefaultHandler);
PROVIDE(EUSCIB3_IRQ = DefaultHandler);
PROVIDE(ADC14_IRQ = DefaultHandler);
PROVIDE(T32_INT1_IRQ = DefaultHandler);
PROVIDE(T32_INT2_IRQ = DefaultHandler);
PROVIDE(T32_INTC_IRQ = DefaultHandler);
PROVIDE(AES256_IRQ = DefaultHandler);
PROVIDE(RTC_C_IRQ = DefaultHandler);
PROVIDE(DMA_ERR_IRQ = DefaultHandler);
PROVIDE(DMA_INT3_IRQ = DefaultHandler);
PROVIDE(DMA_INT2_IRQ = DefaultHandler);
PROVIDE(DMA_INT1_IRQ = DefaultHandler);
PROVIDE(DMA_INT0_IRQ = DefaultHandler);
PROVIDE(PORT1_IRQ = DefaultHandler);
PROVIDE(PORT2_IRQ = DefaultHandler);
PROVIDE(PORT3_IRQ = DefaultHandler);
PROVIDE(PORT4_IRQ = DefaultHandler);
PROVIDE(PORT5_IRQ = DefaultHandler);
PROVIDE(PORT6_IRQ = DefaultHandler);

125
example-source/msp432p401r/src/adc14.rs

@ -0,0 +1,125 @@ @@ -0,0 +1,125 @@
#[doc = r" Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - Control 0 Register"]
pub adc14ctl0: ADC14CTL0,
#[doc = "0x04 - Control 1 Register"]
pub adc14ctl1: ADC14CTL1,
#[doc = "0x08 - Window Comparator Low Threshold 0 Register"]
pub adc14lo0: ADC14LO0,
#[doc = "0x0c - Window Comparator High Threshold 0 Register"]
pub adc14hi0: ADC14HI0,
#[doc = "0x10 - Window Comparator Low Threshold 1 Register"]
pub adc14lo1: ADC14LO1,
#[doc = "0x14 - Window Comparator High Threshold 1 Register"]
pub adc14hi1: ADC14HI1,
#[doc = "0x18 - Conversion Memory Control Register"]
pub adc14mctl: [ADC14MCTL; 32],
#[doc = "0x98 - Conversion Memory Register"]
pub adc14mem: [ADC14MEM; 32],
_reserved0: [u8; 36usize],
#[doc = "0x13c - Interrupt Enable 0 Register"]
pub adc14ier0: ADC14IER0,
#[doc = "0x140 - Interrupt Enable 1 Register"]
pub adc14ier1: ADC14IER1,
#[doc = "0x144 - Interrupt Flag 0 Register"]
pub adc14ifgr0: ADC14IFGR0,
#[doc = "0x148 - Interrupt Flag 1 Register"]
pub adc14ifgr1: ADC14IFGR1,
#[doc = "0x14c - Clear Interrupt Flag 0 Register"]
pub adc14clrifgr0: ADC14CLRIFGR0,
#[doc = "0x150 - Clear Interrupt Flag 1 Register"]
pub adc14clrifgr1: ADC14CLRIFGR1,
#[doc = "0x154 - Interrupt Vector Register"]
pub adc14iv: ADC14IV,
}
#[doc = "Control 0 Register"]
pub struct ADC14CTL0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Control 0 Register"]
pub mod adc14ctl0;
#[doc = "Control 1 Register"]
pub struct ADC14CTL1 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Control 1 Register"]
pub mod adc14ctl1;
#[doc = "Window Comparator Low Threshold 0 Register"]
pub struct ADC14LO0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Window Comparator Low Threshold 0 Register"]
pub mod adc14lo0;
#[doc = "Window Comparator High Threshold 0 Register"]
pub struct ADC14HI0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Window Comparator High Threshold 0 Register"]
pub mod adc14hi0;
#[doc = "Window Comparator Low Threshold 1 Register"]
pub struct ADC14LO1 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Window Comparator Low Threshold 1 Register"]
pub mod adc14lo1;
#[doc = "Window Comparator High Threshold 1 Register"]
pub struct ADC14HI1 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Window Comparator High Threshold 1 Register"]
pub mod adc14hi1;
#[doc = "Conversion Memory Control Register"]
pub struct ADC14MCTL {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Conversion Memory Control Register"]
pub mod adc14mctl;
#[doc = "Conversion Memory Register"]
pub struct ADC14MEM {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Conversion Memory Register"]
pub mod adc14mem;
#[doc = "Interrupt Enable 0 Register"]
pub struct ADC14IER0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Interrupt Enable 0 Register"]
pub mod adc14ier0;
#[doc = "Interrupt Enable 1 Register"]
pub struct ADC14IER1 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Interrupt Enable 1 Register"]
pub mod adc14ier1;
#[doc = "Interrupt Flag 0 Register"]
pub struct ADC14IFGR0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Interrupt Flag 0 Register"]
pub mod adc14ifgr0;
#[doc = "Interrupt Flag 1 Register"]
pub struct ADC14IFGR1 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Interrupt Flag 1 Register"]
pub mod adc14ifgr1;
#[doc = "Clear Interrupt Flag 0 Register"]
pub struct ADC14CLRIFGR0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Clear Interrupt Flag 0 Register"]
pub mod adc14clrifgr0;
#[doc = "Clear Interrupt Flag 1 Register"]
pub struct ADC14CLRIFGR1 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Clear Interrupt Flag 1 Register"]
pub mod adc14clrifgr1;
#[doc = "Interrupt Vector Register"]
pub struct ADC14IV {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Interrupt Vector Register"]
pub mod adc14iv;

2045
example-source/msp432p401r/src/adc14/adc14clrifgr0.rs

File diff suppressed because it is too large Load Diff

442
example-source/msp432p401r/src/adc14/adc14clrifgr1.rs

@ -0,0 +1,442 @@ @@ -0,0 +1,442 @@
#[doc = r" Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::ADC14CLRIFGR1 {
#[doc = r" Modifies the contents of the register"]
#[inline]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
let r = R { bits: bits };
let mut w = W { bits: bits };
f(&r, &mut w);
self.register.set(w.bits);
}
#[doc = r" Reads the contents of the register"]
#[inline]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r" Writes to the register"]
#[inline]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
let mut w = W::reset_value();
f(&mut w);
self.register.set(w.bits);
}
#[doc = r" Writes the reset value to the register"]
#[inline]
pub fn reset(&self) {
self.write(|w| w)
}
}
#[doc = "Values that can be written to the field `CLRADC14INIFG`"]
pub enum CLRADC14INIFGW {
#[doc = "no effect"]
CLRADC14INIFG_0,
#[doc = "clear pending interrupt flag"]
CLRADC14INIFG_1,
}
impl CLRADC14INIFGW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
CLRADC14INIFGW::CLRADC14INIFG_0 => false,
CLRADC14INIFGW::CLRADC14INIFG_1 => true,
}
}
}
#[doc = r" Proxy"]
pub struct _CLRADC14INIFGW<'a> {
w: &'a mut W,
}
impl<'a> _CLRADC14INIFGW<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CLRADC14INIFGW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "no effect"]
#[inline]
pub fn clradc14inifg_0(self) -> &'a mut W {
self.variant(CLRADC14INIFGW::CLRADC14INIFG_0)
}
#[doc = "clear pending interrupt flag"]
#[inline]
pub fn clradc14inifg_1(self) -> &'a mut W {
self.variant(CLRADC14INIFGW::CLRADC14INIFG_1)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 1;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CLRADC14LOIFG`"]
pub enum CLRADC14LOIFGW {
#[doc = "no effect"]
CLRADC14LOIFG_0,
#[doc = "clear pending interrupt flag"]
CLRADC14LOIFG_1,
}