lets try without cross..

Reviewed-on: #4

.github/workflows/ci.yml

@@ -16,14 +16,11 @@ jobs:
           override: true
       - uses: actions-rs/cargo@v1
         with:
-          use-cross: true
           command: check
-          args: --target thumbv6m-none-eabi
       - uses: actions-rs/cargo@v1
         with:
-          use-cross: true
           command: check
-          args: --examples --target thumbv6m-none-eabi
+          args: --examples
 
   fmt:
     name: Rustfmt
@@ -55,9 +52,8 @@ jobs:
       - run: rustup component add clippy
       - uses: actions-rs/cargo@v1
         with:
-          use-cross: true
           command: clippy
-          args: --target thumbv6m-none-eabi -- -D warnings
+          args: -- -D warnings
 
   ci:
       if: ${{ success() }}

CHANGELOG.md

@@ -8,6 +8,26 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [unreleased]
 
+## [v0.4.0]
+
+- Update manifest file to have correct links and license
+- Update some dependencies
+  - `cortex-m-rtic` (dev-depencency) to 1.1.2
+  - Other dependencies: Only revision has changed
+
+## [v0.3.2]
+
+- Bump HAL dependency to v0.5.0. Changed API, especially for IRQ handling
+
+## [v0.3.1]
+
+- Updated ADC code and dependency
+
+## [v0.3.0]
+
+- Completed baseline features to support all sensors on the REB1 sevice
+- Relicensed as Apache-2.0 and moved to https://egit.irs.uni-stuttgart.de/rust/vorago-reb1
+
 ## [v0.2.3]
 
 - Added basic accelerometer example. Board in not populated so it is not complete, but

Cargo.toml

@@ -1,47 +1,38 @@
 [package]
 name = "vorago-reb1"
-version = "0.2.2"
+version = "0.4.0"
 authors = ["Robin Mueller <robin.mueller.m@gmail.com>"]
 edition = "2021"
 description = "Board Support Crate for the Vorago REB1 development board"
-homepage = "https://github.com/robamu/vorago-reb1-rs"
-repository = "https://github.com/robamu/vorago-reb1-rs"
-license = "MIT OR Apache-2.0"
+homepage = "https://egit.irs.uni-stuttgart.de/rust/vorago-reb1"
+repository = "https://egit.irs.uni-stuttgart.de/rust/vorago-reb1"
+license = "Apache-2.0"
 keywords = ["no-std", "reb1", "cortex-m", "vorago", "va108xx"]
-categories = ["embedded", "no-std", "hardware-support"]
+categories = ["aerospace", "embedded", "no-std", "hardware-support"]
 
 [dependencies]
-cortex-m = "0.7.3"
-cortex-m-rt = "0.7.0"
-embedded-hal = "0.2.6"
-dummy-pin = "0.1.1"
-
-[dependencies.max116xx-10bit]
-path = "../max116xx-10bit"
+cortex-m = "0.7"
+cortex-m-rt = "0.7"
+embedded-hal = "0.2.7"
+dummy-pin = "0.1"
+max116xx-10bit = "0.2"
 
 [dependencies.va108xx-hal]
-path = "../va108xx-hal"
-# version = "0.4.1"
+version = "0.5"
 features = ["rt"]
 
 [features]
 rt = ["va108xx-hal/rt"]
 
 [dev-dependencies]
-cortex-m-rtic = "0.6.0-rc.4"
-panic-rtt-target = { version = "0.1", features = ["cortex-m"] }
-rtt-target = { version = "0.3", features = ["cortex-m"] }
+cortex-m-rtic = "1.1"
 panic-halt = "0.2"
-nb = "1.0.0"
+nb = "1"
 
-[[example]]
-name = "blinky-button-rtic"
-required-features = ["rt"]
+[dev-dependencies.rtt-target]
+version = "0.3"
+features = ["cortex-m"]
 
-[[example]]
-name = "adxl343-accelerometer"
-required-features = ["rt"]
-
-[[example]]
-name = "max11619-adc"
-required-features = ["rt", "nb"]
+[dev-dependencies.panic-rtt-target]
+version = "0.1"
+features = ["cortex-m"]

LICENSE

@@ -1,201 +0,0 @@
-                                 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.

LICENSE-MIT

@@ -1,25 +0,0 @@
-Copyright (c) 2021 Robin Mueller
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

NOTICE

@@ -0,0 +1,3 @@
+Rust Board Support Package (HAL) crate for the Vorago REB1 development board
+
+This software contains code developed at the University of Stuttgart.

README.md

