2022-11-10 03:09:05 +00:00
|
|
|
use std::sync::mpsc::{Sender, self};
|
2022-11-22 01:58:35 +00:00
|
|
|
use std::sync::{Arc, Mutex};
|
2022-08-10 01:56:22 +01:00
|
|
|
use usdpl_back::core::serdes::Primitive;
|
2022-11-22 01:58:35 +00:00
|
|
|
use usdpl_back::AsyncCallable;
|
2022-08-10 01:56:22 +01:00
|
|
|
|
2022-11-10 03:09:05 +00:00
|
|
|
use super::handler::{ApiMessage, BatteryMessage};
|
2022-08-10 01:56:22 +01:00
|
|
|
|
|
|
|
/// Current current (ha!) web method
|
2022-11-22 01:58:35 +00:00
|
|
|
pub fn current_now(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl AsyncCallable {
|
|
|
|
let sender = Arc::new(Mutex::new(sender)); // Sender is not Sync; this is required for safety
|
|
|
|
let getter = move || {
|
|
|
|
let sender2 = sender.clone();
|
|
|
|
move || {
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let callback = move |val: Option<f64>| tx.send(val).expect("current_now callback send failed");
|
|
|
|
sender2.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::ReadCurrentNow(Box::new(callback)))).expect("current_now send failed");
|
|
|
|
rx.recv().expect("current_now callback recv failed")
|
|
|
|
}
|
|
|
|
};
|
|
|
|
super::async_utils::AsyncIshGetter {
|
|
|
|
set_get: getter,
|
|
|
|
trans_getter: |result| {
|
|
|
|
super::utility::map_optional_result(Ok(result))
|
|
|
|
}
|
|
|
|
}
|
2022-09-05 22:02:02 +01:00
|
|
|
}
|
|
|
|
|
2022-11-22 01:58:35 +00:00
|
|
|
/// Current current (ha!) web method
|
|
|
|
/*pub fn current_now(_: super::ApiParameterType) -> super::ApiParameterType {
|
|
|
|
super::utility::map_optional_result(crate::settings::driver::read_current_now())
|
|
|
|
}*/
|
|
|
|
|
2022-09-05 22:02:02 +01:00
|
|
|
/// Charge now web method
|
2022-11-22 01:58:35 +00:00
|
|
|
pub fn charge_now(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl AsyncCallable {
|
|
|
|
let sender = Arc::new(Mutex::new(sender)); // Sender is not Sync; this is required for safety
|
|
|
|
let getter = move || {
|
|
|
|
let sender2 = sender.clone();
|
|
|
|
move || {
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let callback = move |val: Option<f64>| tx.send(val).expect("charge_now callback send failed");
|
|
|
|
sender2.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::ReadChargeNow(Box::new(callback)))).expect("charge_now send failed");
|
|
|
|
rx.recv().expect("charge_now callback recv failed")
|
|
|
|
}
|
|
|
|
};
|
|
|
|
super::async_utils::AsyncIshGetter {
|
|
|
|
set_get: getter,
|
|
|
|
trans_getter: |result| {
|
|
|
|
super::utility::map_optional_result(Ok(result))
|
|
|
|
}
|
|
|
|
}
|
2022-09-05 22:02:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Charge full web method
|
2022-11-22 01:58:35 +00:00
|
|
|
pub fn charge_full(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl AsyncCallable {
|
|
|
|
let sender = Arc::new(Mutex::new(sender)); // Sender is not Sync; this is required for safety
|
|
|
|
let getter = move || {
|
|
|
|
let sender2 = sender.clone();
|
|
|
|
move || {
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let callback = move |val: Option<f64>| tx.send(val).expect("charge_full callback send failed");
|
|
|
|
sender2.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::ReadChargeFull(Box::new(callback)))).expect("charge_full send failed");
|
|
|
|
rx.recv().expect("charge_full callback recv failed")
|
|
|
|
}
|
|
|
|
};
|
|
|
|
super::async_utils::AsyncIshGetter {
|
|
|
|
set_get: getter,
|
|
|
|
trans_getter: |result| {
|
|
|
|
super::utility::map_optional_result(Ok(result))
|
|
|
|
}
|
|
|
|
}
|
2022-09-05 22:02:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Charge design web method
|
2022-11-22 01:58:35 +00:00
|
|
|
pub fn charge_design(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl AsyncCallable {
|
|
|
|
let sender = Arc::new(Mutex::new(sender)); // Sender is not Sync; this is required for safety
|
|
|
|
let getter = move || {
|
|
|
|
let sender2 = sender.clone();
|
|
|
|
move || {
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let callback = move |val: Option<f64>| tx.send(val).expect("charge_design callback send failed");
|
|
|
|
sender2.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::ReadChargeDesign(Box::new(callback)))).expect("charge_design send failed");
|
|
|
|
rx.recv().expect("charge_design callback recv failed")
|
|
|
|
}
|
|
|
|
};
|
|
|
|
super::async_utils::AsyncIshGetter {
|
|
|
|
set_get: getter,
|
|
|
|
trans_getter: |result| {
|
|
|
|
super::utility::map_optional_result(Ok(result))
|
|
|
|
}
|
|
|
|
}
|
2022-08-10 01:56:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate set battery charge rate web method
|
|
|
|
pub fn set_charge_rate(
|
2022-11-10 03:09:05 +00:00
|
|
|
sender: Sender<ApiMessage>,
|
2022-08-10 01:56:22 +01:00
|
|
|
) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
|
2022-11-10 03:09:05 +00:00
|
|
|
let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
|
|
|
|
let setter = move |rate: f64|
|
|
|
|
sender.lock()
|
|
|
|
.unwrap()
|
|
|
|
.send(ApiMessage::Battery(BatteryMessage::SetChargeRate(Some(rate as u64))))
|
|
|
|
.expect("set_charge_rate send failed");
|
2022-08-10 01:56:22 +01:00
|
|
|
move |params_in: super::ApiParameterType| {
|
2022-11-10 03:09:05 +00:00
|
|
|
if let Some(&Primitive::F64(new_val)) = params_in.get(0) {
|
|
|
|
setter(new_val);
|
|
|
|
vec![(new_val).into()]
|
2022-08-10 01:56:22 +01:00
|
|
|
} else {
|
|
|
|
vec!["set_charge_rate missing parameter".into()]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate get battery charge rate web method
|
|
|
|
pub fn get_charge_rate(
|
2022-11-10 03:09:05 +00:00
|
|
|
sender: Sender<ApiMessage>,
|
2022-08-10 01:56:22 +01:00
|
|
|
) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
|
2022-11-10 03:09:05 +00:00
|
|
|
let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
|
|
|
|
let getter = move || {
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let callback = move |rate: Option<u64>| tx.send(rate).expect("get_charge_rate callback send failed");
|
|
|
|
sender.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::GetChargeRate(Box::new(callback)))).expect("get_charge_rate send failed");
|
|
|
|
rx.recv().expect("get_charge_rate callback recv failed")
|
|
|
|
};
|
2022-08-10 01:56:22 +01:00
|
|
|
move |_: super::ApiParameterType| {
|
2022-11-10 03:09:05 +00:00
|
|
|
vec![getter().map(|x| x.into()).unwrap_or(Primitive::Empty)]
|
2022-08-10 01:56:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate unset battery charge rate web method
|
|
|
|
pub fn unset_charge_rate(
|
2022-11-10 03:09:05 +00:00
|
|
|
sender: Sender<ApiMessage>,
|
2022-08-10 01:56:22 +01:00
|
|
|
) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
|
2022-11-10 03:09:05 +00:00
|
|
|
let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
|
|
|
|
let setter = move || sender.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::SetChargeRate(None))).expect("unset_charge_rate send failed");
|
|
|
|
move |_params_in: super::ApiParameterType| {
|
|
|
|
setter();
|
|
|
|
vec![true.into()]
|
2022-08-10 01:56:22 +01:00
|
|
|
}
|
|
|
|
}
|
2022-11-21 22:00:43 +00:00
|
|
|
|
|
|
|
/// Generate set battery charge mode web method
|
|
|
|
pub fn set_charge_mode(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
|
|
|
|
let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
|
|
|
|
let setter = move |mode: String|
|
|
|
|
sender.lock()
|
|
|
|
.unwrap()
|
|
|
|
.send(ApiMessage::Battery(BatteryMessage::SetChargeMode(Some(mode))))
|
|
|
|
.expect("set_charge_mode send failed");
|
|
|
|
move |params_in: super::ApiParameterType| {
|
|
|
|
if let Some(Primitive::String(new_val)) = params_in.get(0) {
|
|
|
|
setter(new_val.to_owned());
|
|
|
|
vec![new_val.to_owned().into()]
|
|
|
|
} else {
|
|
|
|
vec!["set_charge_rate missing parameter".into()]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate get battery charge mode web method
|
|
|
|
pub fn get_charge_mode(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
|
|
|
|
let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
|
|
|
|
let getter = move || {
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let callback = move |mode: Option<String>| tx.send(mode).expect("get_charge_mode callback send failed");
|
|
|
|
sender.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::GetChargeMode(Box::new(callback)))).expect("get_charge_mode send failed");
|
|
|
|
rx.recv().expect("get_charge_mode callback recv failed")
|
|
|
|
};
|
|
|
|
move |_: super::ApiParameterType| {
|
|
|
|
vec![getter().map(|x| x.into()).unwrap_or(Primitive::Empty)]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate unset battery charge mode web method
|
|
|
|
pub fn unset_charge_mode(
|
|
|
|
sender: Sender<ApiMessage>,
|
|
|
|
) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
|
|
|
|
let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
|
|
|
|
let setter = move || sender.lock().unwrap().send(ApiMessage::Battery(BatteryMessage::SetChargeMode(None))).expect("unset_charge_mode send failed");
|
|
|
|
move |_params_in: super::ApiParameterType| {
|
|
|
|
setter();
|
|
|
|
vec![true.into()]
|
|
|
|
}
|
|
|
|
}
|