BFPOWER/physical
2
0
Fork 0
Code Issues 2 Pull Requests Releases Activity

Switched custom quantities to using a macro for generation.

Browse Source
This commit is contained in:
Zachary Sunforge
2024-07-10 22:06:16 -07:00
parent da5fca74ef
commit ec497fb256
9 changed files with 165 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Cargo.toml
View File

@ -6,10 +6,12 @@ members = [
# Device types
"node",
"commander",
# Meta
"generate-quantity"
]
[workspace.package]
version = "0.3.5"
version = "0.3.6"
edition = "2021"
repository = "https://git.bfpower.io/BFPOWER/physical"
readme = "README.md"
@ -89,6 +91,8 @@ version = "2.0.*"
features = ["extra-traits", "parsing"]
[workspace.dependencies.quote]
version = "1.0.*"
[workspace.dependencies.proc-macro2]
version = "1.0.*"
[workspace.dependencies.trybuild]
version = "1.0.*"
@ -114,6 +118,8 @@ lm35 = []
pid = []
stm32 = []
[dependencies.generate-quantity]
path = "generate-quantity"
[dependencies.num-traits]
workspace = true
[dependencies.derive_more]

18
generate-quantity/Cargo.toml Normal file
View File

@ -0,0 +1,18 @@
[package]
name = "generate-quantity"
description = "Macros for generating physical quantity type"
version.workspace = true
edition.workspace = true
repository.workspace = true
readme.workspace = true
license.workspace = true
[lib]
proc-macro = true
[dependencies.quote]
workspace = true
[dependencies.syn]
workspace = true
[dependencies.proc-macro2]
workspace = true

101
generate-quantity/src/lib.rs Normal file
View File

@ -0,0 +1,101 @@
extern crate proc_macro;
use proc_macro::TokenStream;
use proc_macro2::{Span, TokenStream as TokenStream2};
use quote::quote;
use syn::parse::{Parse, ParseStream};
use syn::{parse_macro_input, Ident, LitStr, Token};
const NUMBER_TYPES: &[&str] = &[
"u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "u128", "i128", "usize", "isize", "f32",
"f64",
];
// Define the input structure for the macro
struct QuantityInput {
struct_name: Ident,
symbol: LitStr,
}
// Implement the parsing for the input structure
impl Parse for QuantityInput {
fn parse(input: ParseStream) -> syn::Result<Self> {
let struct_name: Ident = input.parse()?;
input.parse::<Token![,]>()?;
let symbol: LitStr = input.parse()?;
Ok(QuantityInput {
struct_name,
symbol,
})
}
}
/// The following imports must be in scope for this macro to work
/// ```
/// use physical::quantity::{Quantity, Value};
/// use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
/// use generate_quantity::quantity_type;
/// ```
#[proc_macro]
pub fn quantity_type(input: TokenStream) -> TokenStream {
// Parse the input tokens into the QuantityInput structure
let QuantityInput {
struct_name,
symbol,
} = parse_macro_input!(input as QuantityInput);
//----- Conversion impls ----------------------------------
let mut impls: Vec<TokenStream2> = Vec::new();
for &current_type in NUMBER_TYPES {
// Generate conversion methods for all primitive types except the current_type
let conversions = NUMBER_TYPES
.iter()
.filter(|&&t| t != current_type)
.map(|&target_type| {
let method_name = Ident::new(&format!("as_{}", target_type), Span::call_site());
let target_type = Ident::new(target_type, Span::call_site());
quote! {
/// Directly [as] cast this quantities value while maintaining the type of the quantity.
#[inline(always)]
pub fn #method_name(self) -> #struct_name<#target_type> {
#struct_name(self.0 as #target_type)
}
}
})
.collect::<Vec<TokenStream2>>();
let current_type = Ident::new(current_type, Span::call_site());
// Generate the impl block for the struct with the current_type
let expanded = quote! {
impl #struct_name<#current_type> {
#(#conversions)*
}
};
impls.push(expanded);
}
//----- Output Code ----------------------------------
let expanded = quote! {
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct #struct_name<V: Value>(pub V);
impl<V: Value> Quantity<V> for #struct_name<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
#symbol
}
}
#(#impls)*
};
expanded.into()
}

24
src/quantity/irradiance.rs
View File

@ -1,22 +1,6 @@
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use crate::quantity::{Quantity, Value};
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use generate_quantity::quantity_type;
// ---------------------------------------------------------------------------------------------------------------------
// ----- Watts per Square Meter ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct WattsPerSquareMeter<V: Value>(pub V);
impl <V: Value> Quantity<V> for WattsPerSquareMeter<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"W/m²"
}
}
//----- Watter per Square Meter ----------------------------------
quantity_type! {WattsPerSquareMeter, "W/m²"}

16
src/quantity/mod.rs
View File

