use crate::driver::{Config, SerialApi, SerialError};
use crate::frame::DataFrame;
use crate::function::FunctionId as F;
use crate::message::{
setup, ControllerId, ControllerVersion, InitData, RfRegion, SerialApiCapabilities,
};
use crate::port::Port;
use crate::NodeId;
use std::time::Duration;
pub const PROBE_TIMEOUT: Duration = Duration::from_millis(2900);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Series {
S500,
S700,
S800,
}
impl Series {
pub fn from_chip_type(chip: u8) -> Option<Series> {
match chip {
0x05 => Some(Series::S500),
0x07 => Some(Series::S700),
0x08 => Some(Series::S800),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ControllerIdentity {
pub firmware: String,
pub manufacturer_id: u16,
pub product_type: u16,
pub product_id: u16,
pub capabilities: SerialApiCapabilities,
pub library_version: Option<String>,
pub api_version: Option<u8>,
pub chip: Option<(u8, u8)>,
pub series: Option<Series>,
pub home_id: Option<u32>,
pub node_id: Option<NodeId>,
pub primary: Option<bool>,
pub sis: Option<bool>,
pub node_count: Option<usize>,
pub region: Option<RfRegion>,
}
impl ControllerIdentity {
pub fn known_name(&self) -> Option<&'static str> {
known_name(self.manufacturer_id, self.product_type, self.product_id)
}
}
pub fn known_name(manufacturer: u16, product_type: u16, product_id: u16) -> Option<&'static str> {
Some(match (manufacturer, product_type, product_id) {
(0x0000, 0x0004, 0x0004) => {
"Silicon Labs 800 series controller (e.g. Zooz ZST39 LR, HomeSeer SmartStick G8)"
}
(0x0000, 0x0004, 0x0001) | (0x0000, 0x0004, 0x0002) => "Silicon Labs 700 series controller",
(0x0086, 0x0001, 0x005a) => "Aeotec Z-Stick Gen5",
(0x0086, 0x0001, 0x005d) => "Aeotec Z-Stick 7",
(0x0115, 0x0400, 0x0001) => "Z-Wave.Me UZB",
_ => return None,
})
}
const STEP: Duration = Duration::from_millis(400);
async fn details(api: &SerialApi, id: &mut ControllerIdentity) {
let c = &id.capabilities;
if c.supports(F::GET_CONTROLLER_VERSION) {
if let Ok(r) = api
.request(DataFrame::request(F::GET_CONTROLLER_VERSION, vec![]), STEP)
.await
{
id.library_version = ControllerVersion::parse(&r.payload).ok().map(|v| v.version);
}
}
if c.supports(F::GET_CONTROLLER_ID) {
if let Ok(r) = api
.request(DataFrame::request(F::GET_CONTROLLER_ID, vec![]), STEP)
.await
{
if let Ok(cid) = ControllerId::parse(&r.payload, 1) {
id.home_id = Some(cid.home_id);
id.node_id = Some(cid.node_id);
}
}
}
if c.supports(F::GET_INIT_DATA) {
if let Ok(r) = api
.request(DataFrame::request(F::GET_INIT_DATA, vec![]), STEP)
.await
{
if let Ok(init) = InitData::parse(&r.payload) {
id.api_version = Some(init.api_version);
id.chip = init.chip_type.zip(init.chip_version);
id.series = init.chip_type.and_then(Series::from_chip_type);
id.sis = Some(init.is_sis());
let own = id.node_id.unwrap_or(1);
id.node_count = Some(init.nodes.iter().filter(|&&n| n != own).count());
}
}
}
if c.supports(F::GET_CONTROLLER_CAPABILITIES) {
if let Ok(r) = api
.request(
DataFrame::request(F::GET_CONTROLLER_CAPABILITIES, vec![]),
STEP,
)
.await
{
id.primary = r.payload.first().map(|b| b & 0x01 == 0);
}
}
if c.supports(F::SERIAL_API_SETUP) {
if let Ok(r) = api
.request(
DataFrame::request(F::SERIAL_API_SETUP, vec![setup::GET_RF_REGION]),
STEP,
)
.await
{
if r.payload.first() == Some(&setup::GET_RF_REGION) {
id.region = r
.payload
.get(1)
.map(|&b| RfRegion::from_u8(b))
.filter(|r| !matches!(r, RfRegion::Other(_)));
}
}
}
}
pub async fn identify(api: &SerialApi) -> Option<ControllerIdentity> {
let resp = api
.request(
DataFrame::request(F::GET_SERIAL_API_CAPABILITIES, vec![]),
Duration::from_millis(800),
)
.await
.ok()?;
let c = SerialApiCapabilities::parse(&resp.payload).ok()?;
let mut id = ControllerIdentity {
firmware: format!("{}.{}", c.firmware_major, c.firmware_minor),
manufacturer_id: c.manufacturer_id,
product_type: c.product_type,
product_id: c.product_id,
capabilities: c,
library_version: None,
api_version: None,
chip: None,
series: None,
home_id: None,
node_id: None,
primary: None,
sis: None,
node_count: None,
region: None,
};
let _ = tokio::time::timeout(Duration::from_millis(2000), details(api, &mut id)).await;
Some(id)
}
pub async fn probe_port<P: Port>(port: P) -> Result<Option<ControllerIdentity>, SerialError> {
let config = Config {
max_attempts: 1,
ack_timeout: Duration::from_millis(500),
..Config::default()
};
let (api, _unsolicited) = SerialApi::start(port, config);
let run = async {
let frame = DataFrame::request(F::GET_SERIAL_API_CAPABILITIES, vec![]);
let resp = match api.request(frame, Duration::from_millis(800)).await {
Ok(r) => r,
Err(
SerialError::NoAck(_) | SerialError::Rejected(_) | SerialError::ResponseTimeout,
) => return Ok(None),
Err(e) => return Err(e),
};
let Ok(c) = SerialApiCapabilities::parse(&resp.payload) else {
return Ok(None);
};
let mut id = ControllerIdentity {
firmware: format!("{}.{}", c.firmware_major, c.firmware_minor),
manufacturer_id: c.manufacturer_id,
product_type: c.product_type,
product_id: c.product_id,
capabilities: c,
library_version: None,
api_version: None,
chip: None,
series: None,
home_id: None,
node_id: None,
primary: None,
sis: None,
node_count: None,
region: None,
};
let _ = tokio::time::timeout(
PROBE_TIMEOUT.saturating_sub(Duration::from_millis(1400)),
details(&api, &mut id),
)
.await;
Ok(Some(id))
};
let r = tokio::time::timeout(PROBE_TIMEOUT, run)
.await
.unwrap_or(Ok(None));
drop(api);
tokio::task::yield_now().await;
r
}
pub async fn probe(path: &str) -> Result<Option<ControllerIdentity>, SerialError> {
let port = crate::port::open(path)
.await
.map_err(|e| SerialError::Closed(e.to_string()))?;
probe_port(port).await
}
pub fn probe_blocking(path: &str) -> Result<Option<ControllerIdentity>, SerialError> {
let rt = tokio::runtime::Builder::new_current_thread()
.enable_io()
.enable_time()
.build()
.map_err(|e| SerialError::Closed(e.to_string()))?;
let r = rt.block_on(probe(path));
drop(rt);
r
}