Fix configs: Make software compatible with nRF52810 again

Cargo.toml

@@ -23,3 +23,11 @@ nrf-softdevice = { version = "0.1.0", features = ["defmt", "ble-peripheral", "bl
 nrf-softdevice-s112 = "0.1.2"
 panic-probe = { version = "0.3.2", features = ["print-defmt"] }
 static_cell = "2.1.0"
+
+[[bin]]
+name = "commonsense"
+path = "src/bin/temp_rh_measurement.rs"
+test = false
+doctest = false
+bench = false
+

memory.x

@@ -1,8 +1,7 @@
 MEMORY
 {
   /* NOTE 1 K = 1 KiB = 1024 bytes */
-  /* These values correspond to the NRF52810 with SoftDevice S112 v7.x */
+  /* These values correspond to the NRF52832 with SoftDevice S112 v7.x */
   FLASH : ORIGIN = 0x00000000 + 100K, LENGTH = 192K - 100K
   RAM   : ORIGIN = 0x20000000 + 0x24b8,  LENGTH = 24K - 0x24b8
 }
-

src/bin/ble_gatt_server.rs

@@ -61,102 +61,100 @@ async fn main(spawner: Spawner) {
     let mut led = Output::new(p.P0_18, Level::Low, OutputDrive::Standard);
     led.set_high();
 
-    info!("Hello World!");
+    let config = nrf_softdevice::Config {
+        clock: Some(raw::nrf_clock_lf_cfg_t {
+            source: raw::NRF_CLOCK_LF_SRC_RC as u8,
+            rc_ctiv: 16,
+            rc_temp_ctiv: 2,
+            accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
+        }),
+        conn_gap: Some(raw::ble_gap_conn_cfg_t {
+            conn_count: 1,
+            event_length: 24,
+        }),
+        conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
+        gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
+            attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
+        }),
+        gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
+            adv_set_count: 1,
+            periph_role_count: 1,
+            // central_role_count: 3,
+            // central_sec_count: 0,
+            // _bitfield_1: raw::ble_gap_cfg_role_count_t::new_bitfield_1(0),
+        }),
+        gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
+            p_value: b"HelloRust" as *const u8 as _,
+            current_len: 9,
+            max_len: 9,
+            write_perm: unsafe { mem::zeroed() },
+            _bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
+                raw::BLE_GATTS_VLOC_STACK as u8,
+            ),
+        }),
+        ..Default::default()
+    };
 
