Files
watermeter_watcher/src/main.rs
T
Romulus21andClaude Opus 5.5 83208191f2 Read the meter with vision LLMs and push the index to Home Assistant
- Add Claude, Mistral and local Ollama (lfm3-vl) vision backends that read
  the digits inside the blue boxes of a cropped, upscaled picture
- Retry every 30s when the picture has no blue box or the reading does not
  have WATERMETER_DIGITS digits
- Set input_number.index_compteur_d_eau to reading * 100 when it is within
  1000 of the current value
- Append one line per run to watermeter.log for cron runs

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 14:24:09 +01:00

191 lines
6.0 KiB
Rust

mod boxes;
mod claude;
mod fetch;
mod homeassistant;
mod mistral;
mod ocr;
mod ollama;
mod runlog;
mod vision;
use std::path::PathBuf;
use std::process::ExitCode;
use std::time::Duration;
use anyhow::{Context, Result};
use image::{Rgb, RgbImage};
use boxes::{BBox, find_blue_boxes};
use ocr::DigitReader;
const DEBUG_DIR: &str = "debug";
/// Wait between two downloads when the picture has no blue box or the reading has the wrong length.
const RETRY_DELAY: Duration = Duration::from_secs(30);
/// Give up after this many downloads without a valid reading.
const MAX_ATTEMPTS: u32 = 10;
fn main() -> ExitCode {
let (status, code) = match run() {
Ok(true) => ("ok", ExitCode::SUCCESS),
Ok(false) => ("incomplete", ExitCode::from(2)),
Err(e) => {
runlog::note(format!("error: {e:#}"));
("error", ExitCode::FAILURE)
}
};
if let Err(e) = runlog::write(status) {
eprintln!("error: {e:#}");
}
code
}
/// Returns whether every digit could be read.
fn run() -> Result<bool> {
dotenvy::dotenv_override().ok();
let args: Vec<String> = std::env::args().skip(1).collect();
let has = |flag: &str| args.iter().any(|a| a == flag);
let debug = has("--debug");
let url = std::env::var("WATERMETER_URL").context("WATERMETER_URL is not set")?;
let expected_len = match std::env::var("WATERMETER_DIGITS") {
Ok(v) => Some(
v.trim()
.parse::<usize>()
.context("WATERMETER_DIGITS must be a positive integer")?,
),
Err(_) => None,
};
for attempt in 1..=MAX_ATTEMPTS {
let retry = |why: &str| {
if attempt < MAX_ATTEMPTS {
runlog::note(format!(
"{why} (attempt {attempt}/{MAX_ATTEMPTS}), retrying in {}s",
RETRY_DELAY.as_secs()
));
std::thread::sleep(RETRY_DELAY);
}
};
let bytes = fetch::fetch_image(&url)?;
let img = image::load_from_memory(&bytes)
.context("failed to decode image")?
.into_rgb8();
if find_blue_boxes(&img).is_empty() {
retry("no blue box in picture");
continue;
}
let digits = read_digits(&bytes, &has, debug)?;
let reading: String = digits.iter().map(|d| d.as_deref().unwrap_or("?")).collect();
if let Some(n) = expected_len
&& reading.chars().count() != n
{
retry(&format!("read {reading:?}, expected {n} digits"));
continue;
}
println!("{reading}");
runlog::note(format!("reading {reading}"));
let complete = !digits.is_empty() && digits.iter().all(Option::is_some);
if complete {
update_home_assistant(&reading)?;
}
return Ok(complete);
}
anyhow::bail!("no valid reading after {MAX_ATTEMPTS} attempts")
}
/// Push `reading * 100` to Home Assistant when it is close enough to the current index.
fn update_home_assistant(reading: &str) -> Result<()> {
let Some(ha) = homeassistant::HomeAssistant::from_env() else {
runlog::note("HA_URL / HA_TOKEN not set, Home Assistant not updated");
return Ok(());
};
let value = reading.parse::<f64>().context("reading is not a number")? * 100.0;
runlog::note(match ha.sync_index(value)? {
homeassistant::Outcome::Updated { previous } => {
format!("{} updated: {previous} -> {value}", ha.entity())
}
homeassistant::Outcome::Unchanged => format!("{} already at {value}", ha.entity()),
homeassistant::Outcome::Rejected { current } => format!(
"{value} is more than 1000 away from {} ({current}), not updated",
ha.entity()
),
});
Ok(())
}
fn read_digits(
bytes: &[u8],
has: &dyn Fn(&str) -> bool,
debug: bool,
) -> Result<Vec<Option<String>>> {
if has("--ocrs") {
return read_with_ocrs(bytes, debug);
}
let crop = vision::crop_to_boxes(bytes)?;
if debug {
std::fs::create_dir_all(DEBUG_DIR)?;
std::fs::write(format!("{DEBUG_DIR}/crop.png"), &crop)?;
}
let llm_digits = if has("--mistral") {
mistral::read_digits(&crop)?
} else if has("--ollama") {
ollama::read_digits(&crop)?
} else {
claude::read_digits(&crop)?
};
Ok(llm_digits
.into_iter()
.map(|d| d.map(String::from))
.collect())
}
fn read_with_ocrs(bytes: &[u8], debug: bool) -> Result<Vec<Option<String>>> {
let models_dir = std::env::var_os("OCRS_MODELS_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("models"));
let img = image::load_from_memory(bytes)
.context("failed to decode image")?
.into_rgb8();
let boxes: Vec<BBox> = find_blue_boxes(&img)
.iter()
.filter_map(BBox::interior)
.collect();
anyhow::ensure!(!boxes.is_empty(), "no blue box found in image");
let reader = DigitReader::new(&models_dir)?;
let digits = reader.read_boxes(&img, &boxes)?;
if debug {
save_debug(&img, &boxes, &digits)?;
}
Ok(digits)
}
fn save_debug(img: &RgbImage, boxes: &[BBox], digits: &[Option<String>]) -> Result<()> {
std::fs::create_dir_all(DEBUG_DIR)?;
let mut annotated = img.clone();
for (i, (b, d)) in boxes.iter().zip(digits).enumerate() {
image::imageops::crop_imm(img, b.x, b.y, b.w, b.h)
.to_image()
.save(format!("{DEBUG_DIR}/box_{i}.png"))?;
draw_rect(&mut annotated, b, Rgb([255, 0, 0]));
eprintln!("box {i}: {b:?} -> {}", d.as_deref().unwrap_or("?"));
}
annotated.save(format!("{DEBUG_DIR}/full.png"))?;
Ok(())
}
fn draw_rect(img: &mut RgbImage, b: &BBox, color: Rgb<u8>) {
let (x1, y1) = (b.x + b.w - 1, b.y + b.h - 1);
for x in b.x..=x1 {
img.put_pixel(x, b.y, color);
img.put_pixel(x, y1, color);
}
for y in b.y..=y1 {
img.put_pixel(b.x, y, color);
img.put_pixel(x1, y, color);
}
}