use crate::error::CalError;
use crate::project::CalibrationProject;
use std::fmt;
pub trait XcpTransport {
fn read(&mut self, addr: u32, len: u8) -> Result<Vec<u8>, CalError>;
fn write(&mut self, addr: u32, data: &[u8]) -> Result<(), CalError>;
fn set_page(&mut self, _page: u32) -> Result<(), CalError> {
Ok(())
}
fn as_any(&self) -> Option<&dyn std::any::Any> {
None
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct SnapshotValue {
pub raw: u64,
pub physical: f64,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SnapshotEntry {
pub module: String,
pub name: String,
pub elements: Vec<SnapshotValue>,
}
impl SnapshotEntry {
#[must_use]
pub fn physical(&self, index: usize) -> Option<f64> {
self.elements.get(index).map(|v| v.physical)
}
#[must_use]
pub fn element_name(&self, index: usize) -> String {
element_name(&self.name, self.elements.len(), index)
}
}
impl fmt::Display for SnapshotEntry {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
" {}.{} ({} element{})",
self.module,
self.name,
self.elements.len(),
if self.elements.len() == 1 { "" } else { "s" }
)?;
for (index, value) in self.elements.iter().enumerate() {
write!(
f,
"\n [{index}] raw 0x{:X} physical {:.6}",
value.raw, value.physical
)?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Snapshot {
pub page: u32,
pub entries: Vec<SnapshotEntry>,
}
impl Snapshot {
#[must_use]
pub fn empty(page: u32) -> Self {
Self {
page,
entries: Vec::new(),
}
}
#[must_use]
pub fn entry(&self, module: &str, name: &str) -> Option<&SnapshotEntry> {
self.entries
.iter()
.find(|e| e.module == module && e.name == name)
}
#[must_use]
pub fn find(&self, name: &str) -> Option<&SnapshotEntry> {
self.entries.iter().find(|e| e.name == name)
}
#[must_use]
pub fn physical(&self, name: &str) -> Option<f64> {
self.find(name).and_then(|entry| entry.physical(0))
}
#[must_use]
pub fn element_count(&self) -> usize {
self.entries.iter().map(|e| e.elements.len()).sum()
}
}
impl fmt::Display for Snapshot {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(
f,
"calibration snapshot: page {}, {} characteristic(s), {} element(s)",
self.page,
self.entries.len(),
self.element_count()
)?;
for entry in &self.entries {
writeln!(f, "{entry}")?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct CalibrationDelta {
pub name: String,
pub before: f64,
pub after: f64,
pub delta: f64,
pub within_limits: bool,
}
impl CalibrationDelta {
#[must_use]
pub fn is_new(&self) -> bool {
self.before.is_nan()
}
#[must_use]
pub fn is_unchanged(&self) -> bool {
!self.is_new() && self.delta == 0.0
}
}
impl fmt::Display for CalibrationDelta {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let verdict = if self.within_limits {
"ok"
} else {
"OUT OF LIMITS"
};
if self.is_new() {
write!(
f,
"{:<28} {:>14} {:>14.6} {:>14} {verdict} (new)",
self.name, "-", self.after, "-"
)
} else {
write!(
f,
"{:<28} {:>14.6} {:>14.6} {:>+14.6} {verdict}",
self.name, self.before, self.after, self.delta
)
}
}
}
#[must_use]
pub fn render_deltas(deltas: &[CalibrationDelta]) -> String {
use std::fmt::Write as _;
let mut out = String::new();
let _ = writeln!(
out,
"{:<28} {:>14} {:>14} {:>14} limits",
"parameter", "before", "after", "delta"
);
for delta in deltas {
let _ = writeln!(out, "{delta}");
}
let changed = deltas.iter().filter(|d| !d.is_unchanged()).count();
let out_of_limits = deltas.iter().filter(|d| !d.within_limits).count();
let _ = writeln!(
out,
"-- {changed} changed, {} unchanged, {out_of_limits} out of limits",
deltas.len() - changed
);
out
}
#[must_use]
pub fn diff_snapshots(
before: Option<&Snapshot>,
after: &Snapshot,
project: &CalibrationProject,
) -> Vec<CalibrationDelta> {
let mut deltas = Vec::new();
for entry in &after.entries {
let before_entry = before.and_then(|b| b.entry(&entry.module, &entry.name));
let characteristic = project.characteristic(&entry.module, &entry.name).ok();
for (index, value) in entry.elements.iter().enumerate() {
let before_value = before_entry
.and_then(|b| b.elements.get(index))
.map_or(f64::NAN, |v| v.physical);
let delta = if before_value.is_nan() {
f64::NAN
} else {
value.physical - before_value
};
let within_limits = characteristic.is_none_or(|c| c.within_limits(value.physical));
deltas.push(CalibrationDelta {
name: entry.element_name(index),
before: before_value,
after: value.physical,
delta,
within_limits,
});
}
}
deltas
}
pub struct CalibrationSession<'a> {
project: &'a CalibrationProject,
transport: Box<dyn XcpTransport + 'a>,
page: u32,
resources: xcp_core::ResourceMode,
baseline: Option<Snapshot>,
}
impl<'a> CalibrationSession<'a> {
pub fn connect(
project: &'a CalibrationProject,
transport: Box<dyn XcpTransport + 'a>,
mode: xcp_core::ResourceMode,
) -> Result<Self, CalError> {
if !mode.is_empty() && !mode.cal_page() {
return Err(CalError::Xcp(xcp_core::XcpError::AccessDenied));
}
Ok(Self {
project,
transport,
page: 0,
resources: mode,
baseline: None,
})
}
#[must_use]
pub const fn project(&self) -> &'a CalibrationProject {
self.project
}
#[must_use]
pub fn transport(&self) -> &dyn XcpTransport {
self.transport.as_ref()
}
pub fn transport_mut(&mut self) -> &mut (dyn XcpTransport + 'a) {
self.transport.as_mut()
}
#[must_use]
pub const fn resources(&self) -> xcp_core::ResourceMode {
self.resources
}
#[must_use]
pub const fn cal_page(&self) -> u32 {
self.page
}
pub fn set_cal_page(&mut self, page: u32) -> Result<(), CalError> {
self.transport.set_page(page)?;
self.page = page;
Ok(())
}
#[must_use]
pub fn upload_frames(&self, addr: u32, len: u8) -> Vec<u8> {
xcp_core::upload_with(self.project.deposit_byte_order(), addr, 0, len)
}
#[must_use]
pub fn download_frames(&self, addr: u32, data: &[u8]) -> Vec<u8> {
xcp_core::download_with(self.project.deposit_byte_order(), addr, 0, data)
}
#[must_use]
pub fn set_cal_page_frame(&self, page: u32) -> Vec<u8> {
xcp_core::set_cal_page(self.project.deposit_byte_order(), 0x03, page as u16)
}
pub fn read_characteristic(&mut self, module: &str, name: &str) -> Result<f64, CalError> {
let raws = self.read_characteristic_raw(module, name)?;
match raws.first() {
Some(&raw) => self.project.to_physical(module, name, raw),
None => Err(CalError::Unsupported {
subject: format!("characteristic `{}`", qualified(module, name)),
reason: "the deposit declares no elements".to_string(),
}),
}
}
pub fn read_characteristic_elements(
&mut self,
module: &str,
name: &str,
) -> Result<Vec<f64>, CalError> {
let raws = self.read_characteristic_raw(module, name)?;
let characteristic = self.project.characteristic(module, name)?;
self.project.physical_values(characteristic, &raws)
}
pub fn read_characteristic_raw(
&mut self,
module: &str,
name: &str,
) -> Result<Vec<u64>, CalError> {
let characteristic = self.project.characteristic(module, name)?;
let len = upload_len(characteristic)?;
let data = self.transport.read(characteristic.address, len)?;
self.project.read_raw(characteristic, &data)
}
pub fn write_characteristic(
&mut self,
module: &str,
name: &str,
physical: f64,
) -> Result<(), CalError> {
self.write_characteristic_element(module, name, 0, physical)
}
pub fn write_characteristic_element(
&mut self,
module: &str,
name: &str,
index: usize,
physical: f64,
) -> Result<(), CalError> {
let raw = self.project.to_raw(module, name, physical)?;
self.write_characteristic_raw(module, name, index, raw)?;
let confirm = self.read_characteristic_raw(module, name)?;
let latched = confirm.get(index).copied().unwrap_or(u64::MAX);
if latched != raw {
return Err(CalError::Transport(format!(
"write-back mismatch for `{}.{}` element {index}: wrote 0x{raw:X}, read 0x{latched:X}",
module, name
)));
}
Ok(())
}
pub fn write_characteristic_raw(
&mut self,
module: &str,
name: &str,
index: usize,
raw: u64,
) -> Result<(), CalError> {
let characteristic = self.project.characteristic(module, name)?;
let elements = characteristic.elements.max(1);
if index >= elements {
return Err(CalError::OutOfBounds {
name: qualified(module, name),
value: index as f64,
lower: 0.0,
upper: (elements - 1) as f64,
});
}
let mut raws = if characteristic.elements > 1 {
self.read_characteristic_raw(module, name)?
} else {
vec![0_u64; elements]
};
raws.resize(elements, 0);
if let Some(slot) = raws.get_mut(index) {
*slot = raw;
}
let data = self.project.write_raw(characteristic, &raws)?;
self.transport.write(characteristic.address, &data)
}
pub fn read_measurement(&mut self, module: &str, name: &str) -> Result<f64, CalError> {
let measurement = self.project.measurement(module, name)?;
let len = measurement.size_bytes();
if len == 0 || len > usize::from(u8::MAX) {
return Err(CalError::Unsupported {
subject: format!("measurement `{}.{}`", module, name),
reason: format!("{len}-byte measurement cannot be read in one UPLOAD"),
});
}
#[allow(clippy::cast_possible_truncation)]
let data = self.transport.read(measurement.address, len as u8)?;
let raw = decode_scalar(&data, measurement.is_signed());
let conversion = measurement.conversion.resolved(self.project.tables())?;
Ok(conversion.apply(raw))
}
pub fn snapshot(&mut self, names: &[&str]) -> Result<Snapshot, CalError> {
let mut entries = Vec::with_capacity(names.len());
for name in names {
let (module_name, characteristic) = self.project.locate(name)?;
let module = module_name.to_string();
let raws = self.read_characteristic_raw(module_name, name)?;
entries.push(SnapshotEntry {
module,
name: characteristic.name.clone(),
elements: self.snapshot_values(characteristic, &raws)?,
});
}
Ok(Snapshot {
page: self.page,
entries,
})
}
pub fn snapshot_module(&mut self, module: &str) -> Result<Snapshot, CalError> {
let declared = self.project.module(module)?;
let names: Vec<String> = declared.characteristic_names().map(String::from).collect();
let borrowed: Vec<&str> = names.iter().map(String::as_str).collect();
let mut snapshot = self.snapshot(&borrowed)?;
for entry in &mut snapshot.entries {
entry.module = module.to_string();
}
Ok(snapshot)
}
pub fn restore(&mut self, snapshot: &Snapshot) -> Result<(), CalError> {
self.set_cal_page(snapshot.page)?;
for entry in &snapshot.entries {
let characteristic = self.project.characteristic(&entry.module, &entry.name)?;
let raws: Vec<u64> = entry.elements.iter().map(|v| v.raw).collect();
let data = self.project.write_raw(characteristic, &raws)?;
self.transport.write(characteristic.address, &data)?;
}
Ok(())
}
#[must_use]
pub fn diff(&self, other: &Snapshot) -> Vec<CalibrationDelta> {
diff_snapshots(self.baseline.as_ref(), other, self.project)
}
pub fn set_baseline(&mut self, snapshot: Snapshot) {
self.baseline = Some(snapshot);
}
#[must_use]
pub fn baseline(&self) -> Option<&Snapshot> {
self.baseline.as_ref()
}
pub fn capture_baseline(&mut self) -> Result<(), CalError> {
let modules: Vec<String> = self.project.module_names().map(String::from).collect();
let mut entries = Vec::new();
let page = self.page;
for module in modules {
let mut snapshot = self.snapshot_module(&module)?;
entries.append(&mut snapshot.entries);
}
self.baseline = Some(Snapshot { page, entries });
Ok(())
}
fn snapshot_values(
&self,
characteristic: &crate::model::Characteristic,
raws: &[u64],
) -> Result<Vec<SnapshotValue>, CalError> {
let conversion = self.project.resolved_conversion(characteristic)?;
Ok(raws
.iter()
.map(|&raw| SnapshotValue {
raw,
physical: conversion.apply(characteristic.raw_value(raw)),
})
.collect())
}
}
impl fmt::Debug for CalibrationSession<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CalibrationSession")
.field("page", &self.page)
.field("resources", &self.resources.to_string())
.finish_non_exhaustive()
}
}
fn upload_len(characteristic: &crate::model::Characteristic) -> Result<u8, CalError> {
let size = usize::from(characteristic.deposit_position) + characteristic.size_bytes();
if size == 0 || size > usize::from(u8::MAX) {
return Err(CalError::Unsupported {
subject: format!("characteristic `{}`", characteristic.name),
reason: format!("deposit of {size} bytes cannot be read in one UPLOAD"),
});
}
#[allow(clippy::cast_possible_truncation)]
Ok(size as u8)
}
fn decode_scalar(data: &[u8], is_signed: bool) -> f64 {
let mut value = 0_u64;
for (index, &byte) in data.iter().enumerate() {
value |= u64::from(byte) << (index * 8);
}
let bits = u32::try_from(data.len() * 8).unwrap_or(32);
if is_signed && bits > 0 && bits < 64 && value & (1_u64 << (bits - 1)) != 0 {
#[allow(clippy::cast_possible_wrap)]
let extended = (value | (u64::MAX << bits)) as i64;
extended as f64
} else {
#[allow(clippy::cast_precision_loss)]
{
value as f64
}
}
}
fn element_name(name: &str, elements: usize, index: usize) -> String {
if elements <= 1 {
name.to_string()
} else {
format!("{name}[{index}]")
}
}
fn qualified(module: &str, name: &str) -> String {
format!("{module}.{name}")
}