-    // let config = nrf_softdevice::Config {
+    let sd = Softdevice::enable(&config);
-    //     clock: Some(raw::nrf_clock_lf_cfg_t {
+    let server = unwrap!(Server::new(sd));
-    //         source: raw::NRF_CLOCK_LF_SRC_RC as u8,
+    unwrap!(spawner.spawn(softdevice_task(sd)));
-    //         rc_ctiv: 16,
+
-    //         rc_temp_ctiv: 2,
+    static ADV_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
-    //         accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
+        .flags(&[Flag::GeneralDiscovery, Flag::LE_Only])
-    //     }),
+        .services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY])
-    //     conn_gap: Some(raw::ble_gap_conn_cfg_t {
+        .full_name("HelloRust")
-    //         conn_count: 1,
+        .build();
-    //         event_length: 24,
+
-    //     }),
+    static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
-    //     conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
+        .services_128(
-    //     gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
+            ServiceList::Complete,
-    //         attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
+            &[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()],
-    //     }),
+        )
-    //     gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
+        .build();
-    //         adv_set_count: 1,
+
-    //         periph_role_count: 1,
+    loop {
-    //         // central_role_count: 3,
+        info!("Creating config");
-    //         // central_sec_count: 0,
+        let config = peripheral::Config::default();
-    //         // _bitfield_1: raw::ble_gap_cfg_role_count_t::new_bitfield_1(0),
+        info!("Creating adv object");
-    //     }),
+        let adv = peripheral::ConnectableAdvertisement::ScannableUndirected {
-    //     gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
+            adv_data: &ADV_DATA,
-    //         p_value: b"HelloRust" as *const u8 as _,
+            scan_data: &SCAN_DATA,
-    //         current_len: 9,
+        };
-    //         max_len: 9,
+        info!("Starting advertising");
-    //         write_perm: unsafe { mem::zeroed() },
+        let conn = unwrap!(peripheral::advertise_connectable(sd, adv, &config).await);
-    //         _bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
+
-    //             raw::BLE_GATTS_VLOC_STACK as u8,
+        info!("advertising done!");
-    //         ),
+
-    //     }),
+        // Run the GATT server on the connection. This returns when the connection gets disconnected.
-    //     ..Default::default()
+        //
-    // };
+        // Event enums (ServerEvent's) are generated by nrf_softdevice::gatt_server
-    //
+        // proc macro when applied to the Server struct above
-    // let sd = Softdevice::enable(&config);
+        let e = gatt_server::run(&conn, &server, |e| match e {
-    // let server = unwrap!(Server::new(sd));
+            ServerEvent::Bas(e) => match e {
-    // unwrap!(spawner.spawn(softdevice_task(sd)));
+                BatteryServiceEvent::BatteryLevelCccdWrite { notifications } => {
-    //
+                    info!("battery notifications: {}", notifications)
-    // static ADV_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
+                }
-    //     .flags(&[Flag::GeneralDiscovery, Flag::LE_Only])
+            },
-    //     .services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY])
+            ServerEvent::Foo(e) => match e {
-    //     .full_name("HelloRust")
+                FooServiceEvent::FooWrite(val) => {
-    //     .build();
+                    info!("wrote foo: {}", val);
-    //
+                    if let Err(e) = server.foo.foo_notify(&conn, &(val + 1)) {
-    // static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
+                        info!("send notification error: {:?}", e);
-    //     .services_128(
+                    }
-    //         ServiceList::Complete,
+                }
-    //         &[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()],
+                FooServiceEvent::FooCccdWrite {
-    //     )
+                    indications,
-    //     .build();
+                    notifications,
-    //
+                } => {
-    // loop {
+                    info!(
-    //     info!("Creating config");
+                        "foo indications: {}, notifications: {}",
-    //     let config = peripheral::Config::default();
+                        indications, notifications
-    //     info!("Creating adv object");
+                    )
-    //     let adv = peripheral::ConnectableAdvertisement::ScannableUndirected {
+                }
-    //         adv_data: &ADV_DATA,
+            },
-    //         scan_data: &SCAN_DATA,
+        })
-    //     };
+        .await;
-    //     info!("Starting advertising");
+
-    //     let conn = unwrap!(peripheral::advertise_connectable(sd, adv, &config).await);
+        info!("gatt_server run exited with error: {:?}", e);
-    //
+    }
-    //     info!("advertising done!");
-    //
-    //     // Run the GATT server on the connection. This returns when the connection gets disconnected.
-    //     //
-    //     // Event enums (ServerEvent's) are generated by nrf_softdevice::gatt_server
-    //     // proc macro when applied to the Server struct above
-    //     let e = gatt_server::run(&conn, &server, |e| match e {
-    //         ServerEvent::Bas(e) => match e {
-    //             BatteryServiceEvent::BatteryLevelCccdWrite { notifications } => {
-    //                 info!("battery notifications: {}", notifications)
-    //             }
-    //         },
-    //         ServerEvent::Foo(e) => match e {
-    //             FooServiceEvent::FooWrite(val) => {
-    //                 info!("wrote foo: {}", val);
-    //                 if let Err(e) = server.foo.foo_notify(&conn, &(val + 1)) {
-    //                     info!("send notification error: {:?}", e);
-    //                 }
-    //             }
-    //             FooServiceEvent::FooCccdWrite {
-    //                 indications,
-    //                 notifications,
-    //             } => {
-    //                 info!(
-    //                     "foo indications: {}, notifications: {}",
-    //                     indications, notifications
-    //                 )
-    //             }
-    //         },
-    //     })
-    //     .await;
-    //
-    //     info!("gatt_server run exited with error: {:?}", e);
-    // }
 }

