Add validation

config.yml

@@ -4,8 +4,8 @@ Pens:
     Color: [127, 127, 127]
     Enabled: true
     LoopCount: 3
-    Speed: 1.234
-    Power: 10.5
+    Speed: 50.0
+    Power: 55.0
     Frequency: 10000
   - !Clone
     From: 0
@@ -14,4 +14,4 @@ Pens:
   - !Pattern
     From: 1
     To: 5
-    Field: !Speed 100
+    Field: !Speed 10

src/config.rs

@@ -2,6 +2,13 @@ use ezcad::pen::Pen;
 use log::debug;
 use serde::{Deserialize, Serialize};
 
+const SPEED_MIN: f64 = 0.0;
+const SPEED_MAX: f64 = 100.0;
+const POWER_MIN: f64 = 0.0;
+const POWER_MAX: f64 = 100.0;
+const FREQUENCY_MIN: u32 = 1000;
+const FREQUENCY_MAX: u32 = 40000;
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "PascalCase")]
 pub struct Patch {
@@ -29,21 +36,40 @@ impl Patch {
 
         if let Some(loop_count) = self.loop_count {
             debug!("Patching loop count for pen #{}: {}", id, loop_count);
+            assert!(loop_count > 0, "Pen loop count must be greater than zero");
             *to_patch.loop_count = loop_count;
         }
 
         if let Some(speed) = self.speed {
             debug!("Patching speed for pen #{}: {}", id, speed);
+            assert!(
+                speed > SPEED_MIN && speed <= SPEED_MAX,
+                "Pen speed must be between {} and {}",
+                SPEED_MIN,
+                SPEED_MAX
+            );
             *to_patch.speed = speed;
         }
 
         if let Some(power) = self.power {
             debug!("Patching power for pen #{}: {}", id, power);
+            assert!(
+                power > POWER_MIN && power <= POWER_MAX,
+                "Pen power must be between {} and {}",
+                POWER_MIN,
+                POWER_MAX
+            );
             *to_patch.power = power;
         }
 
         if let Some(frequency) = self.frequency {
             debug!("Patching frequency for pen #{}: {}", id, frequency);
+            assert!(
+                frequency >= FREQUENCY_MIN && frequency <= FREQUENCY_MAX,
+                "Pen frequency must be between {} and {}",
+                FREQUENCY_MIN,
+                FREQUENCY_MAX
+            );
             *to_patch.frequency = frequency;
             *to_patch.frequency_2 = frequency.try_into().unwrap();
         }
@@ -156,20 +182,44 @@ impl PatternPen {
             // Calculate new setting
             setting = match (setting, &self.field) {
                 (PatternField::Loops(prev), PatternField::Loops(incr)) => {
-                    debug!("Patching loop count for pen #{}: {}", dst, prev + incr);
-                    PatternField::Loops(prev + incr)
+                    let value: i32 = prev + incr;
+                    debug!("Patching loop count for pen #{}: {}", dst, value);
+                    assert!(value > 0, "Pen loop count must be greater than zero");
+                    PatternField::Loops(value)
                 }
                 (PatternField::Speed(prev), PatternField::Speed(incr)) => {
-                    debug!("Patching speed for pen #{}: {}", dst, prev + incr);
-                    PatternField::Speed(prev + incr)
+                    let value: f64 = prev + incr;
+                    debug!("Patching speed for pen #{}: {}", dst, value);
+                    assert!(
+                        value > SPEED_MIN && value <= SPEED_MAX,
+                        "Pen speed must be between {} and {}",
+                        SPEED_MIN,
+                        SPEED_MAX
+                    );
+                    PatternField::Speed(value)
                 }
                 (PatternField::Power(prev), PatternField::Power(incr)) => {
-                    debug!("Patching power for pen #{}: {}", dst, prev + incr);
-                    PatternField::Power(prev + incr)
+                    let value: f64 = prev + incr;
+                    debug!("Patching power for pen #{}: {}", dst, value);
+                    assert!(
+                        value > POWER_MIN && value <= POWER_MAX,
+                        "Pen power must be between {} and {}",
+                        POWER_MIN,
+                        POWER_MAX
+                    );
+                    PatternField::Power(value)
                 }
                 (PatternField::Frequency(prev), PatternField::Frequency(incr)) => {
-                    debug!("Patching frequency for pen #{}: {}", dst, prev + incr);
-                    PatternField::Frequency(prev + incr)
+                    let value: i32 = prev + incr;
+                    debug!("Patching frequency for pen #{}: {}", dst, value);
+                    assert!(
+                        value >= FREQUENCY_MIN.try_into().unwrap()
+                            && value <= FREQUENCY_MAX.try_into().unwrap(),
+                        "Pen frequency must be between {} and {}",
+                        FREQUENCY_MIN,
+                        FREQUENCY_MAX
+                    );
+                    PatternField::Frequency(value)
                 }
                 _ => unreachable!(),
             };