diff --git a/src/config.rs b/src/config.rs
index ca1962c..1c317cb 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -51,9 +51,9 @@ pub struct AppConfig {
 
 #[derive(Debug, Default, Clone)]
 pub struct ModbusValueMaps {
-    pub modbus_coils_values: HashMap<String, f64>,
-    pub modbus_input_register_values: HashMap<String, f64>,
-    pub modbus_holding_register_values: HashMap<String, f64>,
+    pub modbus_coils_values: HashMap<String, Option<f64>>,
+    pub modbus_input_register_values: HashMap<String, Option<f64>>,
+    pub modbus_holding_register_values: HashMap<String, Option<f64>>,
 }
 
 impl ModbusValueMaps {
@@ -62,7 +62,7 @@ impl ModbusValueMaps {
         if let Some(ref vec) = config.modbus_coils {
             for map in vec {
                 for key in map.keys() {
-                    coils.entry(key.clone()).or_insert(0.0);
+                    coils.entry(key.clone()).or_insert(None);
                 }
             }
         }
@@ -70,7 +70,7 @@ impl ModbusValueMaps {
         if let Some(ref vec) = config.modbus_input_register {
             for map in vec {
                 for key in map.keys() {
-                    input.entry(key.clone()).or_insert(0.0);
+                    input.entry(key.clone()).or_insert(None);
                 }
             }
         }
@@ -78,7 +78,7 @@ impl ModbusValueMaps {
         if let Some(ref vec) = config.modbus_holding_register {
             for map in vec {
                 for key in map.keys() {
-                    holding.entry(key.clone()).or_insert(0.0);
+                    holding.entry(key.clone()).or_insert(None);
                 }
             }
         }
diff --git a/src/modbus.rs b/src/modbus.rs
index 9be5f9f..15fb8df 100644
--- a/src/modbus.rs
+++ b/src/modbus.rs
@@ -42,13 +42,22 @@ pub fn start_modbus_polling_thread(
                                 let addr = reg.addr;
                                 let typ = reg.r#type.as_deref().unwrap_or("");
                                 let factor = reg.factor.unwrap_or(1.0);
-                                let value = rt.block_on(async {
+                                let value: Option<f64> = rt.block_on(async {
                                     match typ {
-                                        "INT16" | "UINT16" => client.read_input_registers(addr, 1).await.ok().map(|v| v[0] as f64 * factor),
-                                        "UINT32" => client.read_input_registers(addr, 2).await.ok().map(|v| ((v[0] as u32) << 16 | (v[1] as u32)) as f64 * factor),
+                                        "INT16" => client.read_input_registers(addr, 1).await.ok().map(|v| {
+                                            let raw = v[0] as i16;
+                                            if raw == -32768 || raw == 32767 { None } else { Some(raw as f64 * factor) }
+                                        }).flatten(),
+                                        "UINT16" => client.read_input_registers(addr, 1).await.ok().map(|v| {
+                                            if v[0] == 0xFFFF { None } else { Some(v[0] as f64 * factor) }
+                                        }).flatten(),
+                                        "UINT32" => client.read_input_registers(addr, 2).await.ok().map(|v| {
+                                            let raw = (v[0] as u32) << 16 | (v[1] as u32);
+                                            if raw == 0xFFFFFFFF { None } else { Some(raw as f64 * factor) }
+                                        }).flatten(),
                                         _ => Some(0.0),
                                     }
-                                }).unwrap_or(0.0);
+                                });
                                 if let Ok(mut maps) = value_maps.lock() {
                                     maps.modbus_input_register_values.insert(key.clone(), value);
                                 }
@@ -62,13 +71,22 @@ pub fn start_modbus_polling_thread(
                                 let addr = reg.addr;
                                 let typ = reg.r#type.as_deref().unwrap_or("");
                                 let factor = reg.factor.unwrap_or(1.0);
-                                let value = rt.block_on(async {
+                                let value: Option<f64> = rt.block_on(async {
                                     match typ {
-                                        "INT16" | "UINT16" => client.read_holding_registers(addr, 1).await.ok().map(|v| v[0] as f64 * factor),
-                                        "UINT32" => client.read_holding_registers(addr, 2).await.ok().map(|v| ((v[0] as u32) << 16 | (v[1] as u32)) as f64 * factor),
+                                        "INT16" => client.read_holding_registers(addr, 1).await.ok().map(|v| {
+                                            let raw = v[0] as i16;
+                                            if raw == -32768 || raw == 32767 { None } else { Some(raw as f64 * factor) }
+                                        }).flatten(),
+                                        "UINT16" => client.read_holding_registers(addr, 1).await.ok().map(|v| {
+                                            if v[0] == 0xFFFF { None } else { Some(v[0] as f64 * factor) }
+                                        }).flatten(),
+                                        "UINT32" => client.read_holding_registers(addr, 2).await.ok().map(|v| {
+                                            let raw = (v[0] as u32) << 16 | (v[1] as u32);
+                                            if raw == 0xFFFFFFFF { None } else { Some(raw as f64 * factor) }
+                                        }).flatten(),
                                         _ => Some(0.0),
                                     }
-                                }).unwrap_or(0.0);
+                                });
                                 if let Ok(mut maps) = value_maps.lock() {
                                     maps.modbus_holding_register_values.insert(key.clone(), value);
                                 }
@@ -84,7 +102,7 @@ pub fn start_modbus_polling_thread(
                                     client.read_coils(addr, 1).await.ok().map(|v| if v[0] { 1.0 } else { 0.0 })
                                 }).unwrap_or(0.0);
                                 if let Ok(mut maps) = value_maps.lock() {
-                                    maps.modbus_coils_values.insert(key.clone(), value);
+                                    maps.modbus_coils_values.insert(key.clone(), Some(value));
                                 }
                             }
                         }