Continuum/continuum-proxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Confirm the light and the upload on a real P1P

Browse Source 
Four things were shipped unverified because the printer was off when they
were written. Three are now confirmed first-hand (P1P, 2026-10-15), and one
is settled in the opposite direction from what was assumed.

**`set_light` had never once reached a printer**, and `completion::run`
blinks a finished print's chamber light with it. It works - but "accepted" is
not "it changed": `ledctrl` answers `result: "success"` as soon as the
command parses, exactly like the print-control verbs. So `lights_report` is
now modelled on `PrintReport`, which is the only read-back there is, and the
probe polls it rather than printing a reassuring message. Setting the light
on and off reads `[{"node":"chamber_light","mode":"on"}]` / `"off"` back,
about 3s later. The field was observed on v1 even though only the v2 schema
declares it.

**The blink itself works at the rate it ships at.** `completion::celebrate`
is now public so the probe runs the real function instead of a copy: twenty
`ledctrl` commands half a second apart, which a printer is entitled to
refuse. None were refused, it returned after 10.35s, and the light ended
`off` as specified - a blink that leaves the light on would look like a
printer still working.

**The firmware's own `flashing` mode is not the better option.** It is
accepted, and the reply echoes all four parameters back
(`led_on_time`, `led_off_time`, `loop_times`, `interval_time`), so the
printer does parse them. But `lights_report` never reports `flashing` - it
stayed on the previous mode for 12s of polling. A firmware blink is therefore
unobservable: nothing can confirm it happened or tell when it ended, while
the self-driven blink is built from a call that reads back. That is a better
reason to keep `celebrate` than the one in the comment it replaces, which was
that `loop_times` semantics were unconfirmed. Whether the light physically
blinks is still unwitnessed - nobody was watching the machine.

**Multi-MB FTPS upload works, and is slow.** A 4.96 MB project archive went
up with an exact byte count and came back byte-identical (sha256). But it
took 31.3s - about 0.2 MiB/s - so the 62 MB project already on that card
would take six and a half minutes. Anything that uploads a job needs a
timeout budgeted in minutes, not seconds. The claim in `download`'s comment
that these files are "a few hundred KB" is gone; the card disproves it.

Also adds `delete`, because the probe left a 5 MB file on a real SD card and
there was no way to remove it. One explicit path, no globbing: the convenient
version of this deletes something somebody printed from last week. Used to
clean up, and the card is back as it was.

