Enhance examples and core functionality with type consistency and new features

- Updated ObservableAnalogInput to use template for type flexibility
- Added automatic update method to ObservableAnalogInput example
- Improved accelerometer example with helper functions for clarity
- Refactored PID examples to ensure consistent use of ObservableAnalogInput
- Introduced new OperatorSelect for enhanced data transformation
- Added comparison operators to data structures for better functionality
- Updated main workflow to streamline build process
- Created .gitignore for better repository management

Author: rzeldent

.github/workflows/main.yml

@@ -4,9 +4,10 @@ jobs:
   build:
     name: Build Examples
     runs-on: ubuntu-latest
+    env:
+      pio-env: 'esp12e'
     strategy:
       matrix:
-        pio-env: ['esp12e', 'esp32dev', 'uno', 'nanoatmega328']
         example: [
           'Blink/Blink.cpp', 
           'Do/Do.cpp', 
@@ -34,4 +35,4 @@ jobs:
       - name: Install PlatformIO
         run: python -m pip install platformio
       - name: Build firmware
-        run: pio ci --lib="." --board ${{matrix.pio-env}}  "examples/${{matrix.example}}"
+        run: pio ci --lib="." --board ${{pio-env}}  "examples/${{matrix.example}}"

.gitignore

@@ -0,0 +1,2 @@
+.pio
+.vscode/*

README.md

@@ -53,7 +53,65 @@ More examples in Wiki/[Examples](https://github.com/luisllamasbinaburo/Arduino-R
 ### Observable, observers and operators legend
 More info about the Observables, Observers, and Operators available in the [Wiki](https://github.com/luisllamasbinaburo/Arduino-ReactiveArduino/wiki)
 
-![alt text](https://github.com/luisllamasbinaburo/Arduino-ReactiveArduino/blob/master/ReactiveArduino%20Legend.png "Legend")
+```
+┌─────────────────────────────────────────────────────────────────────────────────────┐
+│                        🔄 REACTIVE ARDUINO COMPONENT LEGEND 🔄                      │
+├─────────────────────────────────────────────────────────────────────────────────────┤
+│                                                                                     │
+│  📡 OBSERVABLES (Data Sources)                                                     │
+│  ┌─────────────────────────────────────────────────────────────────────────────┐   │
+│  │ • FromArray()        • FromProperty()     • FromSerial()                    │   │
+│  │ • FromRange()        • AnalogInput()      • DigitalInput()                  │   │
+│  │ • TimerMillis()      • TimerMicros()      • IntervalMillis()                │   │
+│  │ • Property<T>()      • ManualDefer()      • IntervalMicros()                │   │
+│  └─────────────────────────────────────────────────────────────────────────────┘   │
+│                                 ⬇️                                                  │
+│  🔧 OPERATORS (Data Processing)                                                    │
+│  ┌─────────────────────────────────────────────────────────────────────────────┐   │
+│  │ • Where()            • Distinct()         • DistinctUntilChanged()          │   │
+│  │ • First()            • Last()             • Skip() / Take()                 │   │
+│  │ • SkipWhile()        • TakeWhile()        • SkipUntil() / TakeUntil()       │   │
+│  │ • Batch()            • Repeat()           • Loop()                          │   │
+│  └─────────────────────────────────────────────────────────────────────────────┘   │
+│                                 ⬇️                                                  │
+│  🔄 TRANSFORMATIONS (Data Conversion)                                              │
+│  ┌─────────────────────────────────────────────────────────────────────────────┐   │
+│  │ • Select()           • Map<T>()           • Cast<T>()                       │   │
+│  │ • SelectTo<T>()      • Reduce()           • Scale()                         │   │
+│  │ • Limit()            • LimitUpper()       • LimitLower()                    │   │
+│  │ • Millis()           • Micros()           • Timestamp()                     │   │
+│  └─────────────────────────────────────────────────────────────────────────────┘   │
+│                                 ⬇️                                                  │
+│  🌡️ FILTERS (Conditional Processing)                                               │
+│  ┌─────────────────────────────────────────────────────────────────────────────┐   │
+│  │ • IsEqual()          • IsNotEqual()       • IsGreater() / IsLess()          │   │
+│  │ • IsZero()           • IsNotZero()        • OnRising() / OnFalling()        │   │
+│  │ • DebounceMillis()   • LowPass()          • HighPass()                      │   │
+│  │ • MovingAverage()    • Median3/5()        • WindowMillis()                  │   │
+│  └─────────────────────────────────────────────────────────────────────────────┘   │
+│                                 ⬇️                                                  │
+│  📊 AGGREGATES (Statistical Operations)                                            │
+│  ┌─────────────────────────────────────────────────────────────────────────────┐   │
+│  │ • Count()            • CountDown()        • Sum()                           │   │
+│  │ • Min() / Max()      • Average()          • RMS()                           │   │
+│  │ • Any()              • All()              • None()                          │   │
+│  └─────────────────────────────────────────────────────────────────────────────┘   │
+│                                 ⬇️                                                  │
+│  🎯 OBSERVERS (Data Consumers)                                                     │
+│  ┌─────────────────────────────────────────────────────────────────────────────┐   │
+│  │ • Do()               • Finally()          • DoAndFinally()                  │   │
+│  │ • ToSerial()         • ToProperty()       • ToArray()                       │   │
+│  │ • ToDigitalOutput()  • ToAnalogOutput()   • ToCircularBuffer()              │   │
+│  │ • DoNothing()        • (Custom Actions)                                     │   │
+│  └─────────────────────────────────────────────────────────────────────────────┘   │
+│                                                                                     │
+│  💡 USAGE PATTERN: Observable → [Operators] → [Transformations] → [Filters] →     │
+│                    [Aggregates] → Observer                                         │
+│                                                                                     │
+│  Example: FromArray(data, size).Where(condition).Select(transform).ToSerial()      │
+│                                                                                     │
+└─────────────────────────────────────────────────────────────────────────────────────┘
+```
 
 ### Creating Observables
 Observables are generally generated through factory methods provided by the Reactive class.

examples/AccelerometerExample/AccelerometerExample.cpp

@@ -10,9 +10,35 @@ Unless required by applicable law or agreed to in writing, software distributed
 #include "ReactiveArduinoLib.h"
 using namespace Reactive;
 
+// Helper functions for type conversion
+float getMagnitude(AccelerometerData data) {
+	return data.magnitude;
+}
+
+float getTiltAngle(AccelerometerData data) {
+	return atan2(data.y, data.x) * 180.0 / PI;
+}
+
+bool magnitudeThreshold(float magnitude) {
+	return magnitude > 1.2;
+}
+
+void printStepCount(float magnitude) {
+	static int stepCount = 0;
+	stepCount++;
+	Serial.print("Steps counted: ");
+	Serial.println(stepCount);
+}
+
+void printTiltBrightness(float mappedAngle) {
+	int intAngle = (int)mappedAngle;
+	Serial.print("Tilt mapped to LED brightness: ");
+	Serial.println(intAngle);
+	analogWrite(9, intAngle);
+}
+
 // Example demonstrating accelerometer observable and scan operator
-auto accelerometer = ObservableAccelerometer<AccelerometerData>(A0, A1, A2, 100); // X, Y, Z pins, 100ms interval
-int stepCount = 0;
+auto accelerometer = Reactive::ObservableAccelerometer<AccelerometerData>(A3, A4, A5, 100); // X, Y, Z pins, 100ms interval
 
 void setup()
 {
@@ -24,26 +50,16 @@ void setup()
 
 	// Step counter using scan operator
 	accelerometer
-	.Select([](AccelerometerData data) { return data.magnitude; })
-	.Where([](float magnitude) { return magnitude > 1.2; })  // Motion threshold
+	.Select(getMagnitude)
+	.Where(magnitudeThreshold)
 	.DistinctUntilChanged()  // Only count distinct movements
-	.Do([](float magnitude) {
-		stepCount++;  // Manual step counting for now
-		Serial.print("Steps counted: ");
-		Serial.println(stepCount);
-	});
+	.Do(printStepCount);
 
 	// Tilt detection
 	accelerometer
-	.Select([](AccelerometerData data) { 
-		return atan2(data.y, data.x) * 180.0 / PI;  // Calculate tilt angle
-	})
+	.Select(getTiltAngle)
 	.Scale(-90.0, 90.0, 0, 255)  // Map angle to 0-255 range
-	.Do([](int mappedAngle) {
-		Serial.print("Tilt mapped to LED brightness: ");
-		Serial.println(mappedAngle);
-		analogWrite(9, mappedAngle);  // Control LED brightness with tilt
-	});
+	.Do(printTiltBrightness);
 }
 
 void loop()

examples/AnalogInputUpdate/AnalogInputUpdate.cpp

@@ -0,0 +1,101 @@
+/***************************************************
+Copyright (c) 2019 Luis Llamas
+(www.luisllamas.es)
+
+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
+ ****************************************************/
+
+#include "ReactiveArduinoLib.h"
+using namespace Reactive;
+
+// ObservableAnalogInput Update() Method Example
+// Demonstrates automatic timer-based analog input reading
+
+// Create analog input observable with automatic 500ms update interval
+auto analogSensor = ObservableAnalogInput<int>(A0, 500);
+
+// Helper function for printing values
+void printAnalogValue(int value) {
+    Serial.print("Analog Value: ");
+    Serial.print(value);
+    Serial.print(" (");
+    Serial.print((value / 1023.0) * 100.0);
+    Serial.println("%)");
+}
+
+// Helper function for voltage conversion
+float convertToVoltage(int adcValue) {
+    return (adcValue / 1023.0) * 5.0;  // Assuming 5V reference
+}
+
+// Helper function for printing voltage
+void printVoltage(float voltage) {
+    Serial.print("Voltage: ");
+    Serial.print(voltage);
+    Serial.println("V");
+}
+
+// Helper function for printing smoothed voltage
+void printSmoothedVoltage(float smoothedVoltage) {
+    Serial.print("Smoothed Voltage: ");
+    Serial.print(smoothedVoltage);
+    Serial.println("V (5-sample average)");
+}
+
+void setup()
+{
+    Serial.begin(115200);
+    while (!Serial) delay(1);
+    
+    Serial.println("=== ObservableAnalogInput Update() Example ===");
+    Serial.println("Reading A0 every 500ms automatically using Update() method");
+    Serial.println("Raw ADC values and voltage conversion will be displayed");
+    
+    // Chain 1: Display raw ADC values
+    analogSensor
+    .Do(printAnalogValue);
+    
+    // Chain 2: Convert to voltage and display
+    analogSensor
+    .Map<float>(convertToVoltage)
+    .Do(printVoltage);
+    
+    // Chain 3: Demonstrate filtering with automatic updates
+    analogSensor
+    .Map<float>(convertToVoltage)
+    .MovingAverage(5)  // 5-sample moving average
+    .Do(printSmoothedVoltage);
+    
+    Serial.println("Setup complete. Automatic updates every 500ms...");
+}
+
+void loop()
+{
+    // Call Update() to trigger automatic timer-based reading
+    analogSensor.Update();
+    
+    // You can also manually trigger readings using Next()
+    // analogSensor.Next();  // Immediate reading, ignoring timer
+    
+    // Change interval dynamically if needed
+    static unsigned long lastIntervalChange = 0;
+    if (millis() - lastIntervalChange > 10000) {  // Every 10 seconds
+        static bool fastMode = false;
+        fastMode = !fastMode;
+        
+        if (fastMode) {
+            analogSensor.SetInterval(100);  // Fast: 100ms
+            Serial.println(">> Switched to FAST mode (100ms intervals)");
+        } else {
+            analogSensor.SetInterval(1000);  // Slow: 1000ms
+            Serial.println(">> Switched to SLOW mode (1000ms intervals)");
+        }
+        
+        lastIntervalChange = millis();
+    }
+    
+    // The loop can do other work while analog reading happens automatically
+    delay(10);  // Small delay to prevent tight loop
+}

examples/DistinctExample/DistinctExample.cpp

@@ -10,6 +10,21 @@ Unless required by applicable law or agreed to in writing, software distributed
 #include "ReactiveArduinoLib.h"
 using namespace Reactive;
 
+// Helper functions for actions
+void printValue(int value) {
+    Serial.print(value);
+    Serial.print(" ");
+}
+
+void printNewline() {
+    Serial.println();
+}
+
+void printUniqueValue(int uniqueValue) {
+    Serial.print("New unique sensor value: ");
+    Serial.println(uniqueValue);
+}
+
 // Example demonstrating the difference between Distinct and DistinctUntilChanged
 int values[] = { 1, 2, 3, 2, 4, 1, 5, 3, 6, 2, 1 };
 int valuesLength = sizeof(values) / sizeof(values[0]);
@@ -23,35 +38,17 @@ void setup()
 
     Serial.println("\nOriginal sequence:");
     FromArray(values, valuesLength)
-    .Do([](int value) {
-        Serial.print(value);
-        Serial.print(" ");
-    })
-    .Finally([]() {
-        Serial.println();
-    });
+    .DoAndFinally(printValue, printNewline);
 
     Serial.println("\nWith Distinct() - removes ALL duplicates:");
     FromArray(values, valuesLength)
     .Distinct()  // New operator: removes all duplicate values
-    .Do([](int value) {
-        Serial.print(value);
-        Serial.print(" ");
-    })
-    .Finally([]() {
-        Serial.println();
-    });
+    .DoAndFinally(printValue, printNewline);
 
     Serial.println("\nWith DistinctUntilChanged() - removes consecutive duplicates only:");
     FromArray(values, valuesLength)
     .DistinctUntilChanged()  // Existing operator: removes only consecutive duplicates
-    .Do([](int value) {
-        Serial.print(value);
-        Serial.print(" ");
-    })
-    .Finally([]() {
-        Serial.println();
-    });
+    .DoAndFinally(printValue, printNewline);
 
     Serial.println("\n=== Sensor Reading Example ===");
     Serial.println("Simulating sensor with noise and repeated readings...");
@@ -71,15 +68,11 @@ void loop()
             int currentReading = sensorReadings[readingIndex];
 
             // Process with Distinct to get unique values only
-            auto obs = Property<int>();
-            obs.SetValue(currentReading);
+            auto obs = FromArray(&currentReading, 1);
 
             obs
             .Distinct()
-            .Do([](int uniqueValue) {
-                Serial.print("New unique sensor value: ");
-                Serial.println(uniqueValue);
-            });
+            .Do(printUniqueValue);
 
             readingIndex++;
             lastReading = millis();

examples/PIDMotorSpeedControl/PIDMotorSpeedControl.cpp

@@ -14,7 +14,7 @@ using namespace Reactive;
 // Hardware: Encoder on pins 2&3, motor driver on pin 9, potentiometer on A0
 
 auto encoder = ObservableRotaryEncoder<RotaryEncoderData>(2, 3);
-auto potentiometer = ObservableAnalogInput(A0, 100);  // Read setpoint every 100ms
+auto potentiometer = ObservableAnalogInput<int>(A0, 100);  // Read setpoint every 100ms
 auto speedTimer = IntervalMillis(250);  // Calculate speed every 250ms
 
 auto pidController = FilterPID<float>(0, 1.5, 0.2, 0.1, -255, 255);