From 927ee977ad40d92d7583aeaf31a9d644b12a8451 Mon Sep 17 00:00:00 2001 From: Walter Bonetti Date: Mon, 9 Sep 2024 21:27:31 -0400 Subject: [PATCH] Add: parameters struct/configuration --- src/command.rs | 220 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) diff --git a/src/command.rs b/src/command.rs index df1a03f..8d89dbe 100644 --- a/src/command.rs +++ b/src/command.rs @@ -194,6 +194,10 @@ pub mod constants { /// Soft Reset Register Register (W) /// Default: 00000000 pub const RESET: u8 = 0x60; + /// Parameters 1st command + pub const CMD_PARAM_FRIST: u8 = 0x01; + /// Parameters 2nd command + pub const CMD_PARAM_SECOND: u8 = 0x02; } pub mod register { pub mod ship_info { @@ -1249,3 +1253,219 @@ pub mod register { pub type ResetRegister = u8; } } + +pub mod parameters { + pub mod pedometer { + //! The Pedometer Engine detects the steps and output the step count to the UI registers for host to read, as well as + //! generate the Pedometer interrupt. + //! The calculation of the Pedometer Detection is based on the accelerometer ODR defined by CTRL2.aODR, refer to + //! Table 22 for details. + //! The Pedometer can only work in Non-SyncSample mode, refer to 6.2 Non-SyncSample mode for details + //! + + /// The `PedometerParameters` allows to easly configure + /// the `Pedometer`. + pub struct PedometerParameters { + /// Indicates the count of sample batch/window for calculation + /// Resolution: 1 sample + // Format: 2-bytes integer + // ped_sample_cnt + pub sample_cnt: i16, + /// Indicates the threshold of the valid peak-to-peak detection + /// Resolution: 1 mg + // Format: 2-bytes integer + // (1 / 2^10) g = 1 mg + // ped_fix_peak2peak + pub fix_peak2peak: f32, + /// Indicates the threshold of the peak detection comparing to average + /// Resolution: 1 mg + // Format: 2-bytes integer + // (1 / 2^10) g = 1 mg + // ped_fix_peak + pub fix_peak: f32, + /// Indicates the maximum duration (timeout window) for a + /// step. Reset counting calculation if no peaks detected + /// within this duration. + /// E.g., 80 means 1.6s @ ODR = 50Hz + /// Resolution: 1 sample + // Format: 2-bytes integer + // ped_time_up + pub time_up: i16, + /// Indicates the minimum duration for a step. The peaks + /// detected within this duration \(quiet time\) is ignored. + /// E.g., 12 means 0.25s @ ODR = 50Hz + /// Resolution: 1 sample + // Format: 1-bytes integer + // ped_time_low + pub time_low: i8, + /// Indicates the minimum continuous steps to start the valid + /// step counting. If the continuously detected steps is lower + /// than this count and timeout, the steps will not be take + /// into account; if yes, the detected steps will all be taken + /// into account and counting is started to count every + /// following step before timeout. This is useful to screen out + /// the fake steps detected by non-step vibrations. + /// + /// The timeout duration is defined by `ped_time_up`. + /// + /// E.g., 10 means 10 steps entry count + /// Resolution: 1 step + // ped_cnt_entry + pub cnt_entry: i8, + /// 0 is recommended + /// Resolution: 1 sample + // Format: 1-bytes integer + // ped_fix_precision + pub fix_precision: i8, + /// The amount of steps when to update the pedometer + /// output registers. + // + /// E.g., ped_sig_count = 4, every 4 valid steps is detected, + /// update the registers once (added by 4). + /// Resolution: 1 sample + // Format: 1-bytes integer + // ped_sig_count + pub sig_count: i8, + } + } + + pub mod tap { + //!The Tap engine detects the Single-Tap or Double-Tap, if enabled. + //!The calculation of the Tap Detection is based on the accelerometer ODR defined by CTRL2.aODR, refer to Table 22 + //!for details. + //!The Tap detection can only work in Non-SyncSample mode, refer to for details 6.2 Non-SyncSample mode. + //! + + /// Priority definition between the x, y, z axes of acceleration. O + #[allow(non_camel_case_types)] + pub enum Priority { + /// (X > Y> Z) + X_Y_Z = 0, + /// (X > Z > Y) + X_Z_Y = 1, + /// (Y > X > Z) + Y_X_Z = 2, + /// (Y > Z > X) + Y_Z_X = 3, + /// (Z > X > Y) + Z_X_Y = 4, + /// (Z > Y > X) + Z_Y_X = 5, + } + + pub struct TapParameters { + /// Priority + /// + /// The axis that output the first peak of Linear Acceleration in a valid + /// Tap detection, will be consider as the Tap axis. However, there is + /// possibility that two or three of the axes shows same Linear + /// Acceleration at exactly same time when reach (or be higher than) + /// the PeakMagThr. In this case, the defined priority is used to judge + /// and select the axis as Tap axis. + // Format: 1-byte integer + pub priority: Priority, + /// PeakWindow + /// Defines the maximum duration (in sample) for a valid peak. In a + /// valid peak, the linear acceleration should reach or be higher than + /// the `s` and should return to quiet (no significant + /// movement) within `UDMThr`, at the end of PeakWindow. + /// E.g., 20 @500Hz ODR + // Format: 1-byte integer + // Resolution: er 1 sample + pub peak_window: u8, + /// TapWindow + /// + /// Defines the minimum quiet time before the second Tap happen. + /// After the first Tap is detected, there should be no significant + /// movement (defined by UDMThr) during the TapWindow. The valid + /// second tap should be detected after TapWindow and before + /// DTapWindow. + /// E.g., 20 @500Hz ODR + // Format: 2-bytes integer + // 1 sample + pub tap_window: u16, + /// DTapWindow + /// Defines the maximum time for a valid second Tap for Double Tap, + /// count start from the first peak of the valid first Tap. + /// E.g., 250 @500Hz ODR + // Format: 2-bytes integer + // 1 sample + pub d_tap_window: u16, + /// Alpha + /// + /// Defines the ratio for calculation the average of the acceleration. + /// The bigger of Alpha, the bigger weight of the latest data. + /// E.g., 0.0625 + // Format: 1-byte unsigned, 7-bits fraction + // Resolution: 0.0078 (1/128) + pub alpha: f32, + /// Gamma + /// + /// Defines the ratio for calculating the average of the movement + /// magnitude. The bigger of Gamma, the bigger weight of the latest + /// data. + // Format: 1-byte unsigned, 7-bits fraction + // Resolution: 0.0078 (1/128) + pub gamma: f32, + /// PeakMagThr + /// + /// Threshold for peak detection + /// E.g, 0.8g + // Format: 2-bytes unsigned, 10-bits fraction + // Resolution: 0.001g2 (1/ 1024) + pub peak_mag_thr: f32, + /// UDMThr + /// + /// Undefined Motion threshold. This defines the threshold of the + /// Linear Acceleration for quiet status + /// E.g., 0.4g2 + // Format: 2-bytes unsigned, 10-bits fraction + // Resolution: 0.001g2 (1/ 1024) + pub udm_thr: f32, + } + } + + pub mod wom { + //! The purpose of the Wake on Motion (WoM) functionality is to allow a system to enter a low power sleep state while the + //! system is static and then to automatically awaken when moved. In this mode the system should use very little power, + //! yet still respond quickly to motion. + //! It is assumed that the system host processor is responsible for configuring the QMI8658A correctly to place it into Wake + //! on Motion mode, and then reconfigure the QMI8658A as necessary following a WoM interrupt. + //! Note that, Wake on Motion function works similar to Any-Motion detection but without sensor data output and can be + //! configure more flexibly on interrupt behavior. Besides, once QMI8658A is configured into Wake on Motion mode, there + //! is WoM interrupt to awaken the host if movement is detected. + //! + + pub enum WoMThreshold { + Disabled, + Threshold(u8), + } + + pub enum WoMInterruptInit { + /// Int2 with initial value 0 + Int2_0 = 0b01, + /// Int2 with initial value 1 + Int2_1 = 0b11, + /// Int1 with initial value 0 + Int1_0 = 0b00, + /// Int1 with initial value 1 + Int1_1 = 0b10, + } + + pub struct WoMParameters { + // Format: 1-byte unsigned integer + /// Resolution 1mg + pub wom_threshold: WoMThreshold, + // Resolution 1 + // Format: 2-bits unsigned integer + pub wom_interrupt: WoMInterruptInit, + /// Interrupt Blanking Time (in number of accelerometer samples), + /// the + /// number of consecutive samples that will be ignored after enabling the + /// WoM, to screen out unwanted fake detection + // Format: 6-bits unsigned integer + // Resolution: 1 sample + pub interrupt_blanking_time: u8, + } + } +}