fix(OpenGloves): tick input sensors

firmware/mode_configs/opengloves/opengloves.cpp

@@ -153,7 +153,8 @@ void setupMode()
     auto* pinch = new BUTTON_CLASS(PIN_BUTTON_PINCH, BUTTON_PINCH_INVERT);
 #endif
 
-    OpenGlovesTrackingComponent::Config const tracking_config(2000, false);
+    Serial.begin(115200);
+    OpenGlovesTrackingComponent::Config tracking_config(2000, false);
     auto* opengloves_tracking =
       new OpenGlovesTrackingComponent(tracking_config, input_sensors, new StreamTransport(Serial));
 

ini/opengloves-lucidgloves.ini

@@ -65,8 +65,6 @@ build_flags = ${opengloves.build_flags} -D OG_ENCODE_FAST
 ; -D PIN_BUTTON_GRAB=13 ; unused if GESTURE_GRAB is true
 ; -D PIN_BUTTON_PINCH=23 ; unused if GESTURE_PINCH is true
 
-; todo: add servo pins
-
 build_unflags = ${opengloves.build_unflags}
 build_src_filter = ${opengloves.build_src_filter}
                    +<mode_configs/opengloves/opengloves.cpp>

lib/arduino/senseshift/arduino/input/sensor/digital.hpp

@@ -18,12 +18,14 @@ namespace SenseShift::Arduino::Input {
     };
 
     template<>
