Add FEC base

README.md

@@ -1,8 +1,3 @@
-# Status
-This repository is in maintenance mode! Garmin has signaled the end of the ANT/ANT+ ecosystem, therefore I will not be adding any new features, feel free to send PRs and I will review and integrate.
-
-see `development` branch for latest version.
-
 # ant-rs
 A general purpose ANT* crate for rust
 

ant/Cargo.toml

@@ -21,12 +21,9 @@ ant-derive = { path = "../ant-derive", version = "0.1" }
 embedded-hal = "1.0"
 embedded-hal-nb = "1.0"
 nb = "1.1"
-rusb = {version = "0.9", optional = true}
+rusb = {version = "=0.9.3", optional = true}
 derive-new = {version = "0.6", default-features = false}
 
-[target.'cfg(target_os = "linux")'.dev-dependencies]
-linux-embedded-hal = "0.4"
-
 [dev-dependencies]
 dialoguer = "0.11"
 inner = "0.1"
@@ -41,4 +38,3 @@ usb_adapter = ["dep:rusb", "usb"]
 
 [[test]]
 name = "serial"
-

ant/examples/linux_usb_discovery.rs

@@ -0,0 +1,87 @@
+use ant::drivers::*;
+use ant::messages::config::{AssignChannel, ChannelId, ChannelPeriod, ChannelRfFrequency, ChannelType, DeviceType, LibConfig, SetNetworkKey, TransmissionType, UnAssignChannel};
+use ant::messages::control::{OpenChannel, OpenRxScanMode, ResetSystem};
+use ant::messages::data::{AcknowledgedData, BroadcastData};
+use rusb::{Device, DeviceList};
+
+use dialoguer::Select;
+
+fn main() {
+    let mut devices: Vec<Device<_>> = DeviceList::new()
+        .expect("Unable to lookup usb devices")
+        .iter()
+        .filter(|x| is_ant_usb_device_from_device(x))
+        .collect();
+
+    if devices.is_empty() {
+        panic!("No devices found");
+    }
+
+    let device = if devices.len() == 1 {
+        devices.remove(0)
+    } else {
+        let selection = Select::new()
+            .with_prompt("Multiple devices found, please select a radio to use.")
+            .items(
+                &devices
+                    .iter()
+                    .map(|x| x.device_descriptor().unwrap())
+                    .map(|x| format!("{:04x}:{:04x}", x.vendor_id(), x.product_id()))
+                    .collect::<Vec<String>>(),
+            )
+            .interact()
+            .expect("Dialogue error");
+        devices.remove(selection)
+    };
+
+    let mut driver = UsbDriver::new(device).unwrap();
+    let assign = AssignChannel::new(0, ChannelType::BidirectionalSlave, 0, None);
+    let key = SetNetworkKey::new(0, [0xB9, 0xA5, 0x21, 0xFB, 0xBD, 0x72, 0xC3, 0x45]);
+    // let key = SetNetworkKey::new(0, [0, 0, 0, 0, 0, 0, 0, 0]);
+    let rf = ChannelRfFrequency::new(0, 57);
+    let id = ChannelId::new(
+        0,
+        0,
+        // DeviceType::new(17.into(), true),
+        DeviceType::new_wildcard(),
+        TransmissionType::new_wildcard(),
+    );
+    let period = ChannelPeriod::new(0, 8192);
+    let libconfig = LibConfig::new(true, true, true);
+    driver
+        .send_message(&ResetSystem::new())
+        .expect("Failed to reset device");
+    driver.send_message(&key).expect("Message failed");
+    driver.send_message(&assign).expect("Message failed");
+    driver.send_message(&id).expect("Message failed");
+    driver.send_message(&period).expect("Message failed");
+    driver.send_message(&rf).expect("Message failed");
+    driver.send_message(&libconfig).expect("Message failed");
+    driver
+        .send_message(&OpenRxScanMode::new(Some(false)))
+        .expect("Message failed");
+
+    loop {
+        match driver.get_message() {
+            Ok(None) => (),
+            Ok(Some(msg)) => {
+                match &msg.message {
+                    ant::messages::RxMessage::ChannelEvent(x) => println!("{:#?}", x.payload.message_code),
+                    ant::messages::RxMessage::BroadcastData(x) => {
+                        println!(
+                            "Type: {}, Device number: {}, pairing bit: {}",
+                            x.extended_info.unwrap().channel_id_output.unwrap().device_type.device_type_id,
+                            x.extended_info.unwrap().channel_id_output.unwrap().device_number,
+                            x.extended_info.unwrap().channel_id_output.unwrap().device_type.pairing_request
+                        );
+                        if x.extended_info.unwrap().channel_id_output.unwrap().device_type.device_type_id != 17.into() {
+                            continue;
+                        }
+                    }
+                    _ => println!("{:#?}", msg),
+                }
+            },
+            msg => println!("{:#?}", msg),
+        }
+    }
+}

ant/examples/linux_usb_fec_display.rs