@ -49,7 +49,7 @@ pub trait Value: Num + Copy + PartialOrd + FromPrimitive + NumCast + Display {
fn kelvins(self) -> Kelvins<Self> {
Kelvins(self)
}
#[inline(always)]
fn deci_kelvins(self) -> DeciKelvins<Self> {
DeciKelvins(self)
@ -59,7 +59,7 @@ pub trait Value: Num + Copy + PartialOrd + FromPrimitive + NumCast + Display {
fn degrees_celsius(self) -> DegreesCelsius<Self> {
DegreesCelsius(self)
}
#[inline(always)]
fn deci_degrees_celsius(self) -> DeciDegreesCelsius<Self> {
DeciDegreesCelsius(self)
@ -161,6 +161,12 @@ mod defmt_impl {
}
}
impl<Q: Quantity<usize>> Format for Fmt<usize, Q> {
fn format(&self, fmt: Formatter) {
write!(fmt, "{} {}", self.quantity.value(), Q::symbol());
}
}
impl<Q: Quantity<i8>> Format for Fmt<i8, Q> {
fn format(&self, fmt: Formatter) {
write!(fmt, "{} {}", self.quantity.value(), Q::symbol());
@ -191,6 +197,12 @@ mod defmt_impl {
}
}
impl<Q: Quantity<isize>> Format for Fmt<isize, Q> {
fn format(&self, fmt: Formatter) {
write!(fmt, "{} {}", self.quantity.value(), Q::symbol());
}
}
impl<Q: Quantity<f32>> Format for Fmt<f32, Q> {
fn format(&self, fmt: Formatter) {
write!(fmt, "{} {}", self.quantity.value(), Q::symbol());

22
src/quantity/resistance.rs
View File

@ -1,22 +1,6 @@
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use generate_quantity::quantity_type;
use crate::quantity::{Quantity, Value};
// ---------------------------------------------------------------------------------------------------------------------
// ----- Ohms ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct Ohms<V: Value>(pub V);
impl <V: Value> Quantity<V> for Ohms<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"Ω"
}
}
//----- Ohms ----------------------------------
quantity_type! {Ohms, "Ω"}

86
src/quantity/temperature.rs
View File

@ -1,28 +1,11 @@
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use num_traits::float::FloatCore;
use generate_quantity::quantity_type;
use crate::quantity::{DECI, Quantity, Value};
const KELVIN_CELSIUS_OFFSET: f64 = 273.15;
// ---------------------------------------------------------------------------------------------------------------------
// ----- Kelvins ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct Kelvins<V: Value>(pub V);
impl <V: Value> Quantity<V> for Kelvins<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"K"
}
}
//----- Kelvins ----------------------------------
quantity_type! {Kelvins, "K"}
impl <V: Value> Kelvins<V> {
#[inline]
@ -39,25 +22,8 @@ impl <V: Value> Kelvins<V> {
}
}
// ---------------------------------------------------------------------------------------------------------------------
// ----- Deci Kelvins ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct DeciKelvins<V: Value>(pub V);
impl <V: Value> Quantity<V> for DeciKelvins<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"dK"
}
}
//----- Deci Kelvins ----------------------------------
quantity_type! {DeciKelvins, "dK"}
impl<V: Value> DeciKelvins<V> {
#[inline]
@ -67,25 +33,8 @@ impl<V: Value> DeciKelvins<V> {
}
}
// ---------------------------------------------------------------------------------------------------------------------
// ----- Degrees Celsius ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct DegreesCelsius<V: Value>(pub V);
impl <V: Value> Quantity<V> for DegreesCelsius<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"℃"
}
}
//----- Degrees Celsius ----------------------------------
quantity_type! {DegreesCelsius, "℃"}
impl <V: Value> DegreesCelsius<V> {
#[inline]
@ -102,25 +51,8 @@ impl <V: Value> DegreesCelsius<V> {
}
}
// ---------------------------------------------------------------------------------------------------------------------
// ----- Deci Degrees Celsius ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct DeciDegreesCelsius<V: Value>(pub V);
impl <V: Value> Quantity<V> for DeciDegreesCelsius<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"d℃"
}
}
//----- Deci Degrees Celsius ----------------------------------
quantity_type! {DeciDegreesCelsius, "d℃"}
impl<V: Value> DeciDegreesCelsius<V> {
#[inline]

43
src/quantity/voltage.rs
View File

@ -1,27 +1,11 @@
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use generate_quantity::quantity_type;
use crate::quantity::{Quantity, Value};
const VOLT_MV_RATIO: u16 = 1_000;
// ---------------------------------------------------------------------------------------------------------------------
// ----- Volts ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct Volts<V: Value>(pub V);
impl <V: Value> Quantity<V> for Volts<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"V"
}
}
//----- Volts ----------------------------------
quantity_type! {Volts, "V"}
impl<V: Value> Volts<V> {
#[inline]
@ -31,25 +15,8 @@ impl<V: Value> Volts<V> {
}
}
// ---------------------------------------------------------------------------------------------------------------------
// ----- MilliVolts ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct MilliVolts<V: Value>(pub V);
impl <V: Value> Quantity<V> for MilliVolts<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"mV"
}
}
//----- Milli Volts ----------------------------------
quantity_type! {MilliVolts, "mV"}
impl<V: Value> MilliVolts<V> {
pub fn to_volts(self) -> Volts<V> {

24
src/quantity/volume_rate.rs
View File

@ -1,22 +1,6 @@
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use crate::quantity::{Quantity, Value};
use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
use generate_quantity::quantity_type;
// ---------------------------------------------------------------------------------------------------------------------
// ----- Liters per Minute------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
#[display(fmt = "{} {}", _0, "Self::symbol()")]
#[repr(transparent)]
pub struct LitersPerMinute<V: Value>(pub V);
impl <V: Value> Quantity<V> for LitersPerMinute<V> {
#[inline(always)]
fn value(self) -> V {
self.0
}
#[inline(always)]
fn symbol() -> &'static str {
"L/min"
}
}
//----- Liters per Minute ----------------------------------
quantity_type! {LitersPerMinute, "L/min"}