-    [[nodiscard]] inline auto DigitalSimpleSensor<false>::getValue() -> bool {
+    [[nodiscard]] inline auto DigitalSimpleSensor<false>::getValue() -> bool
+    {
         return digitalRead(this->pin_) == LOW;
     }
 
     template<>
-    [[nodiscard]] inline auto DigitalSimpleSensor<true>::getValue() -> bool {
+    [[nodiscard]] inline auto DigitalSimpleSensor<true>::getValue() -> bool
+    {
         return digitalRead(this->pin_) == HIGH;
     }
 } // namespace SenseShift::Arduino::Input

lib/io/senseshift/input/filter.hpp

@@ -242,9 +242,6 @@ namespace SenseShift::Input::Filter {
       public:
         explicit ExponentialMovingAverageFilter(float alpha) : alpha_(alpha){};
 
-        template<typename U = Tp, std::enable_if_t<std::is_same_v<U, float>, int> = 0>
-        explicit ExponentialMovingAverageFilter(float alpha) : alpha_(alpha), acc_(std::nanf){};
-
         auto filter(ISimpleSensor<Tp>* /*sensor*/, Tp value) -> Tp override
         {
             if (this->is_first_) {

lib/io/senseshift/input/sensor.hpp

@@ -45,6 +45,12 @@ namespace SenseShift::Input {
 
         explicit Sensor() = default;
 
+        template<typename U = Tp, std::enable_if_t<std::is_same_v<U, float>, int> = 0>
+        explicit Sensor(float value = 0.0f) : raw_value_(value)
+        {
+            this->value_ = this->applyFilters(value);
+        }
+
         /// Appends a filter to the sensor's filter chain.
         ///
         /// \param filter The filter to add.

lib/opengloves/opengloves/opengloves.cpp

@@ -59,7 +59,7 @@ namespace og {
                   length - written,
                   "%c%u",
                   'A' + i,
-                  ifloor<std::uint8_t, float>(finger_curl * MAX_ANALOG_VALUE)
+                  ifloor<std::uint16_t, float>(finger_curl * MAX_ANALOG_VALUE)
                 );
             }
 #else

lib/opengloves/opengloves/opengloves.hpp

@@ -35,10 +35,15 @@ namespace og {
 
     template<typename Tf = float>
     union InputFingerCurl {
+        /// Access the curl as an array.
         std::array<Tf, 4> curl; // NOLINT(*-magic-numbers): I'm sure our finger aren't changing anytime soon
+
         union {
+            /// The total curl of the finger.
+            /// Only use it if you do not use per-joint tracking.
             Tf curl_total;
 
+            /// Access the individual curl joints.
             struct {
                 Tf curl_joint0;
                 Tf curl_joint1;

lib/opengloves/senseshift/opengloves/opengloves.hpp

@@ -75,7 +75,7 @@ namespace SenseShift::OpenGloves {
 
         auto collectData() -> og::InputPeripheralData
         {
-            og::InputPeripheralData data;
+            og::InputPeripheralData data{};
 
             const auto& curls = this->curl.fingers;
             const auto& splays = this->splay.fingers;

lib/opengloves_freertos/senseshift/opengloves/opengloves_task.hpp

@@ -2,6 +2,7 @@
 
 #include <Arduino.h>
 
+#include <array>
 #include <cstddef>
 #include <optional>
 
@@ -15,6 +16,11 @@
 #include <opengloves/opengloves.hpp>
 #include <utility>
 
+#define SS_START_CALIBRATION_NOT_NULL(ptr) \
+    if ((ptr) != nullptr) {                \
+        (ptr)->startCalibration();         \
+    }
+
 namespace SenseShift::OpenGloves {
     class OpenGlovesTrackingComponent : public SenseShift::Component {
       public:
@@ -32,8 +38,8 @@ namespace SenseShift::OpenGloves {
             }
         };
 
-        OpenGlovesTrackingComponent(Config config, InputSensors& input_sensors, ITransport* communication) :
-          config(config), input_sensors_(std::move(input_sensors)), communication_(communication)
+        OpenGlovesTrackingComponent(Config& config, InputSensors& input_sensors, ITransport* communication) :
+          config_(config), input_sensors_(std::move(input_sensors)), communication_(communication)
         {
             this->encoder_ = new og::AlphaEncoder();
         }
@@ -42,19 +48,51 @@ namespace SenseShift::OpenGloves {
         {
             this->communication_->init();
             this->input_sensors_.init();
+
+            if (this->config_.always_calibrate_) {
+                this->startCalibration();
+            }
         }
 
         void tick() override
         {
+            this->input_sensors_.tick();
             const auto data = this->input_sensors_.collectData();
+            const auto length = this->encoder_->encode_input(data, buffer.data(), buffer.size());
+            this->communication_->send(buffer.data(), length);
+        }
+
+      protected:
+        void startCalibration()
+        {
+            for (auto& finger_curl : this->input_sensors_.curl.fingers) {
+                for (auto& joint_sensor : finger_curl.curl) {
+                    SS_START_CALIBRATION_NOT_NULL(joint_sensor);
+                }
+            }
 
-            char buffer[256];
-            this->encoder_->encode_input(data, buffer, sizeof(buffer));
-            this->communication_->send(buffer, sizeof(buffer));
+            for (auto& finger_splay : this->input_sensors_.splay.fingers) {
+                SS_START_CALIBRATION_NOT_NULL(finger_splay);
+            }
+
+            SS_START_CALIBRATION_NOT_NULL(this->input_sensors_.joystick.x);
+            SS_START_CALIBRATION_NOT_NULL(this->input_sensors_.joystick.y);
+            SS_START_CALIBRATION_NOT_NULL(this->input_sensors_.joystick.press);
+
+            for (auto& button : this->input_sensors_.buttons) {
+                SS_START_CALIBRATION_NOT_NULL(button.press);
+            }
+
+            for (auto& analog_button : this->input_sensors_.analog_buttons) {
+                SS_START_CALIBRATION_NOT_NULL(analog_button.press);
+                SS_START_CALIBRATION_NOT_NULL(analog_button.value);
+            }
         }
 
       private:
-        Config& config;
+        std::array<char, 256> buffer;
+
+        Config& config_;
         InputSensors input_sensors_;
         ITransport* communication_;
         og::IEncoder* encoder_;