uwbd/src/bin/uwbd_client.rs - third_party/platform2 - Git at Google


            
            // Copyright 2022 The ChromiumOS Authors

            
            // Use of this source code is governed by a BSD-style license that can be

            
            // found in the LICENSE file.


            //! Provide a simple uwbd client, used to verify the uwbd service end-to-end.


            use std::error::Error;

            
            use std::time::Duration;


            use clap::{arg, Command, ArgGroup};

            
            use dbus::blocking::{Connection, Proxy};

            
            use protobuf::{Message, RepeatedField};

            
            use uwb_core::proto::bindings::{

            
                EnableResponse, InitSessionRequest, SessionType, FiraAppConfigParams, DeviceType,

            
                RangingRoundUsage, StsConfig, MultiNodeMode, UwbChannel, MacFcsType, RangingRoundControl,

            
                AoaResultRequest, RangeDataNtfConfig, DeviceRole, RframeConfig, PsduDataRate, RangingTimeStruct,

            
                TxAdaptivePayloadPower, PrfMode, ScheduledMode, KeyRotation, MacAddressMode, HoppingMode,

            
                ResultReportConfig, BprfPhrDataRate, StsLength, InitSessionResponse, PreambleDuration,

            
                StartRangingRequest, StartRangingResponse, StopRangingRequest, StopRangingResponse,

            
                DeinitSessionRequest, DeinitSessionResponse,

            
            };

            
            use uwb_core::proto::utils::write_to_bytes;


            use uwbd::common::{DBUS_OBJECT_PATH, DBUS_SERVICE_NAME};

            
            use uwbd::dbus_bindings::client::OrgChromiumUwbd;


            // Returns the clap Command that this CLI will use

            
            fn cli() -> Command {

            
                Command::new("uwbd_client")

            
                    .about("CLI connecting to uwbd to start and stop UWB ranging sessions")

            
                    .subcommand_required(true)

            
                    .arg_required_else_help(true)

            
                    .subcommand(

            
                        Command::new("start")

            
                            .about("Enables UWB, initializes and starts a ranging session.")

            
                            .args_conflicts_with_subcommands(true)

            
                            .arg(arg!(-i --initiator "Uses the initiator + controller parameter profile"))

            
                            .arg(arg!(-r --responder "Uses the responder + controlee parameter profile"))

            
                            .group(ArgGroup::new("vers")

            
                                .args(["initiator", "responder"])

            
                                .required(true))

            
                        )

            
                    .subcommand(

            
                        Command::new("stop")

            
                            .about("stops and deinits the default UWB ranging session")

            
                    )

            
            }


            // Returns a FiraAppConfigParams that has been initialized with a default set of parameters.

            
            // The profile specific parameters i.e. Device Type, Device Role, Mac Address and Destination

            
            // Mac Addresses are not set.

            
            fn create_app_config_params() -> FiraAppConfigParams {

            
                let mut app_config_params = FiraAppConfigParams::new();

            
                app_config_params.set_device_type(DeviceType::CONTROLEE);

            
                app_config_params.set_ranging_round_usage(RangingRoundUsage::DS_TWR);

            
                app_config_params.set_sts_config(StsConfig::STATIC);

            
                app_config_params.set_multi_node_mode(MultiNodeMode::UNICAST);

            
                app_config_params.set_channel_number(UwbChannel::CHANNEL_9);


                app_config_params.set_slot_duration_rstu(2400);

            
                app_config_params.set_ranging_interval_ms(200);

            
                app_config_params.set_mac_fcs_type(MacFcsType::CRC_16);


                let mut ranging_round_control = RangingRoundControl::new();

            
                ranging_round_control.set_ranging_result_report_message(true);

            
                ranging_round_control.set_control_message(true);

            
                ranging_round_control.set_measurement_report_message(false);

            
                app_config_params.set_ranging_round_control(ranging_round_control);

            
                app_config_params.set_aoa_result_request(AoaResultRequest::REQ_AOA_RESULTS);

            
                app_config_params.set_range_data_ntf_config(RangeDataNtfConfig::RANGE_DATA_NTF_CONFIG_ENABLE);

            
                app_config_params.set_range_data_ntf_proximity_near_cm(0);

            
                app_config_params.set_range_data_ntf_proximity_far_cm(20000);

            
                app_config_params.set_device_role(DeviceRole::RESPONDER);

            
                app_config_params.set_rframe_config(RframeConfig::SP3);

            
                app_config_params.set_preamble_code_index(9);

            
                app_config_params.set_sfd_id(2);

            
                app_config_params.set_psdu_data_rate(PsduDataRate::RATE_6M_81);

            
                app_config_params.set_preamble_duration(PreambleDuration::T64_SYMBOLS);

            
                app_config_params.set_ranging_time_struct(RangingTimeStruct::BLOCK_BASED_SCHEDULING);

            
                app_config_params.set_slots_per_rr(25);

            
                app_config_params.set_tx_adaptive_payload_power(TxAdaptivePayloadPower::

            
                    TX_ADAPTIVE_PAYLOAD_POWER_DISABLE);

            
                app_config_params.set_responder_slot_index(1);

            
                app_config_params.set_prf_mode(PrfMode::BPRF);

            
                app_config_params.set_scheduled_mode(ScheduledMode::TIME_SCHEDULED_RANGING);

            
                app_config_params.set_key_rotation(KeyRotation::KEY_ROTATION_DISABLE);

            
                app_config_params.set_key_rotation_rate(0);

            
                app_config_params.set_session_priority(70);

            
                app_config_params.set_mac_address_mode(MacAddressMode::MAC_ADDRESS_2_BYTES);

            
                app_config_params.set_vendor_id(vec![0x0,0x0]);

            
                app_config_params.set_static_sts_iv(vec![0x0,0x0,0x0,0x0,0x0,0x0]);

            
                app_config_params.set_number_of_sts_segments(1);

            
                app_config_params.set_max_rr_retry(0);

            
                app_config_params.set_uwb_initiation_time_ms(0);

            
                app_config_params.set_hopping_mode(HoppingMode::HOPPING_MODE_DISABLE);

            
                app_config_params.set_block_stride_length(0);

            
                let mut result_report_config = ResultReportConfig::new();

            
                result_report_config.set_tof(true);

            
                result_report_config.set_aoa_azimuth(false);

            
                result_report_config.set_aoa_elevation(false);

            
                result_report_config.set_aoa_fom(false);

            
                app_config_params.set_result_report_config(result_report_config);

            
                app_config_params.set_in_band_termination_attempt_count(1);

            
                app_config_params.set_sub_session_id(0);

            
                app_config_params.set_bprf_phr_data_rate(BprfPhrDataRate::BPRF_PHR_DATA_RATE_850K);

            
                app_config_params.set_max_number_of_measurements(0);

            
                app_config_params.set_sts_length(StsLength::LENGTH_64);

            
                app_config_params.set_number_of_range_measurements(0); //dropped by HAL

            
                app_config_params.set_number_of_aoa_azimuth_measurements(0); //dropped by HAL

            
                app_config_params.set_number_of_aoa_elevation_measurements(0); //dropped by HAL


                app_config_params

            
            }


            fn main() -> Result<(), Box<dyn Error>> {

            
                let matches = cli().get_matches();


                let session_id = 1;

            
                const TIMEOUT: Duration = Duration::from_millis(5000);


                // Connect to D-Bus and create uwbd proxy.

            
                let dbus_connection = Connection::new_system()?;

            
                let uwbd_proxy = Proxy::new(

            
                    DBUS_SERVICE_NAME,

            
                    DBUS_OBJECT_PATH,

            
                    TIMEOUT,

            
                    &dbus_connection,

            
                );


                match matches.subcommand(){

            
                    Some(("start", sub_matches)) => {

            
                        // Create params

            
                        let mut app_config_params = create_app_config_params();


                        // Set initiator profile in params

            
                        if sub_matches.get_flag("initiator"){

            
                            app_config_params.set_device_type(DeviceType::CONTROLLER);

            
                            app_config_params.set_device_role(DeviceRole::INITIATOR);

            
                            app_config_params.set_device_mac_address(vec![0x08,0x00]);

            
                            let mut dst_mac_addresses: RepeatedField<Vec<u8>> = RepeatedField::new();

            
                            dst_mac_addresses.push(vec![0x04,0x00]);

            
                            app_config_params.set_dst_mac_address(dst_mac_addresses);

            
                            println!("Using initiator profile");

            
                        }

            
                        // Set responder profile in params

            
                        if sub_matches.get_flag("responder"){

            
                            app_config_params.set_device_type(DeviceType::CONTROLEE);

            
                            app_config_params.set_device_role(DeviceRole::RESPONDER);

            
                            app_config_params.set_device_mac_address(vec![0x04,0x00]);

            
                            let mut dst_mac_addresses: RepeatedField<Vec<u8>> = RepeatedField::new();

            
                            dst_mac_addresses.push(vec![0x08,0x00]);

            
                            app_config_params.set_dst_mac_address(dst_mac_addresses);

            
                            println!("Using responder profile");

            
                        }


                        // Enable UwB

            
                        let result_bytes = uwbd_proxy.enable()?;

            
                        let result = EnableResponse::parse_from_bytes(&result_bytes)?;

            
                        println!("Enable() returns: {:?}", result.status);


                        // Initialize the ranging session

            
                        let mut request = InitSessionRequest::new();

            
                        request.set_session_id(session_id);

            
                        request.set_session_type(SessionType::FIRA_RANGING_SESSION);

            
                        request.set_params(app_config_params);

            
                        let request_bytes = write_to_bytes(&request)?;

            
                        let result_bytes = uwbd_proxy.init_session(request_bytes)?;

            
                        let result = InitSessionResponse::parse_from_bytes(&result_bytes)?;

            
                        println!("InitSessionRequest returns: {:?}", result.status);


                        // Start the ranging session

            
                        let mut request = StartRangingRequest::new();

            
                        request.set_session_id(session_id);

            
                        let request_bytes = write_to_bytes(&request)?;

            
                        let result_bytes = uwbd_proxy.start_ranging(request_bytes)?;

            
                        let result = StartRangingResponse::parse_from_bytes(&result_bytes)?;

            
                        println!("StartRangingResponse returns: {:?}", result.status);

            
                    }

            
                    Some(("stop", _)) => {

            
                        // Stop the ranging session

            
                        let mut request = StopRangingRequest::new();

            
                        request.set_session_id(session_id);

            
                        let request_bytes = write_to_bytes(&request)?;

            
                        let result_bytes = uwbd_proxy.stop_ranging(request_bytes)?;

            
                        let result = StopRangingResponse::parse_from_bytes(&result_bytes)?;

            
                        println!("StopRangingResponse returns: {:?}", result.status);


                        // Deinit the ranging session

            
                        let mut request = DeinitSessionRequest::new();

            
                        request.set_session_id(session_id);

            
                        let request_bytes = write_to_bytes(&request)?;

            
                        let result_bytes = uwbd_proxy.stop_ranging(request_bytes)?;

            
                        let result = DeinitSessionResponse::parse_from_bytes(&result_bytes)?;

            
                        println!("DeinitSessionResponse returns: {:?}", result.status);

            
                    }

            
                    _ => unreachable!(),

            
                }


                Ok(())

            
            }
	// Copyright 2022 The ChromiumOS Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//! Provide a simple uwbd client, used to verify the uwbd service end-to-end.

	use std::error::Error;
	use std::time::Duration;

	use clap::{arg, Command, ArgGroup};
	use dbus::blocking::{Connection, Proxy};
	use protobuf::{Message, RepeatedField};
	use uwb_core::proto::bindings::{
	EnableResponse, InitSessionRequest, SessionType, FiraAppConfigParams, DeviceType,
	RangingRoundUsage, StsConfig, MultiNodeMode, UwbChannel, MacFcsType, RangingRoundControl,
	AoaResultRequest, RangeDataNtfConfig, DeviceRole, RframeConfig, PsduDataRate, RangingTimeStruct,
	TxAdaptivePayloadPower, PrfMode, ScheduledMode, KeyRotation, MacAddressMode, HoppingMode,
	ResultReportConfig, BprfPhrDataRate, StsLength, InitSessionResponse, PreambleDuration,
	StartRangingRequest, StartRangingResponse, StopRangingRequest, StopRangingResponse,
	DeinitSessionRequest, DeinitSessionResponse,
	};
	use uwb_core::proto::utils::write_to_bytes;

	use uwbd::common::{DBUS_OBJECT_PATH, DBUS_SERVICE_NAME};
	use uwbd::dbus_bindings::client::OrgChromiumUwbd;

	// Returns the clap Command that this CLI will use
	fn cli() -> Command {
	Command::new("uwbd_client")
	.about("CLI connecting to uwbd to start and stop UWB ranging sessions")
	.subcommand_required(true)
	.arg_required_else_help(true)
	.subcommand(
	Command::new("start")
	.about("Enables UWB, initializes and starts a ranging session.")
	.args_conflicts_with_subcommands(true)
	.arg(arg!(-i --initiator "Uses the initiator + controller parameter profile"))
	.arg(arg!(-r --responder "Uses the responder + controlee parameter profile"))
	.group(ArgGroup::new("vers")
	.args(["initiator", "responder"])
	.required(true))
	)
	.subcommand(
	Command::new("stop")
	.about("stops and deinits the default UWB ranging session")
	)
	}


	// Returns a FiraAppConfigParams that has been initialized with a default set of parameters.
	// The profile specific parameters i.e. Device Type, Device Role, Mac Address and Destination
	// Mac Addresses are not set.
	fn create_app_config_params() -> FiraAppConfigParams {
	let mut app_config_params = FiraAppConfigParams::new();
	app_config_params.set_device_type(DeviceType::CONTROLEE);
	app_config_params.set_ranging_round_usage(RangingRoundUsage::DS_TWR);
	app_config_params.set_sts_config(StsConfig::STATIC);
	app_config_params.set_multi_node_mode(MultiNodeMode::UNICAST);
	app_config_params.set_channel_number(UwbChannel::CHANNEL_9);

	app_config_params.set_slot_duration_rstu(2400);
	app_config_params.set_ranging_interval_ms(200);
	app_config_params.set_mac_fcs_type(MacFcsType::CRC_16);

	let mut ranging_round_control = RangingRoundControl::new();
	ranging_round_control.set_ranging_result_report_message(true);
	ranging_round_control.set_control_message(true);
	ranging_round_control.set_measurement_report_message(false);
	app_config_params.set_ranging_round_control(ranging_round_control);
	app_config_params.set_aoa_result_request(AoaResultRequest::REQ_AOA_RESULTS);
	app_config_params.set_range_data_ntf_config(RangeDataNtfConfig::RANGE_DATA_NTF_CONFIG_ENABLE);
	app_config_params.set_range_data_ntf_proximity_near_cm(0);
	app_config_params.set_range_data_ntf_proximity_far_cm(20000);
	app_config_params.set_device_role(DeviceRole::RESPONDER);
	app_config_params.set_rframe_config(RframeConfig::SP3);
	app_config_params.set_preamble_code_index(9);
	app_config_params.set_sfd_id(2);
	app_config_params.set_psdu_data_rate(PsduDataRate::RATE_6M_81);
	app_config_params.set_preamble_duration(PreambleDuration::T64_SYMBOLS);
	app_config_params.set_ranging_time_struct(RangingTimeStruct::BLOCK_BASED_SCHEDULING);
	app_config_params.set_slots_per_rr(25);
	app_config_params.set_tx_adaptive_payload_power(TxAdaptivePayloadPower::
	TX_ADAPTIVE_PAYLOAD_POWER_DISABLE);
	app_config_params.set_responder_slot_index(1);
	app_config_params.set_prf_mode(PrfMode::BPRF);
	app_config_params.set_scheduled_mode(ScheduledMode::TIME_SCHEDULED_RANGING);
	app_config_params.set_key_rotation(KeyRotation::KEY_ROTATION_DISABLE);
	app_config_params.set_key_rotation_rate(0);
	app_config_params.set_session_priority(70);
	app_config_params.set_mac_address_mode(MacAddressMode::MAC_ADDRESS_2_BYTES);
	app_config_params.set_vendor_id(vec![0x0,0x0]);
	app_config_params.set_static_sts_iv(vec![0x0,0x0,0x0,0x0,0x0,0x0]);
	app_config_params.set_number_of_sts_segments(1);
	app_config_params.set_max_rr_retry(0);
	app_config_params.set_uwb_initiation_time_ms(0);
	app_config_params.set_hopping_mode(HoppingMode::HOPPING_MODE_DISABLE);
	app_config_params.set_block_stride_length(0);
	let mut result_report_config = ResultReportConfig::new();
	result_report_config.set_tof(true);
	result_report_config.set_aoa_azimuth(false);
	result_report_config.set_aoa_elevation(false);
	result_report_config.set_aoa_fom(false);
	app_config_params.set_result_report_config(result_report_config);
	app_config_params.set_in_band_termination_attempt_count(1);
	app_config_params.set_sub_session_id(0);
	app_config_params.set_bprf_phr_data_rate(BprfPhrDataRate::BPRF_PHR_DATA_RATE_850K);
	app_config_params.set_max_number_of_measurements(0);
	app_config_params.set_sts_length(StsLength::LENGTH_64);
	app_config_params.set_number_of_range_measurements(0); //dropped by HAL
	app_config_params.set_number_of_aoa_azimuth_measurements(0); //dropped by HAL
	app_config_params.set_number_of_aoa_elevation_measurements(0); //dropped by HAL

	app_config_params
	}


	fn main() -> Result<(), Box<dyn Error>> {
	let matches = cli().get_matches();

	let session_id = 1;
	const TIMEOUT: Duration = Duration::from_millis(5000);

	// Connect to D-Bus and create uwbd proxy.
	let dbus_connection = Connection::new_system()?;
	let uwbd_proxy = Proxy::new(
	DBUS_SERVICE_NAME,
	DBUS_OBJECT_PATH,
	TIMEOUT,
	&dbus_connection,
	);

	match matches.subcommand(){
	Some(("start", sub_matches)) => {
	// Create params
	let mut app_config_params = create_app_config_params();

	// Set initiator profile in params
	if sub_matches.get_flag("initiator"){
	app_config_params.set_device_type(DeviceType::CONTROLLER);
	app_config_params.set_device_role(DeviceRole::INITIATOR);
	app_config_params.set_device_mac_address(vec![0x08,0x00]);
	let mut dst_mac_addresses: RepeatedField<Vec<u8>> = RepeatedField::new();
	dst_mac_addresses.push(vec![0x04,0x00]);
	app_config_params.set_dst_mac_address(dst_mac_addresses);
	println!("Using initiator profile");
	}
	// Set responder profile in params
	if sub_matches.get_flag("responder"){
	app_config_params.set_device_type(DeviceType::CONTROLEE);
	app_config_params.set_device_role(DeviceRole::RESPONDER);
	app_config_params.set_device_mac_address(vec![0x04,0x00]);
	let mut dst_mac_addresses: RepeatedField<Vec<u8>> = RepeatedField::new();
	dst_mac_addresses.push(vec![0x08,0x00]);
	app_config_params.set_dst_mac_address(dst_mac_addresses);
	println!("Using responder profile");
	}

	// Enable UwB
	let result_bytes = uwbd_proxy.enable()?;
	let result = EnableResponse::parse_from_bytes(&result_bytes)?;
	println!("Enable() returns: {:?}", result.status);

	// Initialize the ranging session
	let mut request = InitSessionRequest::new();
	request.set_session_id(session_id);
	request.set_session_type(SessionType::FIRA_RANGING_SESSION);
	request.set_params(app_config_params);
	let request_bytes = write_to_bytes(&request)?;
	let result_bytes = uwbd_proxy.init_session(request_bytes)?;
	let result = InitSessionResponse::parse_from_bytes(&result_bytes)?;
	println!("InitSessionRequest returns: {:?}", result.status);

	// Start the ranging session
	let mut request = StartRangingRequest::new();
	request.set_session_id(session_id);
	let request_bytes = write_to_bytes(&request)?;
	let result_bytes = uwbd_proxy.start_ranging(request_bytes)?;
	let result = StartRangingResponse::parse_from_bytes(&result_bytes)?;
	println!("StartRangingResponse returns: {:?}", result.status);
	}
	Some(("stop", _)) => {
	// Stop the ranging session
	let mut request = StopRangingRequest::new();
	request.set_session_id(session_id);
	let request_bytes = write_to_bytes(&request)?;
	let result_bytes = uwbd_proxy.stop_ranging(request_bytes)?;
	let result = StopRangingResponse::parse_from_bytes(&result_bytes)?;
	println!("StopRangingResponse returns: {:?}", result.status);

	// Deinit the ranging session
	let mut request = DeinitSessionRequest::new();
	request.set_session_id(session_id);
	let request_bytes = write_to_bytes(&request)?;
	let result_bytes = uwbd_proxy.stop_ranging(request_bytes)?;
	let result = DeinitSessionResponse::parse_from_bytes(&result_bytes)?;
	println!("DeinitSessionResponse returns: {:?}", result.status);
	}
	_ => unreachable!(),
	}

	Ok(())
	}