eneuber/paramod-rust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Nicht vorhandene Sensoren beachten

Browse Source
This commit is contained in:
Eric Neuber 2026-02-16 22:50:00 +01:00
parent 459b97d95c
commit 7fb98b95f8
2 changed files with 33 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/config.rs
View File

@ -51,9 +51,9 @@ pub struct AppConfig {
#[derive(Debug, Default, Clone)] #[derive(Debug, Default, Clone)]
pub struct ModbusValueMaps { pub struct ModbusValueMaps {
pub modbus_coils_values: HashMap<String, f64>, pub modbus_coils_values: HashMap<String, Option<f64>>,
pub modbus_input_register_values: HashMap<String, f64>, pub modbus_input_register_values: HashMap<String, Option<f64>>,
pub modbus_holding_register_values: HashMap<String, f64>, pub modbus_holding_register_values: HashMap<String, Option<f64>>,
} }
impl ModbusValueMaps { impl ModbusValueMaps {
@ -62,7 +62,7 @@ impl ModbusValueMaps {
if let Some(ref vec) = config.modbus_coils { if let Some(ref vec) = config.modbus_coils {
for map in vec { for map in vec {
for key in map.keys() { 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 { if let Some(ref vec) = config.modbus_input_register {
for map in vec { for map in vec {
for key in map.keys() { 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 { if let Some(ref vec) = config.modbus_holding_register {
for map in vec { for map in vec {
for key in map.keys() { for key in map.keys() {
holding.entry(key.clone()).or_insert(0.0); holding.entry(key.clone()).or_insert(None);
} }
} }
} }

36
src/modbus.rs
View File

@ -42,13 +42,22 @@ pub fn start_modbus_polling_thread(
let addr = reg.addr; let addr = reg.addr;
let typ = reg.r#type.as_deref().unwrap_or(""); let typ = reg.r#type.as_deref().unwrap_or("");
let factor = reg.factor.unwrap_or(1.0); let factor = reg.factor.unwrap_or(1.0);
let value = rt.block_on(async { let value: Option<f64> = rt.block_on(async {
match typ { match typ {
"INT16" | "UINT16" => client.read_input_registers(addr, 1).await.ok().map(|v| v[0] as f64 * factor), "INT16" => client.read_input_registers(addr, 1).await.ok().map(|v| {
"UINT32" => client.read_input_registers(addr, 2).await.ok().map(|v| ((v[0] as u32) << 16 | (v[1] as u32)) as f64 * factor), 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), _ => Some(0.0),
} }
}).unwrap_or(0.0); });
if let Ok(mut maps) = value_maps.lock() { if let Ok(mut maps) = value_maps.lock() {
maps.modbus_input_register_values.insert(key.clone(), value); maps.modbus_input_register_values.insert(key.clone(), value);
} }
@ -62,13 +71,22 @@ pub fn start_modbus_polling_thread(
let addr = reg.addr; let addr = reg.addr;
let typ = reg.r#type.as_deref().unwrap_or(""); let typ = reg.r#type.as_deref().unwrap_or("");
let factor = reg.factor.unwrap_or(1.0); let factor = reg.factor.unwrap_or(1.0);
let value = rt.block_on(async { let value: Option<f64> = rt.block_on(async {
match typ { match typ {
"INT16" | "UINT16" => client.read_holding_registers(addr, 1).await.ok().map(|v| v[0] as f64 * factor), "INT16" => client.read_holding_registers(addr, 1).await.ok().map(|v| {
"UINT32" => client.read_holding_registers(addr, 2).await.ok().map(|v| ((v[0] as u32) << 16 | (v[1] as u32)) as f64 * factor), 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), _ => Some(0.0),
} }
}).unwrap_or(0.0); });
if let Ok(mut maps) = value_maps.lock() { if let Ok(mut maps) = value_maps.lock() {
maps.modbus_holding_register_values.insert(key.clone(), value); 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 }) client.read_coils(addr, 1).await.ok().map(|v| if v[0] { 1.0 } else { 0.0 })
}).unwrap_or(0.0); }).unwrap_or(0.0);
if let Ok(mut maps) = value_maps.lock() { 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));
} }
} }
} }