New probe steps: `light on|off|flash`, `blink`, `upload <local> [name]`,
`delete <path>`. 51 tests still pass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
octoturge
2026-10-15 22:23:41 +00:00
co-authored by Claude Opus 5
parent 6766ebbe80
commit 3d907d0443
7 changed files with 324 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/bambu_print_probe.rs
+217 -2
View File
@@ -16,6 +16,25 @@
//! at all? A clean rejection naming the file means the
//! shape is right and only the target was wrong. A
//! parse error, or silence, means the shape is wrong.
//! - `upload <local> [name]`
//! **inert.** FTPS-transfers a local file onto the card
//! and stops - nothing prints until told to. Reports
//! the byte count the printer accepted and the rate.
//! - `delete <path>` removes one named file from the card.
//! - `blink` runs `completion::celebrate`, the real ten-second
//! finished-print blink, and then checks the light
//! ended off. Twenty light commands in ten seconds is
//! a rate the printer may refuse, which is the thing
//! this answers.
//! - `light on|off|flash`
//! **no physical risk** beyond a light changing. `on`
//! and `off` go through `BambuPrinter::set_light`, the
//! same call `completion::run` blinks with, so this
//! confirms the shipped path rather than a hand-built
//! body. `flash` instead sends the schema's `flashing`
//! mode raw, to settle what `loop_times` and
//! `interval_time` actually do - the self-driven blink
//! exists because that was unconfirmed.
//! - `start <file>` sends `print.gcode_file`/`print.project_file` for a
//! file in `cache/`. Gated on `gcode_state: IDLE` and
//! on the explicit flag.
@@ -34,12 +53,20 @@
use std::time::Duration;
use continuum_proxy::fleet;
use continuum_proxy::printer::{FilamentSource, GenericPrinter, PrintControl, PrinterHandle};
use continuum_proxy::printer::{
FilamentSource, GenericPrinter, LightState, PrintControl, PrinterHandle, CHAMBER_LIGHT,
};
const CONNECT_TIMEOUT: Duration = Duration::from_secs(20);
const STATUS_TIMEOUT: Duration = Duration::from_secs(15);
/// How long to watch the report stream after sending something.
const WATCH: Duration = Duration::from_secs(20);
/// How long to wait for a light change to show up in `lights_report`. A v1
/// printer only reports when asked, so this polls `pushall` rather than
/// waiting on an organic push that is not coming.
const LIGHT_READBACK: Duration = Duration::from_secs(12);
/// Only for the message - `completion.rs` owns the real value.
const BLINK_FOR_DISPLAY: &str = "10s";
/// A file name that cannot exist in `cache/`, for `probe-missing`.
const MISSING_FILE: &str = "continuum-probe-no-such-file.gcode";
@@ -65,11 +92,18 @@ async fn main() -> anyhow::Result<()> {
let (Some(target), Some(step)) = (args.get(1).cloned(), args.get(2).cloned()) else {
anyhow::bail!(
"usage: cargo run --example bambu_print_probe -- <printer-id> <step> [arg]\n\
steps: status | probe-missing | start <file-in-cache> | pause | resume | stop"
steps: status | probe-missing | light on|off|flash | start <file-in-cache> \
| pause | resume | stop"
);
};
let confirmed = args.iter().any(|a| a == "--yes-start-a-real-print");
// Handled before the fleet below is borrowed, because the real blink
// wants the whole fleet behind a lock rather than one printer.
if step == "blink" {
return blink_probe(&target).await;
}
let mut printers = fleet::load(std::path::Path::new("printers.toml"))?;
let printer = printers
.iter_mut()
@@ -190,6 +224,60 @@ async fn main() -> anyhow::Result<()> {
}
}
// `light on|off|flash`. The first two deliberately go through
// `set_light` rather than a raw body: that method had never once
// reached a printer, and `completion::run` blinks a finished print's
// chamber light with it, so the thing worth testing is it and not a
// body written here to match.
"light" => {
let mode = args.get(3).map(String::as_str).unwrap_or("on");
match mode {
"on" | "off" => {
let state = if mode == "on" { LightState::On } else { LightState::Off };
println!("\n set_light({CHAMBER_LIGHT}, {mode}):");
match bambu.set_light(CHAMBER_LIGHT, state).await {
Ok(()) => println!(" accepted"),
Err(err) => println!(" FAILED: {err}"),
}
// "Accepted" is not "it changed" - a ledctrl reply says
// success as soon as the command parses. `lights_report`
// is the only read-back there is, so poll until the
// printer says the light is what we asked for.
report_light(bambu, mode).await;
}
// Raw, because there is no typed call for it yet - that is
// the point of the probe. Deliberately short: 3 cycles of
// 500ms on / 500ms off, matching what `completion::run`
// drives by hand, so the two are comparable by eye.
"flash" => {
let body = serde_json::json!({
"command": "ledctrl",
"led_node": CHAMBER_LIGHT,
"led_mode": "flashing",
"led_on_time": 500,
"led_off_time": 500,
"loop_times": 3,
"interval_time": 1000,
});
println!("\n sending system.ledctrl flashing (3x 500/500, interval 1000):");
match bambu.request_raw("system", body).await {
Ok(reply) => println!(" reply: {reply}"),
Err(err) => println!(" no usable reply: {err}"),
}
println!(
" watch the printer: 3 blinks means loop_times is cycles; \n\
anything else means the field means something other than that"
);
// And read it back, which says whether `flashing` is a
// firmware *mode* the printer holds and reports, or a
// one-shot that leaves the reported mode untouched.
report_light(bambu, "flashing").await;
}
other => anyhow::bail!("`light` takes on, off or flash - not '{other}'"),
}
return Ok(());
}
// `shape <json>` sends one `print` command verbatim as a correlated
// request and prints the reply. For settling an unconfirmed command
// shape against the hardware - see `BambuPrinter::request_raw`.
@@ -206,6 +294,53 @@ async fn main() -> anyhow::Result<()> {
}
}
// `upload <local> [name]` puts a file on the card and stops there.
// Inert: a file on the SD card does nothing until something is told
// to print it. The only proven transfer before this was 102 bytes,
// and real projects on the card run to 62 MB - a size at which
// buffering, timeouts and the FTPS data connection all start to
// matter in ways a 102-byte write cannot show.
"upload" => {
let Some(local) = args.get(3) else {
anyhow::bail!("`upload` needs a local file path");
};
let data = std::fs::read(local)?;
let name = args
.get(4)
.cloned()
.unwrap_or_else(|| format!("continuum-probe-{}", file_stem(local)));
println!("\n uploading {} bytes as {name} ...", data.len());
let started = std::time::Instant::now();
match bambu.upload_file(&name, data.clone()).await {
Ok(written) => {
let elapsed = started.elapsed();
println!(" printer accepted {written} bytes in {elapsed:?}");
if written == data.len() as u64 {
let rate = data.len() as f64 / elapsed.as_secs_f64() / 1_048_576.0;
println!(" byte count matches exactly ({rate:.1} MiB/s)");
} else {
println!(" MISMATCH: sent {}, printer took {written}", data.len());
}
}
Err(err) => println!(" upload FAILED: {err}"),
}
return Ok(());
}
// `delete <path>` removes one file. Named in full on the command
// line every time - there is no pattern form on purpose.
"delete" => {
let Some(path) = args.get(3) else {
anyhow::bail!("`delete` needs the exact path of a file on the card");
};
println!("\n deleting {path} ...");
match bambu.delete_file(path).await {
Ok(()) => println!(" gone"),
Err(err) => println!(" delete FAILED: {err}"),
}
return Ok(());
}
// `fetch <path> <dest>` copies one file off the card. Read-only.
"fetch" => {
let (Some(path), Some(dest)) = (args.get(3), args.get(4)) else {
@@ -227,6 +362,86 @@ async fn main() -> anyhow::Result<()> {
Ok(())
}
/// The file name without its directory, for naming an upload after its
/// source. Not `Path::file_stem`, which would strip only the last extension
/// and turn `tray.stl.gcode.3mf` into something that is no longer a `.3mf`.
fn file_stem(path: &str) -> String {
path.rsplit('/').next().unwrap_or(path).to_string()
}
/// Runs `completion::celebrate` - the actual ten-second blink a finished print
/// triggers - against a real printer. The question it answers is a rate one:
/// `celebrate` sends twenty `ledctrl` commands half a second apart, and a
/// printer is entitled to refuse that. It stops at the first failure, so if
/// the rate is too high this prints one warning and ends dark.
async fn blink_probe(target: &str) -> anyhow::Result<()> {
use std::sync::Arc;
use tokio::sync::Mutex;
let mut printers = fleet::load(std::path::Path::new("printers.toml"))?;
{
let printer = printers
.iter_mut()
.find(|p| p.base().id == target)
.ok_or_else(|| anyhow::anyhow!("no printer with id '{target}' in printers.toml"))?;
let PrinterHandle::Bambu(bambu) = printer else {
anyhow::bail!("'{target}' is not a Bambu printer");
};
println!("=== {} / step: blink ===", bambu.display_name());
match tokio::time::timeout(CONNECT_TIMEOUT, bambu.connect()).await {
Ok(Ok(())) => {}
Ok(Err(err)) => anyhow::bail!("connect failed: {err}"),
Err(_) => anyhow::bail!("connect timed out - printer off or unreachable?"),
}
}
println!("\n running completion::celebrate for {BLINK_FOR_DISPLAY} - watch the printer");
let fleet: continuum_proxy::uplink::SharedFleet = Arc::new(Mutex::new(printers));
let started = std::time::Instant::now();
continuum_proxy::completion::celebrate(fleet.clone(), target.to_string()).await;
println!(" returned after {:?}", started.elapsed());
// It is specified to end dark, which is the part worth checking: a blink
// that leaves the light on looks like a printer that is still busy.
let fleet = fleet.lock().await;
if let Some(PrinterHandle::Bambu(bambu)) = fleet.iter().find(|p| p.base().id == target) {
report_light(bambu, "off").await;
}
Ok(())
}
/// Polls `lights_report` until the chamber light reads `want`, printing every
/// change with the time it took. Gives up rather than hanging: a light that
/// never reports what was asked for is the result, not a reason to wait.
async fn report_light(bambu: &continuum_proxy::printer::BambuPrinter, want: &str) {
let started = std::time::Instant::now();
let mut last = String::new();
while started.elapsed() < LIGHT_READBACK {
let mode = bambu
.print_status()
.await
.and_then(|r| r.lights_report)
.and_then(|lights| {
lights
.into_iter()
.find(|l| l.node.as_deref() == Some(CHAMBER_LIGHT))
.and_then(|l| l.mode)
});
let mode = mode.unwrap_or_else(|| "<not reported>".into());
if mode != last {
println!(" lights_report after {:?}: {CHAMBER_LIGHT} = {mode}", started.elapsed());
last = mode.clone();
}
if mode == want {
println!(" confirmed: the printer reports '{want}', not just that it accepted it");
return;
}
bambu.pushall().await.ok();
tokio::time::sleep(Duration::from_millis(1500)).await;
}
println!(" gave up after {LIGHT_READBACK:?}: last reported '{last}', asked for '{want}'");
}
async fn wait_for_state(bambu: &continuum_proxy::printer::BambuPrinter) -> anyhow::Result<String> {
let deadline = tokio::time::Instant::now() + STATUS_TIMEOUT;
loop {