ParamStore {
accessor(&*guard)
}
+ /// Change a param from inside the app and persist it to FRAM.
+ ///
+ /// Same call shape as the full AppParams writeback (#640), but without the
+ /// host push: the configurator stays stale until that lands. Apps can call
+ /// this now; swapping in the real #640 implementation later is a drop-in.
+ #[allow(dead_code)]
+ pub async fn update(&self, modifier: F)
+ where
+ F: FnOnce(&mut P),
+ {
+ {
+ let mut inner = self.inner.borrow_mut();
+ modifier(&mut inner);
+ }
+ self.save().await;
+ // #640 adds: try_send AppState on APP_PARAM_PUSH_CHANNEL so the host
+ // tracks on-device edits live.
+ }
+
pub async fn param_handler(&self) {
APP_PARAM_SIGNALS[self.layout_id as usize].reset();
loop {
diff --git a/faderpunk/src/tasks/clock.rs b/faderpunk/src/tasks/clock.rs
index 40b0afc85..85a2b906e 100644
--- a/faderpunk/src/tasks/clock.rs
+++ b/faderpunk/src/tasks/clock.rs
@@ -15,7 +15,7 @@ use embassy_sync::{
use embassy_time::{Duration, Instant, Timer};
use heapless::Deque;
use midly::live::SystemRealtime;
-use portable_atomic::{AtomicBool, Ordering};
+use portable_atomic::{AtomicBool, AtomicU64, Ordering};
use libfp::{
utils::bpm_to_clock_duration, AuxJackMode, ClockSrc, GlobalConfig, MidiOut, MidiOutConfig,
@@ -34,7 +34,7 @@ use crate::{
const CLOCK_PUBSUB_SIZE: usize = 16;
// 16 apps + 1 metronome
-const CLOCK_PUBSUB_SUBSCRIBERS: usize = 17;
+const CLOCK_PUBSUB_SUBSCRIBERS: usize = 16;
// Only the gatekeeper publishes to CLOCK_PUBSUB
const CLOCK_PUBSUB_PUBLISHERS: usize = 5;
// Add a slight delay before the very first tick (to offset it to reset)
@@ -46,6 +46,14 @@ const METRONOME_HIGH_MS: u64 = 25;
pub static METRONOME_HIGH: AtomicBool = AtomicBool::new(true);
+/// Current gatekeeper tick, mirrored for readers that only need the count.
+///
+/// A [`CLOCK_PUBSUB`] subscription costs a queue slot and obliges the reader to
+/// keep draining it; anything that only wants "which tick is it" can poll this
+/// instead and never influence the gatekeeper. `u64::MAX` means "not started" —
+/// the first tick after a Start/Reset is 0.
+pub static TICK_COUNTER: AtomicU64 = AtomicU64::new(u64::MAX);
+
type AuxInputs = (
Peri<'static, PIN_1>,
Peri<'static, PIN_2>,
@@ -308,27 +316,46 @@ async fn analog_tick_release(ports: heapless::Vec, trigger_len: u64) {
.await;
}
+/// Scene LED beat flash — polls [`TICK_COUNTER`] only.
+///
+/// Must never subscribe to [`CLOCK_PUBSUB`]: awaiting a timer while holding a
+/// subscriber slot lets the shared queue fill, and a gatekeeper that cannot
+/// publish stops the whole device clock.
#[embassy_executor::task]
async fn metronome() {
- let mut sub = CLOCK_PUBSUB.subscriber().unwrap();
+ let mut last_seen = TICK_COUNTER.load(Ordering::Relaxed);
+ let mut last_beat = u64::MAX;
+ let mut high_left_ms: u16 = 0;
loop {
- match sub.next_message_pure().await {
- ClockEvent::Tick(ticks) => {
- // Fire on the first tick of each quarter note (every 24 ppqn ticks).
- if ticks.is_multiple_of(24) {
- METRONOME_HIGH.store(true, Ordering::Relaxed);
- Timer::after_millis(METRONOME_HIGH_MS).await;
- METRONOME_HIGH.store(false, Ordering::Relaxed);
- }
- }
- ClockEvent::Start | ClockEvent::Reset => {
- METRONOME_HIGH.store(true, Ordering::Relaxed);
- }
- ClockEvent::Stop => {
+ Timer::after_millis(1).await;
+
+ if high_left_ms > 0 {
+ high_left_ms -= 1;
+ if high_left_ms == 0 {
METRONOME_HIGH.store(false, Ordering::Relaxed);
}
}
+
+ let t = TICK_COUNTER.load(Ordering::Relaxed);
+ if t == last_seen {
+ continue;
+ }
+ // Counter reset (Start/Reset stores u64::MAX, then ticks from 0).
+ if t < last_seen {
+ last_beat = u64::MAX;
+ METRONOME_HIGH.store(true, Ordering::Relaxed);
+ high_left_ms = METRONOME_HIGH_MS as u16;
+ }
+ last_seen = t;
+
+ // First tick of each quarter note (every 24 PPQN ticks).
+ let beat = t / 24;
+ if beat != last_beat {
+ last_beat = beat;
+ METRONOME_HIGH.store(true, Ordering::Relaxed);
+ high_left_ms = METRONOME_HIGH_MS as u16;
+ }
}
}
@@ -400,6 +427,7 @@ async fn run_clock_gatekeeper() {
|| matches!(source, ClockSrc::Atom | ClockSrc::Meteor | ClockSrc::Cube)
{
tick_counter = tick_counter.wrapping_add(1);
+ TICK_COUNTER.store(tick_counter, Ordering::Relaxed);
clock_publisher
.publish(ClockEvent::Tick(tick_counter))
.await;
@@ -423,6 +451,7 @@ async fn run_clock_gatekeeper() {
// (Re-)start the clock. Full phase reset
ClockInEvent::Start(_) => {
tick_counter = u64::MAX;
+ TICK_COUNTER.store(u64::MAX, Ordering::Relaxed);
is_running = true;
clock_publisher.publish(ClockEvent::Reset).await;
clock_publisher.publish(ClockEvent::Start).await;
@@ -439,6 +468,7 @@ async fn run_clock_gatekeeper() {
// Reset the phase without affecting the run state
ClockInEvent::Reset(_) => {
tick_counter = u64::MAX;
+ TICK_COUNTER.store(u64::MAX, Ordering::Relaxed);
clock_publisher.publish(ClockEvent::Reset).await;
analog_tick_counters = [0; 3];
send_analog_reset(&spawner, &config).await;
diff --git a/gen-bindings/Cargo.lock b/gen-bindings/Cargo.lock
index 768a4dcb2..ea65738aa 100644
--- a/gen-bindings/Cargo.lock
+++ b/gen-bindings/Cargo.lock
@@ -324,7 +324,7 @@ checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
[[package]]
name = "libfp"
-version = "0.10.5"
+version = "0.10.6-beta.0"
dependencies = [
"embassy-time",
"enum-ordinalize",
diff --git a/gen-bindings/src/catalog.rs b/gen-bindings/src/catalog.rs
index b99ccb833..049d63d44 100644
--- a/gen-bindings/src/catalog.rs
+++ b/gen-bindings/src/catalog.rs
@@ -10,14 +10,15 @@
//! `const fn` builder chain (`Config::new(...).add_param(...)...`), so
//! syntactic extraction is sufficient.
+use std::collections::HashMap;
use std::fmt::Write as _;
use std::fs;
use std::path::Path;
use syn::punctuated::Punctuated;
use syn::{
- Expr, ExprArray, ExprCall, ExprLit, ExprMethodCall, ExprPath, ExprReference, ExprStruct, Ident,
- Item, Lit, LitInt, Member, Token,
+ Expr, ExprArray, ExprCall, ExprLit, ExprMethodCall, ExprPath, ExprReference, ExprStruct,
+ ExprUnary, Ident, Item, Lit, LitInt, Member, Token, UnOp,
};
struct AppEntry {
@@ -150,19 +151,76 @@ fn unwrap_reference(expr: &Expr) -> &Expr {
/// enum paths become arrays of `{ tag: "Variant" }`, and `&["str", ...]`
/// arrays of string literals (only used by `Param::Enum.variants`) stay as
/// plain string arrays.
-fn convert_field_value(expr: &Expr) -> TsValue {
+fn convert_field_value(expr: &Expr, consts: &ConstMap) -> TsValue {
match expr {
Expr::Lit(ExprLit { lit, .. }) => convert_lit(lit),
Expr::Path(_) => {
let name = path_last_segment(expr).expect("path expr must have a segment");
- TsValue::tag(&name)
+ // A bare path is an enum variant unless the app declared it as an
+ // integer const (`max: STRUM_MAX_MS`), in which case it is a bound.
+ match consts.get(&name) {
+ Some(v) => v.clone(),
+ None => TsValue::tag(&name),
+ }
}
+ // `STRUM_MAX_MS as i32` — the cast only satisfies Rust's typing.
+ Expr::Cast(cast) => convert_field_value(&cast.expr, consts),
+ // A signed bound (`min: -100`) is a negation around a positive
+ // literal, since Rust has no negative literal token.
+ Expr::Unary(ExprUnary {
+ op: UnOp::Neg(_),
+ expr,
+ ..
+ }) => match convert_field_value(expr, consts) {
+ TsValue::Num(n) => TsValue::Num(format!("-{n}")),
+ _ => panic!("unary minus applied to a non-numeric param value"),
+ },
Expr::Array(ExprArray { elems, .. }) => convert_array(elems),
- Expr::Reference(_) => convert_field_value(unwrap_reference(expr)),
+ Expr::Reference(_) => convert_field_value(unwrap_reference(expr), consts),
other => panic!("unsupported field-value expression: {:?}", other),
}
}
+/// Top-level consts an app's `CONFIG` may reference instead of inlining a
+/// value: integer bounds (`max: STRUM_MAX_MS`) and string arrays
+/// (`variants: GENRE_NAMES`).
+///
+/// Names are not unique across modules — Bassment and Chord Vamp both declare
+/// their own `SCALE_NAMES` — so callers resolve module-locally first and only
+/// fall back to the shared map for consts defined in another app module.
+type ConstMap = HashMap;
+
+fn collect_consts(file: &syn::File, out: &mut ConstMap) {
+ for item in &file.items {
+ let Item::Const(item_const) = item else {
+ continue;
+ };
+ let value = match unwrap_reference(item_const.expr.as_ref()) {
+ Expr::Lit(ExprLit {
+ lit: Lit::Int(i), ..
+ }) => match i.base10_parse::() {
+ Ok(v) => TsValue::Num(v.to_string()),
+ Err(_) => continue,
+ },
+ Expr::Array(ExprArray { elems, .. })
+ if elems.iter().all(|e| {
+ matches!(
+ unwrap_reference(e),
+ Expr::Lit(ExprLit {
+ lit: Lit::Str(_),
+ ..
+ })
+ )
+ }) =>
+ {
+ convert_array(elems)
+ }
+ _ => continue,
+ };
+ out.insert(item_const.ident.to_string(), value);
+ }
+}
+
fn convert_array(elems: &Punctuated) -> TsValue {
TsValue::Array(elems.iter().map(convert_array_elem).collect())
}
@@ -191,7 +249,7 @@ fn convert_lit(lit: &Lit) -> TsValue {
/// Converts a `Param::Variant { .. }` or `Param::Variant` expression (one
/// `.add_param(...)` argument) into a `TsValue` matching the postcard-bindgen
/// TS shape for `Param`.
-fn convert_param(expr: &Expr) -> TsValue {
+fn convert_param(expr: &Expr, consts: &ConstMap) -> TsValue {
match expr {
Expr::Path(_) => {
let name = path_last_segment(expr).expect("Param path must have a segment");
@@ -209,7 +267,7 @@ fn convert_param(expr: &Expr) -> TsValue {
Member::Named(ident) => ident.to_string(),
Member::Unnamed(idx) => idx.index.to_string(),
};
- rendered_fields.push((key, convert_field_value(&field.expr)));
+ rendered_fields.push((key, convert_field_value(&field.expr, consts)));
}
TsValue::tag_with_value(&name, rendered_fields)
}
@@ -227,7 +285,7 @@ struct ExtractedConfig {
/// Walks a `Config::new(name, description, color, icon).add_param(..).add_param(..)`
/// method-call chain and extracts the four base args plus each param.
-fn extract_config(expr: &Expr, context: &str) -> ExtractedConfig {
+fn extract_config(expr: &Expr, consts: &ConstMap, context: &str) -> ExtractedConfig {
fn walk(expr: &Expr, params: &mut Vec) -> (Expr, Expr, Expr, Expr) {
match expr {
Expr::MethodCall(ExprMethodCall {
@@ -281,7 +339,10 @@ fn extract_config(expr: &Expr, context: &str) -> ExtractedConfig {
"non-ASCII app name/description in {context} (must be ASCII — see \
libfp::Config's ASCII assert)"
);
- let params: Vec = param_exprs.iter().map(convert_param).collect();
+ let params: Vec = param_exprs
+ .iter()
+ .map(|e| convert_param(e, consts))
+ .collect();
for param in ¶ms {
assert_ascii_strings(param, context);
}
@@ -390,6 +451,26 @@ pub fn generate(faderpunk_src: &Path, out_file: &Path) {
let apps_dir = faderpunk_src.join("apps");
let registered = find_registered_apps(&apps_dir.join("mod.rs"));
+ // Consts live wherever the author put them (e.g. GENRE_NAMES in
+ // genre_palette.rs), so collect every module up front as a fallback.
+ let mut shared_consts = ConstMap::new();
+ if let Ok(entries) = fs::read_dir(&apps_dir) {
+ let mut paths: Vec<_> = entries
+ .flatten()
+ .map(|e| e.path())
+ .filter(|p| p.extension().is_some_and(|e| e == "rs"))
+ .collect();
+ paths.sort();
+ for path in paths {
+ let Ok(content) = fs::read_to_string(&path) else {
+ continue;
+ };
+ if let Ok(parsed) = syn::parse_file(&content) {
+ collect_consts(&parsed, &mut shared_consts);
+ }
+ }
+ }
+
let mut apps = Vec::new();
for (id, module) in registered {
let file_path = apps_dir.join(format!("{module}.rs"));
@@ -402,7 +483,9 @@ pub fn generate(faderpunk_src: &Path, out_file: &Path) {
.unwrap_or_else(|| panic!("no `pub const CHANNELS` found in {}", file_path.display()));
let config_expr = find_config_static(&parsed)
.unwrap_or_else(|| panic!("no `pub static CONFIG` found in {}", file_path.display()));
- let config = extract_config(&config_expr, &file_path.display().to_string());
+ let mut consts = shared_consts.clone();
+ collect_consts(&parsed, &mut consts);
+ let config = extract_config(&config_expr, &consts, &file_path.display().to_string());
apps.push(AppData {
id,
@@ -448,7 +531,7 @@ mod tests {
variants: &["1/2", "x2 + gate"],
})
};
- let config = extract_config(&expr, "test.rs");
+ let config = extract_config(&expr, &ConstMap::new(), "test.rs");
assert_eq!(config.name, "Clock Divider+");
assert_eq!(config.params.len(), 1);
}
@@ -459,7 +542,7 @@ mod tests {
let expr: Expr = parse_quote! {
Config::new("Arp de Lévy", "Sequencer", Color::Yellow, AppIcon::Fader)
};
- extract_config(&expr, "test.rs");
+ extract_config(&expr, &ConstMap::new(), "test.rs");
}
#[test]
@@ -469,7 +552,7 @@ mod tests {
Config::new("Sequencer", "Sequencer", Color::Yellow, AppIcon::Fader)
.add_param(Param::bool { name: "Activé" })
};
- extract_config(&expr, "test.rs");
+ extract_config(&expr, &ConstMap::new(), "test.rs");
}
#[test]
@@ -482,6 +565,6 @@ mod tests {
variants: &["Normal", "Lévy"],
})
};
- extract_config(&expr, "test.rs");
+ extract_config(&expr, &ConstMap::new(), "test.rs");
}
}