@@ -0,0 +1,145 @@
+use std::time::{Duration, Instant};
+
+use ant::channel::{RxError, RxHandler, TxError, TxHandler};
+use ant::drivers::{is_ant_usb_device_from_device, UsbDriver};
+use ant::messages::channel::MessageCode;
+use ant::messages::config::SetNetworkKey;
+use ant::messages::RxMessage;
+use ant::plus::profiles::fitness_equipment_controls::{Display, DisplayConfig, Period};
+use ant::router::Router;
+use dialoguer::Select;
+use rusb::{Device, DeviceList};
+
+use thingbuf::mpsc::errors::{TryRecvError, TrySendError};
+use thingbuf::mpsc::{channel, Receiver, Sender};
+
+struct TxSender<T> {
+    sender: Sender<T>,
+}
+
+struct RxReceiver<T> {
+    receiver: Receiver<T>,
+}
+
+impl<T: Default + Clone> TxHandler<T> for TxSender<T> {
+    fn try_send(&self, msg: T) -> Result<(), TxError> {
+        match self.sender.try_send(msg) {
+            Ok(_) => Ok(()),
+            Err(TrySendError::Full(_)) => Err(TxError::Full),
+            Err(TrySendError::Closed(_)) => Err(TxError::Closed),
+            Err(_) => Err(TxError::UnknownError),
+        }
+    }
+}
+
+impl<T: Default + Clone> RxHandler<T> for RxReceiver<T> {
+    fn try_recv(&self) -> Result<T, RxError> {
+        match self.receiver.try_recv() {
+            Ok(e) => Ok(e),
+            Err(TryRecvError::Empty) => Err(RxError::Empty),
+            Err(TryRecvError::Closed) => Err(RxError::Closed),
+            Err(_) => Err(RxError::UnknownError),
+        }
+    }
+}
+
+fn main() -> std::io::Result<()> {
+    let mut devices: Vec<Device<_>> = DeviceList::new()
+        .expect("Unable to lookup usb devices")
+        .iter()
+        .filter(|x| is_ant_usb_device_from_device(x))
+        .collect();
+
+    if devices.is_empty() {
+        panic!("No devices found");
+    }
+
+    let device = if devices.len() == 1 {
+        devices.remove(0)
+    } else {
+        let selection = Select::new()
+            .with_prompt("Multiple devices found, please select a radio to use.")
+            .items(
+                &devices
+                    .iter()
+                    .map(|x| x.device_descriptor().unwrap())
+                    .map(|x| format!("{:04x}:{:04x}", x.vendor_id(), x.product_id()))
+                    .collect::<Vec<String>>(),
+            )
+            .interact()
+            .expect("Selection failed");
+        devices.remove(selection)
+    };
+
+    let driver = UsbDriver::new(device).unwrap();
+
+    let (channel_tx, router_rx) = channel(8);
+    let (router_tx, channel_rx) = channel(8);
+
+    let mut router = Router::new(
+        driver,
+        RxReceiver {
+            receiver: router_rx,
+        },
+    )
+    .unwrap();
+    let snk = SetNetworkKey::new(0, [0xB9, 0xA5, 0x21, 0xFB, 0xBD, 0x72, 0xC3, 0x45]);
+    router.send(&snk).expect("failed to set network key");
+    let chan = router
+        .add_channel(TxSender { sender: router_tx })
+        .expect("Add channel failed");
+    let config = DisplayConfig {
+        device_number: 0,
+        device_number_extension: 0.into(),
+        channel: chan,
+        period: Period::FourHz,
+        ant_plus_key_index: 0,
+    };
+    let mut tacx = Display::new(
+        config,
+        TxSender { sender: channel_tx },
+        RxReceiver { receiver: channel_rx },
+    );
+    tacx.set_rx_message_callback(Some(|msg| {
+        match msg.message {
+            RxMessage::ChannelEvent(event) => match event.payload.message_code {
+                MessageCode::EventTransferTxCompleted => println!("Transfer TX completed"),
+                MessageCode::EventTransferTxFailed => println!("Transfer TX failed"),
+                _ => {}
+            },
+            _ => {}
+        }
+    }));
+
+    tacx.open();
+
+    let mut last_send_time = Instant::now();
+    let mut resistance_multiplier = 2;
+    let mut has_set_init_values = false;
+
+    loop {
+        router.process().unwrap();
+        tacx.process().unwrap();
+
+        // Every 5 seconds, increase the target power by 50 watts
+        if last_send_time.elapsed() >= Duration::from_secs(5) {
+            if !has_set_init_values {
+                tacx.set_user_configuration(70, 0, 12, 68, 0).unwrap();
+                // tacx.set_basic_resistance(20).unwrap();
+                // tacx.set_track_resistance(0, 0.002).unwrap();
+                // tacx.set_wind_resistance(0).unwrap();
+                has_set_init_values = true;
+            }
+
+            let target_power = 50 * resistance_multiplier;
+            println!("Setting power target to {} watts", target_power);
+
+            if let Err(_) = tacx.set_power_target(target_power) {
+                println!("Failed to send power target");
+            }
+
+            resistance_multiplier += 1;
+            last_send_time = Instant::now();
+        }
+    }
+}