src/bin/temp_rh_measurement.rs

@@ -1,45 +1,213 @@
 #![no_std]
 #![no_main]
 
+use static_cell::StaticCell;
+
+use core::mem;
+use embassy_nrf::interrupt::{self, InterruptExt};
+use embassy_nrf::peripherals::TWI0;
 use embassy_time::Timer;
+use nrf_softdevice::ble::advertisement_builder::{
+    Flag, LegacyAdvertisementBuilder, LegacyAdvertisementPayload, ServiceList, ServiceUuid16,
+};
+use nrf_softdevice::ble::{gatt_server, peripheral, TxPower};
 use nrf_softdevice::{raw, Softdevice};
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_nrf::twim::{self, Twim};
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_nrf::twim;
 use embassy_nrf::{bind_interrupts, peripherals};
 use {defmt_rtt as _, panic_probe as _};
 
-const ADDRESS: u8 = 0x44;
+//
+//
+// BLE code
+//
+//
 
-bind_interrupts!(struct Irqs {
+#[nrf_softdevice::gatt_service(uuid = "181a")]
-    TWIM0_TWIS0_TWI0 => twim::InterruptHandler<peripherals::TWI0>;
+struct EnvironmentalService {
-});
+    #[characteristic(uuid = "2a6e", read, notify)]
+    temperature: u32,
+    #[characteristic(uuid = "2a6f", read, notify)]
+    humidity: u32,
+}
 
