1use std::process::ExitCode;
6use std::time::{Duration, Instant};
7
8use kdi::{Acquisition, Cap, Device, Stream};
9
10const M: u8 = 42;
14const D: u8 = 25;
15
16const LANES: u32 = 1;
20
21type Sample = (u64, u32, u32);
25
26fn drain(
27 dev: &mut Device,
28 s: Stream,
29 want: usize,
30 budget: Duration,
31) -> Result<(Vec<Sample>, u64), String> {
32 let mut rd = dev
33 .start(
34 s,
35 &Acquisition {
36 lanes: LANES,
37 burst: Some(want as u16),
38 },
39 )
40 .map_err(|e| format!("start: {e}"))?;
41 let mut out = Vec::new();
42 let mut lost = 0u64;
43 let t0 = Instant::now();
44 while out.len() < want && t0.elapsed() < budget {
45 match rd.next(Duration::from_millis(200)) {
46 Ok(Some(r)) => {
49 if !out.is_empty() {
50 lost += r.lost_before();
51 }
52 let (n, d) = r.blocks().next().map(|b| b.cadence()).unwrap_or((0, 1));
53 out.push((r.timestamp(), n, u32::from(d)))
54 }
55 Ok(None) => {}
56 Err(e) => return Err(format!("read: {e}")),
57 }
58 }
59 let _ = rd.stop();
60 Ok((out, lost))
61}
62
63fn main() -> ExitCode {
64 let serial = std::env::args().nth(1).unwrap_or_default();
65 let mut dev = match Device::open_usb3(&serial, None) {
66 Ok(d) => d,
67 Err(e) => {
68 eprintln!("open failed: {e}");
69 return ExitCode::FAILURE;
70 }
71 };
72
73 println!("gateware_sha 0x{:08x}", dev.gateware_sha());
74 let (maj, min) = dev.kdi();
75 println!("contract {maj}.{min}");
76 if !dev.caps().has(Cap::RateControl) {
77 eprintln!(
78 "FAIL: this build does not advertise rate_control -- wrong bitstream for this check"
79 );
80 return ExitCode::FAILURE;
81 }
82
83 let mut fails = 0;
84 let mut check = |name: &str, ok: bool, detail: String| {
85 println!(
86 " {:<26} {} {detail}",
87 name,
88 if ok { "ok " } else { "FAIL" }
89 );
90 if !ok {
91 fails += 1;
92 }
93 };
94
95 let ready0 = dev.rate_ready().unwrap_or(true);
97 let silent = drain(&mut dev, Stream::Samples, 4, Duration::from_secs(3));
98 match silent {
99 Err(e) if e.contains("rate is not configured") => check(
101 "unconfigured is silent",
102 !ready0,
103 format!("rate_ready={ready0}, start refused: named set_rate"),
104 ),
105 Ok((v, _)) => check(
106 "unconfigured is silent",
107 !ready0 && v.is_empty(),
108 format!("rate_ready={ready0}, {} frames", v.len()),
109 ),
110 Err(e) => check("unconfigured is silent", false, e),
111 }
112
113 if let Err(e) = dev.set_rate(M, D) {
116 check("set_rate", false, format!("{e}"));
117 } else {
118 let ready1 = dev.rate_ready().unwrap_or(false);
119 match drain(&mut dev, Stream::Samples, 24, Duration::from_secs(10)) {
120 Ok((v, lost)) if v.len() >= 8 => {
121 let declared = f64::from(v[0].1) / f64::from(v[0].2.max(1));
122 let mut gaps: Vec<f64> = v.windows(2).map(|w| (w[1].0 - w[0].0) as f64).collect();
123 gaps.sort_by(|a, b| a.partial_cmp(b).unwrap());
124 let med = gaps[gaps.len() / 2];
125 let ratio = med / declared;
126 check("configured is correct", ready1 && lost == 0 && (ratio - 1.0).abs() < 0.02,
127 format!("rate_ready={ready1}, declared {declared:.1}, observed {med:.1}, ratio {ratio:.3}, lost {lost}"));
128 }
129 Ok((v, _)) => check(
130 "configured is correct",
131 false,
132 format!("only {} frames", v.len()),
133 ),
134 Err(e) => check("configured is correct", false, e),
135 }
136 }
137
138 for (m, d, label) in [
142 (7u8, 125u8, "1 kS/s"),
143 (14, 25, "10 kS/s"),
144 (42, 25, "30 kS/s"),
145 ] {
146 if let Err(e) = dev.set_rate(m, d) {
147 check("sweep", false, format!("{label}: set_rate: {e}"));
148 continue;
149 }
150 match drain(&mut dev, Stream::Samples, 16, Duration::from_secs(20)) {
151 Ok((v, lost)) if v.len() >= 8 => {
152 let declared = f64::from(v[0].1) / f64::from(v[0].2.max(1));
153 let mut gaps: Vec<f64> = v.windows(2).map(|w| (w[1].0 - w[0].0) as f64).collect();
154 gaps.sort_by(|a, b| a.partial_cmp(b).unwrap());
155 let med = gaps[gaps.len() / 2];
156 let ratio = med / declared;
157 check(
158 &format!("sweep {label}"),
159 lost == 0 && (ratio - 1.0).abs() < 0.02,
160 format!(
161 "declared {declared:.1}, observed {med:.1}, ratio {ratio:.3}, lost {lost}"
162 ),
163 );
164 }
165 Ok((v, _)) => check(
166 &format!("sweep {label}"),
167 false,
168 format!("only {} frames", v.len()),
169 ),
170 Err(e) => check(&format!("sweep {label}"), false, e),
171 }
172 }
173
174 if let Err(e) = dev.quiesce() {
176 check("quiesce unconfigures", false, format!("{e}"));
177 } else {
178 let ready2 = dev.rate_ready().unwrap_or(true);
179 check(
180 "quiesce unconfigures",
181 !ready2,
182 format!("rate_ready={ready2}"),
183 );
184 }
185
186 match drain(&mut dev, Stream::Digital, 8, Duration::from_secs(5)) {
189 Ok((v, _)) if v.len() >= 4 => {
190 let declared = f64::from(v[0].1) / f64::from(v[0].2.max(1));
191 let mut gaps: Vec<f64> = v.windows(2).map(|w| (w[1].0 - w[0].0) as f64).collect();
192 gaps.sort_by(|a, b| a.partial_cmp(b).unwrap());
193 let med = gaps[gaps.len() / 2];
194 check(
195 "digital unaffected",
196 (med / declared - 1.0).abs() < 0.05,
197 format!(
198 "{} frames, declared {declared:.1}, observed {med:.1}",
199 v.len()
200 ),
201 );
202 }
203 Ok((v, _)) => check(
204 "digital unaffected",
205 false,
206 format!("only {} frames", v.len()),
207 ),
208 Err(e) => check("digital unaffected", false, e),
209 }
210
211 let _ = dev.quiesce();
212 println!("\nRESULT: {}", if fails == 0 { "PASS" } else { "FAIL" });
213 if fails == 0 {
214 ExitCode::SUCCESS
215 } else {
216 ExitCode::FAILURE
217 }
218}