@@ -1,5 +1,5 @@
 [![Crates.io](https://img.shields.io/crates/v/vorago-reb1)](https://crates.io/crates/vorago-reb1)
-[![ci](https://github.com/robamu-org/vorago-reb1-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/robamu-org/vorago-reb1-rs/actions/workflows/ci.yml)
+[![ci](https://github.com/us-irs/vorago-reb1-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/us-irs/vorago-reb1-rs/actions/workflows/ci.yml)
 [![docs.rs](https://img.shields.io/docsrs/vorago-reb1)](https://docs.rs/vorago-reb1)
 
 # Rust BSP for the Vorago REB1 development board
@@ -7,7 +7,7 @@
 This is the Rust **B**oard **S**upport **P**ackage crate for the Vorago REB1 development board.
 Its aim is to provide drivers for the board features of the REB1 board
 
-The BSP builds on top of the [HAL crate for VA108xx devices](https://github.com/robamu-org/va108xx-hal-rs).
+The BSP builds on top of the [HAL crate for VA108xx devices](https://egit.irs.uni-stuttgart.de/rust/va108xx-hal).
 
 ## Building
 
@@ -58,8 +58,9 @@ A `jlink.gdb` file is provided to allow flashing of the board from the command l
 
 ## Debugging with VS Code
 
-The REB1 board features an on-board JTAG, so all that is required to flash the board is a
-Micro-USB cable and an 
+The REB1 board features an on-board JTAG, so all that is required to debug the board is a
+Micro-USB cable.
+
 You can debug applications on the REB1 board with a graphical user interface using VS Code with
 the [`Cortex-Debug` plugin](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug).
 

automation/Dockerfile

@@ -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 thumbv6m-none-eabi && \
+	rustup component add rustfmt clippy

automation/Jenkinsfile

@@ -0,0 +1,50 @@
+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 thumbv6m-none-eabi'
+            }
+        }
+        stage('Check Examples') {
+            agent {
+                dockerfile {
+                    dir 'automation'
+                    reuseNode true
+                }
+            }
+            steps {
+                sh 'cargo check --target thumbv6m-none-eabi --examples'
+            }
+        }
+    }
+}

examples/adt75-temp-sensor.rs

@@ -3,11 +3,7 @@
 use cortex_m_rt::entry;
 use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
-use va108xx_hal::{
-    pac::{self, interrupt},
-    prelude::*,
-    timer::{default_ms_irq_handler, set_up_ms_timer, Delay},
-};
+use va108xx_hal::{pac, prelude::*, timer::set_up_ms_delay_provider};
 use vorago_reb1::temp_sensor::Adt75TempSensor;
 
 #[entry]
@@ -15,14 +11,7 @@ fn main() -> ! {
     rtt_init_print!();
     rprintln!("-- Vorago Temperature Sensor and I2C Example --");
     let mut dp = pac::Peripherals::take().unwrap();
-    let tim0 = set_up_ms_timer(
-        &mut dp.SYSCONFIG,
-        &mut dp.IRQSEL,
-        50.mhz().into(),
-        dp.TIM0,
-        interrupt::OC0,
-    );
-    let mut delay = Delay::new(tim0);
+    let mut delay = set_up_ms_delay_provider(&mut dp.SYSCONFIG, 50.mhz(), dp.TIM0);
     unsafe {
         cortex_m::peripheral::NVIC::unmask(pac::Interrupt::OC0);
     }
@@ -34,11 +23,6 @@ fn main() -> ! {
             .read_temperature()
             .expect("Failed reading temperature");
         rprintln!("Temperature in Celcius: {}", temp);
-        delay.delay_ms(500);
+        delay.delay_ms(500_u16);
     }
 }
-
-#[interrupt]
-fn OC0() {
-    default_ms_irq_handler();
-}

examples/adxl343-accelerometer.rs

@@ -10,10 +10,10 @@ use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
 use va108xx_hal::{
     gpio::PinsA,
-    pac::{self, interrupt},
+    pac,
     prelude::*,
     spi::{Spi, SpiConfig, TransferConfig},
-    timer::{default_ms_irq_handler, set_up_ms_timer, Delay},
+    timer::set_up_ms_delay_provider,
 };
 
 const READ_MASK: u8 = 1 << 7;
@@ -28,18 +28,7 @@ fn main() -> ! {
     rtt_init_print!();
     rprintln!("-- Vorago Accelerometer Example --");
     let mut dp = pac::Peripherals::take().unwrap();
-    let tim0 = set_up_ms_timer(
-        &mut dp.SYSCONFIG,
-        &mut dp.IRQSEL,
-        50.mhz().into(),
-        dp.TIM0,
-        interrupt::OC0,
-    );
-    let mut delay = Delay::new(tim0);
-    unsafe {
-        cortex_m::peripheral::NVIC::unmask(pac::Interrupt::OC0);
-    }
-
+    let mut delay = set_up_ms_delay_provider(&mut dp.SYSCONFIG, 50.mhz(), dp.TIM0);
     let pinsa = PinsA::new(&mut dp.SYSCONFIG, None, dp.PORTA);
     let spi_cfg = SpiConfig::default();
     let (sck, mosi, miso) = (
@@ -78,12 +67,7 @@ fn main() -> ! {
         .expect("Enabling measurement mode failed");
 
     loop {
-        delay.delay_ms(500);
-        todo!("Not implemented for now, is not populated on the board..");
+        delay.delay_ms(500_u16);
+        unimplemented!("Not implemented for now, is not populated on the board..");
     }
 }
-
-#[interrupt]
-fn OC0() {
-    default_ms_irq_handler();
-}

examples/blinky-button-irq.rs

@@ -14,7 +14,7 @@ use va108xx_hal::{
     pac::{self, interrupt},
     prelude::*,
     time::Hertz,
-    timer::{default_ms_irq_handler, set_up_ms_timer},
+    timer::{default_ms_irq_handler, set_up_ms_timer, IrqCfg},
 };
 use vorago_reb1::button::Button;
 use vorago_reb1::leds::Leds;
@@ -45,9 +45,9 @@ fn main() -> ! {
     // Configure an edge interrupt on the button and route it to interrupt vector 15
     let mut button = Button::new(pinsa.pa11.into_floating_input()).edge_irq(
         edge_irq,
+        IrqCfg::new(pac::interrupt::OC15, true, true),
         Some(&mut dp.SYSCONFIG),
-        &mut dp.IRQSEL,
-        pac::interrupt::OC15,
+        Some(&mut dp.IRQSEL),
     );
 
     if PRESS_MODE == PressMode::Toggle {
@@ -61,11 +61,11 @@ fn main() -> ! {
     }
 
     set_up_ms_timer(
+        IrqCfg::new(pac::Interrupt::OC0, true, true),
         &mut dp.SYSCONFIG,
-        &mut dp.IRQSEL,
-        50.mhz().into(),
+        Some(&mut dp.IRQSEL),
+        50.mhz(),
         dp.TIM0,
-        interrupt::OC0,
     );
     let mut leds = Leds::new(
         pinsa.pa10.into_push_pull_output(),
@@ -75,8 +75,6 @@ fn main() -> ! {
     for led in leds.iter_mut() {
         led.off();
     }
-    // Activate the IRQs so the processors sees them as well
-    unmask_irqs();
     // Make both button and LEDs accessible from the IRQ handler as well
     cortex_m::interrupt::free(|cs| {
         LEDS.borrow(cs).replace(Some(leds));
@@ -85,13 +83,6 @@ fn main() -> ! {
     loop {}
 }
 
-fn unmask_irqs() {
-    unsafe {
-        cortex_m::peripheral::NVIC::unmask(pac::Interrupt::OC0);
-        cortex_m::peripheral::NVIC::unmask(pac::Interrupt::OC15);
-    }
-}
-
 #[interrupt]
 fn OC0() {
     default_ms_irq_handler();

examples/blinky-button-rtic.rs

@@ -9,10 +9,10 @@ mod app {
     use va108xx_hal::{
         clock::{set_clk_div_register, FilterClkSel},
         gpio::{FilterType, InterruptEdge, PinsA},
-        pac::{self, interrupt},
+        pac,
         prelude::*,
         time::Hertz,
-        timer::{default_ms_irq_handler, set_up_ms_timer},
+        timer::{default_ms_irq_handler, set_up_ms_timer, IrqCfg},
     };
     use vorago_reb1::button::Button;
     use vorago_reb1::leds::Leds;
@@ -66,9 +66,9 @@ mod app {
         // Configure an edge interrupt on the button and route it to interrupt vector 15
         let mut button = Button::new(pinsa.pa11.into_floating_input()).edge_irq(
             edge_irq,
+            IrqCfg::new(pac::interrupt::OC15, true, true),
             Some(&mut dp.SYSCONFIG),
-            &mut dp.IRQSEL,
-            pac::interrupt::OC15,
+            Some(&mut dp.IRQSEL),
         );
 
         if mode == PressMode::Toggle {
@@ -80,14 +80,6 @@ mod app {
                 Hertz::from(50.khz()).0,
             );
         }
-
-        set_up_ms_timer(
-            &mut dp.SYSCONFIG,
-            &mut dp.IRQSEL,
-            50.mhz().into(),
-            dp.TIM0,
-            interrupt::OC0,
-        );
         let mut leds = Leds::new(
             pinsa.pa10.into_push_pull_output(),
             pinsa.pa7.into_push_pull_output(),
@@ -96,8 +88,13 @@ mod app {
         for led in leds.iter_mut() {
             led.off();
         }
-        // Activate the IRQs so the processors sees them as well
-        unmask_irqs();
+        set_up_ms_timer(
+            IrqCfg::new(pac::Interrupt::OC0, true, true),
+            &mut dp.SYSCONFIG,
+            Some(&mut dp.IRQSEL),
+            50.mhz(),
+            dp.TIM0,
+        );
         (Shared {}, Local { leds, button, mode }, init::Monotonics())
     }
 
@@ -128,13 +125,6 @@ mod app {
         default_ms_irq_handler();
     }
 
-    fn unmask_irqs() {
-        unsafe {
-            cortex_m::peripheral::NVIC::unmask(pac::Interrupt::OC0);
-            cortex_m::peripheral::NVIC::unmask(pac::Interrupt::OC15);
-        }
-    }
-
     fn prompt_mode(mut down_channel: rtt_target::DownChannel) -> PressMode {
         rprintln!("Using prompt mode");
         rprintln!("Please enter the mode [0: Toggle, 1: Keep]");
@@ -145,11 +135,11 @@ mod app {
             for i in 0..read {
                 let val = read_buf[i] as char;
                 if val == '0' || val == '1' {
-                    if val == '0' {
-                        return PressMode::Toggle;
+                    return if val == '0' {
+                        PressMode::Toggle
                     } else {
-                        return PressMode::Keep;
-                    }
+                        PressMode::Keep
+                    };
                 }
             }
         }

examples/blinky-leds.rs

@@ -9,7 +9,7 @@
 use cortex_m_rt::entry;
 use embedded_hal::digital::v2::ToggleableOutputPin;
 use panic_halt as _;
-use va108xx_hal::{gpio::pins::PinsA, pac, prelude::*};
+use va108xx_hal::{gpio::pins::PinsA, pac, prelude::*, timer::set_up_ms_delay_provider};
 use vorago_reb1::leds::Leds;
 
 // REB LED pin definitions. All on port A
@@ -64,23 +64,24 @@ fn main() -> ! {
             let mut led1 = pins.pa10.into_push_pull_output();
             let mut led2 = pins.pa7.into_push_pull_output();
             let mut led3 = pins.pa6.into_push_pull_output();
+            let mut delay = set_up_ms_delay_provider(&mut dp.SYSCONFIG, 50.mhz(), dp.TIM0);
             for _ in 0..10 {
                 led1.set_low().ok();
                 led2.set_low().ok();
                 led3.set_low().ok();
-                cortex_m::asm::delay(5_000_000);
+                delay.delay_ms(200_u16);
                 led1.set_high().ok();
                 led2.set_high().ok();
                 led3.set_high().ok();
-                cortex_m::asm::delay(5_000_000);
+                delay.delay_ms(200_u16);
             }
             loop {
                 led1.toggle().ok();
-                cortex_m::asm::delay(5_000_000);
+                delay.delay_ms(200_u16);
                 led2.toggle().ok();
-                cortex_m::asm::delay(5_000_000);
+                delay.delay_ms(200_u16);
                 led3.toggle().ok();
-                cortex_m::asm::delay(5_000_000);
+                delay.delay_ms(200_u16);
             }
         }
         LibType::Bsp => {
@@ -90,22 +91,21 @@ fn main() -> ! {
                 pinsa.pa7.into_push_pull_output(),
                 pinsa.pa6.into_push_pull_output(),
             );
+            let mut delay = set_up_ms_delay_provider(&mut dp.SYSCONFIG, 50.mhz(), dp.TIM0);
             loop {
                 for _ in 0..10 {
                     // Blink all LEDs quickly
                     for led in leds.iter_mut() {
                         led.toggle();
                     }
-                    cortex_m::asm::delay(5_000_000);
+                    delay.delay_ms(200_u16);
                 }
                 // Now use a wave pattern
                 loop {
-                    leds[0].toggle();
-                    cortex_m::asm::delay(5_000_000);
-                    leds[1].toggle();
-                    cortex_m::asm::delay(5_000_000);
-                    leds[2].toggle();
-                    cortex_m::asm::delay(5_000_000);
+                    for led in leds.iter_mut() {
+                        led.toggle();
+                        delay.delay_ms(200_u16);
+                    }
                 }
             }
         }

examples/max11619-adc.rs

@@ -2,29 +2,31 @@
 #![no_main]
 #![no_std]
 
-use core::panic;
-
 use cortex_m_rt::entry;
-use embedded_hal::spi;
+use embedded_hal::{blocking::delay::DelayUs, spi};
+use max116xx_10bit::VoltageRefMode;
+use max116xx_10bit::{AveragingConversions, AveragingResults};
 use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
+use va108xx_hal::timer::CountDownTimer;
 use va108xx_hal::{
     gpio::PinsA,
     pac::{self, interrupt, SPIB},
     prelude::*,
     spi::{Spi, SpiBase, SpiConfig, TransferConfig},
-    timer::{default_ms_irq_handler, set_up_ms_timer, Delay},
-    utility::*,
+    timer::{default_ms_irq_handler, set_up_ms_timer, Delay, IrqCfg},
+    utility::{port_mux, Funsel, PortSel},
 };
 use vorago_reb1::max11619::{
-    max11619_externally_clocked, max11619_internally_clocked, EocPin, AN2_CHANNEL,
-    POTENTIOMETER_CHANNEL,
+    max11619_externally_clocked_no_wakeup, max11619_externally_clocked_with_wakeup,
+    max11619_internally_clocked, EocPin, AN2_CHANNEL, POTENTIOMETER_CHANNEL,
 };
 
 #[derive(Debug, PartialEq, Copy, Clone)]
 pub enum ExampleMode {
     UsingEoc,
     NotUsingEoc,
+    NotUsingEocWithDelay,
 }
 
 #[derive(Debug, PartialEq, Copy, Clone)]
@@ -32,10 +34,18 @@ pub enum ReadMode {
     Single,
     Multiple,
     MultipleNToHighest,
+    AverageN,
+}
+
+#[derive(Debug, PartialEq, Copy, Clone)]
+pub enum MuxMode {
+    None,
+    PortB19to17,
 }
 
 const EXAMPLE_MODE: ExampleMode = ExampleMode::NotUsingEoc;
 const READ_MODE: ReadMode = ReadMode::Multiple;
+const MUX_MODE: MuxMode = MuxMode::None;
 
 #[entry]
 fn main() -> ! {
@@ -44,11 +54,11 @@ fn main() -> ! {
 
     let mut dp = pac::Peripherals::take().unwrap();
     let tim0 = set_up_ms_timer(
+        IrqCfg::new(pac::Interrupt::OC0, true, true),
         &mut dp.SYSCONFIG,
-        &mut dp.IRQSEL,
-        50.mhz().into(),
+        Some(&mut dp.IRQSEL),
+        50.mhz(),
         dp.TIM0,
-        interrupt::OC0,
     );
     let delay = Delay::new(tim0);
     unsafe {
@@ -56,18 +66,19 @@ fn main() -> ! {
     }
 
     let pinsa = PinsA::new(&mut dp.SYSCONFIG, None, dp.PORTA);
-    let mut spi_cfg = SpiConfig::default();
-    spi_cfg.scrdv = 0x07;
+    let spi_cfg = SpiConfig::default();
     let (sck, mosi, miso) = (
         pinsa.pa20.into_funsel_2(),
         pinsa.pa19.into_funsel_2(),
         pinsa.pa18.into_funsel_2(),
     );
 
-    port_mux(&mut dp.IOCONFIG, PortSel::PortB, 16, Funsel::Funsel1).ok();
-    // port_mux(&mut dp.IOCONFIG, PortSel::PortB, 17, Funsel::Funsel1).ok();
-    port_mux(&mut dp.IOCONFIG, PortSel::PortB, 18, Funsel::Funsel1).ok();
-    port_mux(&mut dp.IOCONFIG, PortSel::PortB, 19, Funsel::Funsel1).ok();
+    if MUX_MODE == MuxMode::PortB19to17 {
+        port_mux(&mut dp.IOCONFIG, PortSel::PortB, 19, Funsel::Funsel1).ok();
+        port_mux(&mut dp.IOCONFIG, PortSel::PortB, 18, Funsel::Funsel1).ok();
+        port_mux(&mut dp.IOCONFIG, PortSel::PortB, 17, Funsel::Funsel1).ok();
+        port_mux(&mut dp.IOCONFIG, PortSel::PortB, 16, Funsel::Funsel1).ok();
+    }
     // Set the accelerometer chip select low in case the board slot is populated
     let mut accel_cs = pinsa.pa16.into_push_pull_output();
     accel_cs
@@ -95,6 +106,10 @@ fn main() -> ! {
         ExampleMode::UsingEoc => {
             spi_example_internally_clocked(spi, delay, pinsa.pa14.into_floating_input());
         }
+        ExampleMode::NotUsingEocWithDelay => {
+            let delay_us = CountDownTimer::new(&mut dp.SYSCONFIG, 50.mhz(), dp.TIM2);
+            spi_example_externally_clocked_with_delay(spi, delay, delay_us);
+        }
     }
 }
 
@@ -103,9 +118,17 @@ fn OC0() {
     default_ms_irq_handler();
 }
 
+/// Use the SPI clock as the conversion clock
 fn spi_example_externally_clocked(spi: SpiBase<SPIB>, mut delay: Delay) -> ! {
-    let mut adc = max11619_externally_clocked(spi)
+    let mut adc = max11619_externally_clocked_no_wakeup(spi)
         .expect("Creating externally clocked MAX11619 device failed");
+    if READ_MODE == ReadMode::AverageN {
+        adc.averaging(
+            AveragingConversions::FourConversions,
+            AveragingResults::FourResults,
+        )
+        .expect("Error setting up averaging register");
+    }
     let mut cmd_buf: [u8; 32] = [0; 32];
     let mut counter = 0;
     loop {
@@ -114,50 +137,36 @@ fn spi_example_externally_clocked(spi: SpiBase<SPIB>, mut delay: Delay) -> ! {
         match READ_MODE {
             ReadMode::Single => {
                 rprintln!("Reading single potentiometer channel");
-                let pot_val = match adc.read_single_channel(&mut cmd_buf, POTENTIOMETER_CHANNEL) {
-                    Ok(pot_val) => pot_val,
-                    _ => {
-                        panic!("Creating externally clocked MAX11619 ADC failed");
-                    }
-                };
+                let pot_val = adc
+                    .read_single_channel(&mut cmd_buf, POTENTIOMETER_CHANNEL)
+                    .expect("Creating externally clocked MAX11619 ADC failed");
                 rprintln!("Single channel read:");
                 rprintln!("\tPotentiometer value: {}", pot_val);
             }
             ReadMode::Multiple => {
                 let mut res_buf: [u16; 4] = [0; 4];
-                match adc.read_multiple_channels_0_to_n(
+                adc.read_multiple_channels_0_to_n(
                     &mut cmd_buf,
                     &mut res_buf.iter_mut(),
                     POTENTIOMETER_CHANNEL,
-                ) {
-                    Ok(_) => {
-                        rprintln!("Multi channel read from 0 to 3:");
-                        rprintln!("\tAN0 value: {}", res_buf[0]);
-                        rprintln!("\tAN1 value: {}", res_buf[1]);
-                        rprintln!("\tAN2 value: {}", res_buf[2]);
-                        rprintln!("\tAN3 / Potentiometer value: {}", res_buf[3]);
-                    }
-                    _ => {
-                        panic!("Multi-Channel read failed");
-                    }
-                }
+                )
+                .expect("Multi-Channel read failed");
+                print_res_buf(&res_buf);
             }
             ReadMode::MultipleNToHighest => {
                 let mut res_buf: [u16; 2] = [0; 2];
-                match adc.read_multiple_channels_n_to_highest(
+                adc.read_multiple_channels_n_to_highest(
                     &mut cmd_buf,
                     &mut res_buf.iter_mut(),
                     AN2_CHANNEL,
-                ) {
-                    Ok(_) => {
-                        rprintln!("Multi channel read from 2 to 3:");
-                        rprintln!("\tAN2 value: {}", res_buf[0]);
-                        rprintln!("\tAN3 / Potentiometer value: {}", res_buf[1]);
-                    }
-                    _ => {
-                        panic!("Multi-Channel read failed");
-                    }
-                }
+                )
+                .expect("Multi-Channel read failed");
+                rprintln!("Multi channel read from 2 to 3:");
+                rprintln!("\tAN2 value: {}", res_buf[0]);
+                rprintln!("\tAN3 / Potentiometer value: {}", res_buf[1]);
+            }
+            ReadMode::AverageN => {
+                rprintln!("Scanning and averaging not possible for externally clocked mode");
             }
         }
         counter += 1;
@@ -165,22 +174,122 @@ fn spi_example_externally_clocked(spi: SpiBase<SPIB>, mut delay: Delay) -> ! {
     }
 }
 
-fn spi_example_internally_clocked(spi: SpiBase<SPIB>, mut delay: Delay, mut eoc_pin: EocPin) -> ! {
-    let mut adc = max11619_internally_clocked(spi).expect("Creaintg MAX116xx device failed");
+fn spi_example_externally_clocked_with_delay(
+    spi: SpiBase<SPIB>,
+    mut delay: Delay,
+    mut delay_us: impl DelayUs<u8>,
+) -> ! {
+    let mut adc =
+        max11619_externally_clocked_with_wakeup(spi).expect("Creating MAX116xx device failed");
+    let mut cmd_buf: [u8; 32] = [0; 32];
     let mut counter = 0;
     loop {
         rprintln!("-- Measurement {} --", counter);
-        match adc.request_single_channel(POTENTIOMETER_CHANNEL) {
-            Ok(_) => (),
-            _ => panic!("Requesting single channel value  failed"),
-        };
 
-        let pot_val = match nb::block!(adc.get_single_channel(&mut eoc_pin)) {
-            Ok(pot_val) => pot_val,
-            _ => panic!("Reading single channel value  failed"),
-        };
-        rprintln!("\tPotentiometer value: {}", pot_val);
+        match READ_MODE {
+            ReadMode::Single => {
+                rprintln!("Reading single potentiometer channel");
+                let pot_val = adc
+                    .read_single_channel(&mut cmd_buf, POTENTIOMETER_CHANNEL, &mut delay_us)
+                    .expect("Creating externally clocked MAX11619 ADC failed");
+                rprintln!("Single channel read:");
+                rprintln!("\tPotentiometer value: {}", pot_val);
+            }
+            ReadMode::Multiple => {
+                let mut res_buf: [u16; 4] = [0; 4];
+                adc.read_multiple_channels_0_to_n(
+                    &mut cmd_buf,
+                    &mut res_buf.iter_mut(),
+                    POTENTIOMETER_CHANNEL,
+                    &mut delay_us,
+                )
+                .expect("Multi-Channel read failed");
+                print_res_buf(&res_buf);
+            }
+            ReadMode::MultipleNToHighest => {
+                let mut res_buf: [u16; 2] = [0; 2];
+                adc.read_multiple_channels_n_to_highest(
+                    &mut cmd_buf,
+                    &mut res_buf.iter_mut(),
+                    AN2_CHANNEL,
+                    &mut delay_us,
+                )
+                .expect("Multi-Channel read failed");
+                rprintln!("Multi channel read from 2 to 3:");
+                rprintln!("\tAN2 value: {}", res_buf[0]);
+                rprintln!("\tAN3 / Potentiometer value: {}", res_buf[1]);
+            }
+            ReadMode::AverageN => {
+                rprintln!("Scanning and averaging not possible for externally clocked mode");
+            }
+        }
         counter += 1;
         delay.delay_ms(500);
     }
 }
+
+/// This function uses the EOC pin to determine whether the conversion finished
+fn spi_example_internally_clocked(spi: SpiBase<SPIB>, mut delay: Delay, eoc_pin: EocPin) -> ! {
+    let mut adc = max11619_internally_clocked(
+        spi,
+        eoc_pin,
+        VoltageRefMode::ExternalSingleEndedNoWakeupDelay,
+    )
+    .expect("Creating MAX116xx device failed");
+    let mut counter = 0;
+    loop {
+        rprintln!("-- Measurement {} --", counter);
+
+        match READ_MODE {
+            ReadMode::Single => {
+                adc.request_single_channel(POTENTIOMETER_CHANNEL)
+                    .expect("Requesting single channel value  failed");
+
+                let pot_val = nb::block!(adc.get_single_channel())
+                    .expect("Reading single channel value  failed");
+                rprintln!("\tPotentiometer value: {}", pot_val);
+            }
+            ReadMode::Multiple => {
+                adc.request_multiple_channels_0_to_n(POTENTIOMETER_CHANNEL)
+                    .expect("Requesting single channel value  failed");
+                let mut res_buf: [u16; 4] = [0; 4];
+                nb::block!(adc.get_multi_channel(&mut res_buf.iter_mut()))
+                    .expect("Requesting multiple channel values failed");
+                print_res_buf(&res_buf);
+            }
+            ReadMode::MultipleNToHighest => {
+                adc.request_multiple_channels_n_to_highest(AN2_CHANNEL)
+                    .expect("Requesting single channel value  failed");
+                let mut res_buf: [u16; 4] = [0; 4];
+                nb::block!(adc.get_multi_channel(&mut res_buf.iter_mut()))
+                    .expect("Requesting multiple channel values failed");
+                rprintln!("Multi channel read from 2 to 3:");
+                rprintln!("\tAN2 value: {}", res_buf[0]);
+                rprintln!("\tAN3 / Potentiometer value: {}", res_buf[1]);
+            }
+            ReadMode::AverageN => {
+                adc.request_channel_n_repeatedly(POTENTIOMETER_CHANNEL)
+                    .expect("Reading channel multiple times failed");
+                let mut res_buf: [u16; 16] = [0; 16];
+                nb::block!(adc.get_multi_channel(&mut res_buf.iter_mut()))
+                    .expect("Requesting multiple channel values failed");
+                rprintln!("Reading potentiometer 4 times");
+                rprintln!("\tValue 0: {}", res_buf[0]);
+                rprintln!("\tValue 1: {}", res_buf[1]);
+                rprintln!("\tValue 2: {}", res_buf[2]);
+                rprintln!("\tValue 3: {}", res_buf[3]);
+            }
+        }
+
+        counter += 1;
+        delay.delay_ms(500);
+    }
+}
+
+fn print_res_buf(buf: &[u16; 4]) {
+    rprintln!("Multi channel read from 0 to 3:");
+    rprintln!("\tAN0 value: {}", buf[0]);
+    rprintln!("\tAN1 value: {}", buf[1]);
+    rprintln!("\tAN2 value: {}", buf[2]);
+    rprintln!("\tAN3 / Potentiometer value: {}", buf[3]);
+}

src/button.rs

@@ -8,6 +8,7 @@ use va108xx_hal::{
     gpio::{FilterClkSel, FilterType, InputFloating, InterruptEdge, InterruptLevel, Pin, PA11},
     pac,
     prelude::*,
+    utility::IrqCfg,
 };
 
 pub struct Button {
@@ -28,30 +29,28 @@ impl Button {
     }
 
     /// Configures an IRQ on edge.
-    ///
-    /// Please note that you still have to unpend the Cortex-M interrupt yourself
     pub fn edge_irq(
         mut self,
         edge_type: InterruptEdge,
+        irq_cfg: IrqCfg,
         syscfg: Option<&mut pac::SYSCONFIG>,
-        irqsel: &mut pac::IRQSEL,
-        irq: pac::interrupt,
+        irqsel: Option<&mut pac::IRQSEL>,
     ) -> Self {
-        self.button = self.button.interrupt_edge(edge_type, syscfg, irqsel, irq);
+        self.button = self
+            .button
+            .interrupt_edge(edge_type, irq_cfg, syscfg, irqsel);
         self
     }
 
     /// Configures an IRQ on level.
-    ///
-    /// Please note that you still have to unpend the Cortex-M interrupt yourself
     pub fn level_irq(
         mut self,
         level: InterruptLevel,
+        irq_cfg: IrqCfg,
         syscfg: Option<&mut pac::SYSCONFIG>,
-        irqsel: &mut pac::IRQSEL,
-        irq: pac::interrupt,
+        irqsel: Option<&mut pac::IRQSEL>,
     ) -> Self {
-        self.button = self.button.interrupt_level(level, syscfg, irqsel, irq);
+        self.button = self.button.interrupt_level(level, irq_cfg, syscfg, irqsel);
         self
     }
 

src/max11619.rs

@@ -4,24 +4,20 @@
 //!
 //! - [ADC example](https://egit.irs.uni-stuttgart.de/rust/vorago-reb1/src/branch/main/examples/max11619-adc.rs)
 use core::convert::Infallible;
-
 use dummy_pin::DummyPin;
 use embedded_hal::{blocking::spi::Transfer, spi::FullDuplex};
 use max116xx_10bit::{
-    Error, ExternallyClocked, InternallyClockedInternallyTimedSerialInterface, Max11619,
-    Max116xx10Bit, RefMode, WithoutWakeupDelay,
+    Error, ExternallyClocked, InternallyClockedInternallyTimedSerialInterface, Max116xx10Bit,
+    Max116xx10BitEocExt, VoltageRefMode, WithWakeupDelay, WithoutWakeupDelay,
 };
 use va108xx_hal::gpio::{Floating, Input, Pin, PA14};
 
-pub type Max11619ExternallyClocked<SPI> =
-    Max116xx10Bit<SPI, DummyPin, Max11619, ExternallyClocked, WithoutWakeupDelay>;
-pub type Max11619InternallyClocked<SPI> = Max116xx10Bit<
-    SPI,
-    DummyPin,
-    Max11619,
-    InternallyClockedInternallyTimedSerialInterface,
-    WithoutWakeupDelay,
->;
+pub type Max11619ExternallyClockedNoWakeup<SPI> =
+    Max116xx10Bit<SPI, DummyPin, ExternallyClocked, WithoutWakeupDelay>;
+pub type Max11619ExternallyClockedWithWakeup<SPI> =
+    Max116xx10Bit<SPI, DummyPin, ExternallyClocked, WithWakeupDelay>;
+pub type Max11619InternallyClocked<SPI, EOC> =
+    Max116xx10BitEocExt<SPI, DummyPin, EOC, InternallyClockedInternallyTimedSerialInterface>;
 pub type EocPin = Pin<PA14, Input<Floating>>;
 
 pub const AN0_CHANNEL: u8 = 0;
@@ -29,37 +25,42 @@ pub const AN1_CHANNEL: u8 = 1;
 pub const AN2_CHANNEL: u8 = 2;
 pub const POTENTIOMETER_CHANNEL: u8 = 3;
 
-pub fn max11619_externally_clocked<SpiE, SPI>(
+pub fn max11619_externally_clocked_no_wakeup<SpiE, SPI>(
     spi: SPI,
-) -> Result<Max11619ExternallyClocked<SPI>, Error<SpiE, Infallible>>
+) -> Result<Max11619ExternallyClockedNoWakeup<SPI>, Error<SpiE, Infallible>>
 where
     SPI: Transfer<u8, Error = SpiE> + FullDuplex<u8, Error = SpiE>,
 {
-    let adc: Max116xx10Bit<SPI, DummyPin, Max11619, ExternallyClocked, WithoutWakeupDelay> =
-        Max116xx10Bit::new(
-            spi,
-            DummyPin::new_low(),
-            RefMode::ExternalSingleEndedNoWakeupDelay,
-        )?;
+    let mut adc = Max116xx10Bit::max11619(spi, DummyPin::new_low())?;
+    adc.reset(false)?;
+    adc.setup()?;
+    Ok(adc)
+}
+
+pub fn max11619_externally_clocked_with_wakeup<SpiE, SPI>(
+    spi: SPI,
+) -> Result<Max11619ExternallyClockedWithWakeup<SPI>, Error<SpiE, Infallible>>
+where
+    SPI: Transfer<u8, Error = SpiE> + FullDuplex<u8, Error = SpiE>,
+{
+    let mut adc = Max116xx10Bit::max11619(spi, DummyPin::new_low())?
+        .into_ext_clkd_with_int_ref_wakeup_delay();
+    adc.reset(false)?;
+    adc.setup()?;
     Ok(adc)
 }
 
 pub fn max11619_internally_clocked<SpiE, SPI>(
     spi: SPI,
-) -> Result<Max11619InternallyClocked<SPI>, Error<SpiE, Infallible>>
+    eoc: EocPin,
+    v_ref: VoltageRefMode,
+) -> Result<Max11619InternallyClocked<SPI, EocPin>, Error<SpiE, Infallible>>
 where
     SPI: Transfer<u8, Error = SpiE> + FullDuplex<u8, Error = SpiE>,
 {
-    let adc: Max116xx10Bit<
-        SPI,
-        DummyPin,
-        Max11619,
-        InternallyClockedInternallyTimedSerialInterface,
-        WithoutWakeupDelay,
-    > = Max116xx10Bit::new(
-        spi,
-        DummyPin::new_low(),
-        RefMode::ExternalSingleEndedNoWakeupDelay,
-    )?;
+    let mut adc = Max116xx10Bit::max11619(spi, DummyPin::new_low())?
+        .into_int_clkd_int_timed_through_ser_if_without_wakeup(v_ref, eoc)?;
+    adc.reset(false)?;
+    adc.setup()?;
     Ok(adc)
 }

src/temp_sensor.rs

@@ -21,7 +21,7 @@ pub struct Adt75TempSensor {
     current_reg: RegAddresses,
 }
 
-#[derive(PartialEq, Debug, Copy, Clone)]
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
 pub enum RegAddresses {
     Temperature = 0x00,
     Configuration = 0x01,
@@ -67,15 +67,14 @@ impl Adt75TempSensor {
         let mut reply: [u8; 2] = [0; 2];
         self.sensor_if.read(ADT75_I2C_ADDR, &mut reply)?;
         let adc_code = (((reply[0] as u16) << 8) | reply[1] as u16) >> 4;
-        let temp_celcius: f32;
-        if ((adc_code >> 11) & 0x01) == 0 {
+        let temp_celcius: f32 = if ((adc_code >> 11) & 0x01) == 0 {
             // Sign bit not set, positiv value
             // Divide ADC code by 16 according to datasheet
-            temp_celcius = adc_code as f32 / 16.0;
+            adc_code as f32 / 16.0
         } else {
             // Calculation for negative values, assuming all 12 bits are used
-            temp_celcius = (adc_code - 4096) as f32 / 16.0;
-        }
+            (adc_code - 4096) as f32 / 16.0
+        };
         Ok(temp_celcius)
     }
 }