-#[embassy_executor::main]
+#[nrf_softdevice::gatt_server]
-async fn main(_spawner: Spawner) {
+struct Server {
-    let p = embassy_nrf::init(Default::default());
+    bas: EnvironmentalService,
+}
 
-    info!("Initializing TWI...");
+#[embassy_executor::task]
+async fn softdevice_task(sd: &'static Softdevice) -> ! {
+    sd.run().await
+}
 
-    let config = twim::Config::default();
+#[embassy_executor::task]
-    let mut twi = Twim::new(p.TWI0, Irqs, p.P0_14, p.P0_13, config);
+async fn ble_task(sd: &'static Softdevice, server: &'static Server) {
+    static ADV_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
+        .flags(&[Flag::GeneralDiscovery, Flag::LE_Only])
+        .services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY])
+        .full_name("CommonSense")
+        .build();
+
+    static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
+        .services_128(
+            ServiceList::Complete,
+            &[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()],
+        )
+        .build();
 
     loop {
-        unwrap!(twi.blocking_write(ADDRESS, &mut [0xFD]));
+        let config = peripheral::Config {
+            tx_power: TxPower::Plus4dBm,
+            ..Default::default()
+        };
 
-        Timer::after_millis(10).await;
+        let adv = peripheral::ConnectableAdvertisement::ScannableUndirected {
+            adv_data: &ADV_DATA,
+            scan_data: &SCAN_DATA,
+        };
 
+        let conn = unwrap!(peripheral::advertise_connectable(sd, adv, &config).await);
+
+        let _e = gatt_server::run(&conn, server, |_| {}).await;
+
+        Timer::after_secs(10).await;
+    }
+}
+
+//
+//
+// Sensing code
+//
+//
+
+struct GenericTempHumiditySensor<T: twim::Instance> {
+    address: u8,
+    driver: twim::Twim<'static, T>,
+}
+
+// TODO: Implement CRC checks
+impl<T: twim::Instance> GenericTempHumiditySensor<T> {
+    fn new(address: u8, driver: twim::Twim<'static, T>) -> Self {
+        Self { address, driver }
+    }
+
+    /// The procedure for reading out the temperature and humidity and converting them to floats is
+    /// detailed in the datasheet of the SHT41-AD1B-R2.
+    async fn read_temp_and_humidity(&mut self) -> (f32, f32) {
         let mut buf = [0u8; 6];
-        unwrap!(twi.blocking_read(ADDRESS, &mut buf));
+
+        unwrap!(self.driver.blocking_write(self.address, &mut [0xFD]));
+        Timer::after_millis(10).await;
+        unwrap!(self.driver.blocking_read(self.address, &mut buf));
 
         let temp_int = u16::from_be_bytes([buf[0], buf[1]]);
         let temp_float: f32 = -45f32 + 175f32 * (temp_int as f32 / (2u32.pow(16) - 1) as f32);
 
         let rh_int = u16::from_be_bytes([buf[3], buf[4]]);
         let rh_float: f32 = -6f32 + 125f32 * (rh_int as f32 / (2u32.pow(16) - 1) as f32);
-        println!("{}\t{}", temp_float, rh_float);
 
-        Timer::after_millis(50).await;
+        return (temp_float, rh_float);
+    }
+}
+
+bind_interrupts!(struct Irqs {
+    TWIM0_TWIS0_TWI0 => twim::InterruptHandler<peripherals::TWI0>;
+});
+
+type TempHumiditySensor = GenericTempHumiditySensor<TWI0>;
+
+#[embassy_executor::task]
+async fn measurement_task(mut sensor: TempHumiditySensor, server: &'static Server) {
+    loop {
+        let (temp, humidity) = sensor.read_temp_and_humidity().await;
+        println!("{} °C\t{} %", temp, humidity);
+
+        let temp: u32 = (temp * 100.0) as u32;
+        let humidity: u32 = (humidity * 100.0) as u32;
+
+        unwrap!(server.bas.temperature_set(&temp));
+        unwrap!(server.bas.humidity_set(&humidity));
+
+        Timer::after_secs(5).await;
+    }
+}
+
+//
+//
+// Main code
+//
+//
+
+static SERVER: StaticCell<Server> = StaticCell::new();
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    // Set up peripherals
+
+    interrupt::TWIM0_TWIS0_TWI0.set_priority(interrupt::Priority::P2);
+
+    let mut embassy_config = embassy_nrf::config::Config::default();
+    embassy_config.gpiote_interrupt_priority = interrupt::Priority::P2;
+    embassy_config.time_interrupt_priority = interrupt::Priority::P2;
+    let p = embassy_nrf::init(embassy_config);
+
+    let config = twim::Config::default();
+    let twi = twim::Twim::new(p.TWI0, Irqs, p.P0_14, p.P0_13, config);
+    let sensor = TempHumiditySensor::new(0x44, twi);
+
+    let mut led = Output::new(p.P0_20, Level::Low, OutputDrive::Standard);
+
+    // Set up softdevice
+
+    let config = nrf_softdevice::Config {
+        clock: Some(raw::nrf_clock_lf_cfg_t {
+            source: raw::NRF_CLOCK_LF_SRC_RC as u8,
+            rc_ctiv: 16,
+            rc_temp_ctiv: 2,
+            accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
+        }),
+        conn_gap: Some(raw::ble_gap_conn_cfg_t {
+            conn_count: 1,
+            event_length: 24,
+        }),
+        conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
+        gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
+            attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
+        }),
+        gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
+            adv_set_count: 1,
+            periph_role_count: 1,
+        }),
+        gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
+            p_value: b"CommonSense" as *const u8 as _,
+            current_len: 9,
+            max_len: 9,
+            write_perm: unsafe { mem::zeroed() },
+            _bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
+                raw::BLE_GATTS_VLOC_STACK as u8,
+            ),
+        }),
+        ..Default::default()
+    };
+
+    let sd = Softdevice::enable(&config);
+    let server = unwrap!(Server::new(sd));
+    let server: &'static mut Server = SERVER.init(server);
+
+    // Start tasks
+
+    unwrap!(spawner.spawn(softdevice_task(sd)));
+    unwrap!(spawner.spawn(ble_task(sd, server)));
+    unwrap!(spawner.spawn(measurement_task(sensor, server)));
+
+    loop {
+        led.set_high();
+        Timer::after_millis(500).await;
+        led.set_low();
+        Timer::after_millis(500).await;
     }
 }