gondola_core/monitoring/
rb_moni_data.rs

1// This file is part of gaps-online-software and published 
2// under the GPLv3 license
3
4use crate::prelude::*;
5
6#[cfg(feature="tofcontrol")]
7use tof_control::helper::rb_type::{
8  RBMag,
9  RBTemp,
10  RBPh,
11  RBVcp
12};
13
14/// Sensors on the individual RB
15///  
16/// This includes temperatures, power data,
17/// pressure, humidity
18/// as well as the magnetic sensors
19#[derive(Debug, Copy, Clone, PartialEq)]
20#[cfg_attr(feature="pybindings", pyclass)]
21pub struct RBMoniData {
22  pub board_id           : u8,
23  pub rate               : u16,
24  pub tmp_drs            : f32,
25  pub tmp_clk            : f32,
26  pub tmp_adc            : f32,
27  pub tmp_zynq           : f32,
28  pub tmp_lis3mdltr      : f32,
29  pub tmp_bm280          : f32,
30  pub pressure           : f32,
31  pub humidity           : f32,
32  pub mag_x              : f32,
33  pub mag_y              : f32,
34  pub mag_z              : f32,
35  pub lost_event_ids     : f32,
36  pub drs_dvdd_voltage   : f32, 
37  pub drs_dvdd_current   : f32,
38  pub drs_dvdd_power     : f32,
39  pub p3v3_voltage       : f32,
40  pub p3v3_current       : f32,
41  pub p3v3_power         : f32,
42  pub zynq_voltage       : f32,
43  pub zynq_current       : f32,
44  pub zynq_power         : f32,
45  pub p3v5_voltage       : f32, 
46  pub p3v5_current       : f32,
47  pub p3v5_power         : f32,
48  pub adc_dvdd_voltage   : f32,
49  pub adc_dvdd_current   : f32,
50  pub adc_dvdd_power     : f32,
51  pub adc_avdd_voltage   : f32,
52  pub adc_avdd_current   : f32,
53  pub adc_avdd_power     : f32,
54  pub drs_avdd_voltage   : f32, 
55  pub drs_avdd_current   : f32,
56  pub drs_avdd_power     : f32,
57  pub n1v5_voltage       : f32,
58  pub n1v5_current       : f32,
59  pub n1v5_power         : f32,
60  // new - we add the t
61  // Won't get serialized, but can be filled 
62  // with the gcutime down the road for plotting
63  pub timestamp          : u64
64}
65
66impl RBMoniData {
67  
68  pub fn new() -> Self {
69    Self {
70      board_id           : 0, 
71      rate               : 0,
72      tmp_drs            : f32::MAX,
73      tmp_clk            : f32::MAX,
74      tmp_adc            : f32::MAX,
75      tmp_zynq           : f32::MAX,
76      tmp_lis3mdltr      : f32::MAX,
77      tmp_bm280          : f32::MAX,
78      pressure           : f32::MAX,
79      humidity           : f32::MAX,
80      mag_x              : f32::MAX,
81      mag_y              : f32::MAX,
82      mag_z              : f32::MAX,
83      lost_event_ids     : f32::MAX,
84      drs_dvdd_voltage   : f32::MAX, 
85      drs_dvdd_current   : f32::MAX,
86      drs_dvdd_power     : f32::MAX,
87      p3v3_voltage       : f32::MAX,
88      p3v3_current       : f32::MAX,
89      p3v3_power         : f32::MAX,
90      zynq_voltage       : f32::MAX,
91      zynq_current       : f32::MAX,
92      zynq_power         : f32::MAX,
93      p3v5_voltage       : f32::MAX, 
94      p3v5_current       : f32::MAX,
95      p3v5_power         : f32::MAX,
96      adc_dvdd_voltage   : f32::MAX,
97      adc_dvdd_current   : f32::MAX,
98      adc_dvdd_power     : f32::MAX,
99      adc_avdd_voltage   : f32::MAX,
100      adc_avdd_current   : f32::MAX,
101      adc_avdd_power     : f32::MAX,
102      drs_avdd_voltage   : f32::MAX, 
103      drs_avdd_current   : f32::MAX,
104      drs_avdd_power     : f32::MAX,
105      n1v5_voltage       : f32::MAX,
106      n1v5_current       : f32::MAX,
107      n1v5_power         : f32::MAX,
108      timestamp          : 0,
109    }
110  }
111
112  #[cfg(feature = "tofcontrol")]
113  pub fn add_rbvcp(&mut self, rb_vcp   : &RBVcp) {
114    self.drs_dvdd_voltage = rb_vcp.drs_dvdd_vcp[0] ;
115    self.drs_dvdd_current = rb_vcp.drs_dvdd_vcp[1] ;
116    self.drs_dvdd_power   = rb_vcp.drs_dvdd_vcp[2] ;
117    self.p3v3_voltage     = rb_vcp.p3v3_vcp[0]  ;
118    self.p3v3_current     = rb_vcp.p3v3_vcp[1]  ;
119    self.p3v3_power       = rb_vcp.p3v3_vcp[2]  ;
120    self.zynq_voltage     = rb_vcp.zynq_vcp[0]  ;
121    self.zynq_current     = rb_vcp.zynq_vcp[1]  ;
122    self.zynq_power       = rb_vcp.zynq_vcp[2]  ;
123    self.p3v5_voltage     = rb_vcp.p3v5_vcp[0]  ;
124    self.p3v5_current     = rb_vcp.p3v5_vcp[1]  ;
125    self.p3v5_power       = rb_vcp.p3v5_vcp[2]  ;
126    self.adc_dvdd_voltage = rb_vcp.adc_dvdd_vcp[0] ;
127    self.adc_dvdd_current = rb_vcp.adc_dvdd_vcp[1] ;
128    self.adc_dvdd_power   = rb_vcp.adc_dvdd_vcp[2] ;
129    self.adc_avdd_voltage = rb_vcp.adc_avdd_vcp[0]  ;
130    self.adc_avdd_current = rb_vcp.adc_avdd_vcp[1]  ;
131    self.adc_avdd_power   = rb_vcp.adc_avdd_vcp[2]  ;
132    self.drs_avdd_voltage = rb_vcp.drs_avdd_vcp[0]  ;
133    self.drs_avdd_current = rb_vcp.drs_avdd_vcp[1]  ;
134    self.drs_avdd_power   = rb_vcp.drs_avdd_vcp[2]  ;
135    self.n1v5_voltage     = rb_vcp.n1v5_vcp[0]      ;
136    self.n1v5_current     = rb_vcp.n1v5_vcp[1]      ;
137    self.n1v5_power       = rb_vcp.n1v5_vcp[2]      ;
138  }
139  
140  #[cfg(feature = "tofcontrol")] 
141  pub fn add_rbph(&mut self, rb_ph   : &RBPh) {
142    self.pressure = rb_ph.pressure;
143    self.humidity = rb_ph.humidity;
144  }
145  #[cfg(feature = "tofcontrol")]
146  pub fn add_rbtemp(&mut self, rb_temp : &RBTemp) {
147    self.tmp_drs         = rb_temp.drs_temp      ; 
148    self.tmp_clk         = rb_temp.clk_temp      ; 
149    self.tmp_adc         = rb_temp.adc_temp      ; 
150    self.tmp_zynq        = rb_temp.zynq_temp     ; 
151    self.tmp_lis3mdltr   = rb_temp.lis3mdltr_temp; 
152    self.tmp_bm280       = rb_temp.bme280_temp   ; 
153  }
154
155  #[cfg(feature = "tofcontrol")] 
156  pub fn add_rbmag(&mut self, rb_mag   : &RBMag) {
157    self.mag_x   = rb_mag.mag_xyz[0];
158    self.mag_y   = rb_mag.mag_xyz[1];
159    self.mag_z   = rb_mag.mag_xyz[2];
160  }
161 
162  pub fn get_mag_tot(&self) -> f32 {
163    (self.mag_x.powi(2) + self.mag_y.powi(2) + self.mag_z.powi(2)).sqrt()
164  }
165
166  /// Get the rate-weighted number of event ids which were found unusable 
167  /// by the RB 
168  pub fn get_lost_event_ids_over_rate(&self) -> f32 {
169    if self.rate == 0 {
170      return 0.0 
171    }
172    100.0*self.lost_event_ids / self.rate as f32 
173  }
174}
175
176impl Default for RBMoniData {
177  fn default() -> Self {
178    Self::new()
179  }
180}
181
182impl fmt::Display for RBMoniData {
183  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
184    write!(f, "<RBMoniData:
185  BOARD ID       {}
186  RATE           {}    [Hz] 
187  LOST EV IDS    {:.3} [%/Rate]   
188  ** Temperatures **
189  DRS TMP        {:.3} [\u{00B0}C]
190  CLK TMP        {:.3} [\u{00B0}C]
191  ADC TMP        {:.3} [\u{00B0}C]
192  ZYNQ TMP       {:.3} [\u{00B0}C]
193  LIS3MDLTR TMP  {:.3} [\u{00B0}C]  
194  BM280 TMP      {:.3} [\u{00B0}C]
195  ** Ambience **
196  PRESSURE       {:.3} [hPa]
197  HUMIDITY       {:.3} [%]
198  MAG_X , MAG_Y, MAG_Z, MAG_TOT:
199   |->  {:.3} [G] | {:.3} [G] | {:.3} [G] | {:.3} [G]
200  ** Power **
201  ZYNQ 3.3V         Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]
202  3.3V              Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]
203  3.5V              Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]
204  -1.5V             Power: {:.3}  [V] | {:.3} [A] | {:.3} [W]
205  DRS4 Digital 2.5V Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]
206  DRS4 Analog 2.5V  Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]
207  ADC Digital 2.5V  Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]
208  ADC Analog 3.0V   Power:  {:.3}  [V] | {:.3} [A] | {:.3} [W]>",
209           self.board_id        , 
210           self.rate            ,
211           self.get_lost_event_ids_over_rate(),
212           self.tmp_drs         ,
213           self.tmp_clk         ,
214           self.tmp_adc         ,
215           self.tmp_zynq        ,
216           self.tmp_lis3mdltr   ,
217           self.tmp_bm280       ,
218           self.pressure        ,
219           self.humidity        ,
220           self.mag_x           ,
221           self.mag_y           ,
222           self.mag_z           ,
223           self.get_mag_tot()   ,
224           self.zynq_voltage    ,
225           self.zynq_current    ,
226           self.zynq_power      ,
227           self.p3v3_voltage    ,
228           self.p3v3_current    ,
229           self.p3v3_power      ,
230           self.p3v5_voltage    , 
231           self.p3v5_current    ,
232           self.p3v5_power      ,
233           self.n1v5_voltage    ,
234           self.n1v5_current    ,
235           self.n1v5_power      ,
236           self.drs_dvdd_voltage, 
237           self.drs_dvdd_current,
238           self.drs_dvdd_power  ,
239           self.drs_avdd_voltage, 
240           self.drs_avdd_current,
241           self.drs_avdd_power  ,
242           self.adc_dvdd_voltage,
243           self.adc_dvdd_current,
244           self.adc_dvdd_power  ,
245           self.adc_avdd_voltage,
246           self.adc_avdd_current,
247           self.adc_avdd_power  )
248  }
249}
250
251impl MoniData for RBMoniData {
252
253  fn get_timestamp(&self) -> u64 {
254    self.timestamp
255  }
256
257  fn set_timestamp(&mut self, ts : u64) {
258    self.timestamp = ts 
259  }
260
261  fn get_board_id(&self) -> u8 {
262    self.board_id
263  }
264  
265  /// Access the (data) members by name 
266  fn get(&self, varname : &str) -> Option<f32> {
267    match varname {
268      "board_id"         => Some(self.board_id as   f32),
269      "rate"             => Some(self.rate as f32      ), 
270      "tmp_drs"          => Some(self.tmp_drs          ), 
271      "tmp_clk"          => Some(self.tmp_clk          ), 
272      "tmp_adc"          => Some(self.tmp_adc          ), 
273      "tmp_zynq"         => Some(self.tmp_zynq         ), 
274      "tmp_lis3mdltr"    => Some(self.tmp_lis3mdltr    ), 
275      "tmp_bm280"        => Some(self.tmp_bm280        ), 
276      "pressure"         => Some(self.pressure         ), 
277      "humidity"         => Some(self.humidity         ), 
278      "mag_x"            => Some(self.mag_x            ), 
279      "mag_y"            => Some(self.mag_y            ), 
280      "mag_z"            => Some(self.mag_z            ), 
281      "mag_tot"          => Some(self.get_mag_tot()    ),
282      "drs_dvdd_voltage" => Some(self.drs_dvdd_voltage ), 
283      "drs_dvdd_current" => Some(self.drs_dvdd_current ), 
284      "drs_dvdd_power"   => Some(self.drs_dvdd_power   ), 
285      "p3v3_voltage"     => Some(self.p3v3_voltage     ), 
286      "p3v3_current"     => Some(self.p3v3_current     ), 
287      "p3v3_power"       => Some(self.p3v3_power       ), 
288      "zynq_voltage"     => Some(self.zynq_voltage     ), 
289      "zynq_current"     => Some(self.zynq_current     ), 
290      "zynq_power"       => Some(self.zynq_power       ), 
291      "p3v5_voltage"     => Some(self.p3v5_voltage     ), 
292      "p3v5_current"     => Some(self.p3v5_current     ), 
293      "p3v5_power"       => Some(self.p3v5_power       ), 
294      "adc_dvdd_voltage" => Some(self.adc_dvdd_voltage ), 
295      "adc_dvdd_current" => Some(self.adc_dvdd_current ), 
296      "adc_dvdd_power"   => Some(self.adc_dvdd_power   ), 
297      "adc_avdd_voltage" => Some(self.adc_avdd_voltage ), 
298      "adc_avdd_current" => Some(self.adc_avdd_current ), 
299      "adc_avdd_power"   => Some(self.adc_avdd_power   ), 
300      "drs_avdd_voltage" => Some(self.drs_avdd_voltage ), 
301      "drs_avdd_current" => Some(self.drs_avdd_current ), 
302      "drs_avdd_power"   => Some(self.drs_avdd_power   ), 
303      "n1v5_voltage"     => Some(self.n1v5_voltage     ), 
304      "n1v5_current"     => Some(self.n1v5_current     ), 
305      "n1v5_power"       => Some(self.n1v5_power       ),
306      "timestamp"        => Some(self.timestamp  as f32),
307      _             => None
308    }
309  }
310
311  /// A list of the variables in this MoniData
312  fn keys() -> Vec<&'static str> {
313    vec![
314      "board_id"        , 
315      "rate"            , 
316      "tmp_drs"         , 
317      "tmp_clk"         , 
318      "tmp_adc"         , 
319      "tmp_zynq"        , 
320      "tmp_lis3mdltr"   , 
321      "tmp_bm280"       , 
322      "pressure"        , 
323      "humidity"        , 
324      "mag_x"           , 
325      "mag_y"           , 
326      "mag_z"           , 
327      "drs_dvdd_voltage", 
328      "drs_dvdd_current", 
329      "drs_dvdd_power"  , 
330      "p3v3_voltage"    , 
331      "p3v3_current"    , 
332      "p3v3_power"      , 
333      "zynq_voltage"    , 
334      "zynq_current"    , 
335      "zynq_power"      , 
336      "p3v5_voltage"    , 
337      "p3v5_current"    , 
338      "p3v5_power"      , 
339      "adc_dvdd_voltage", 
340      "adc_dvdd_current", 
341      "adc_dvdd_power"  , 
342      "adc_avdd_voltage", 
343      "adc_avdd_current", 
344      "adc_avdd_power"  , 
345      "drs_avdd_voltage", 
346      "drs_avdd_current", 
347      "drs_avdd_power"  , 
348      "n1v5_voltage"    , 
349      "n1v5_current"    , 
350      "timestamp"       ,
351      "n1v5_power"      ] 
352  }
353}
354
355impl TofPackable for RBMoniData {
356  const TOF_PACKET_TYPE : TofPacketType = TofPacketType::RBMoniData;
357}
358
359impl Serialization for RBMoniData {
360  
361  const HEAD : u16 = 0xAAAA;
362  const TAIL : u16 = 0x5555;
363  /// The data size when serialized to a bytestream
364  /// This needs to be updated when we change the 
365  /// packet layout, e.g. add new members.
366  /// HEAD + TAIL + sum(sizeof(m) for m in _all_members_))
367  const SIZE : usize  = 7 + (36*4) ;
368  
369  fn to_bytestream(&self) -> Vec<u8> {
370    let mut stream = Vec::<u8>::with_capacity(Self::SIZE);
371    stream.extend_from_slice(&Self::HEAD.to_le_bytes());
372    stream.extend_from_slice(&self.board_id          .to_le_bytes()); 
373    stream.extend_from_slice(&self.rate              .to_le_bytes()); 
374    stream.extend_from_slice(&self.tmp_drs           .to_le_bytes()); 
375    stream.extend_from_slice(&self.tmp_clk           .to_le_bytes()); 
376    stream.extend_from_slice(&self.tmp_adc           .to_le_bytes()); 
377    stream.extend_from_slice(&self.tmp_zynq          .to_le_bytes()); 
378    stream.extend_from_slice(&self.tmp_lis3mdltr     .to_le_bytes()); 
379    stream.extend_from_slice(&self.tmp_bm280         .to_le_bytes()); 
380    stream.extend_from_slice(&self.pressure          .to_le_bytes()); 
381    stream.extend_from_slice(&self.humidity          .to_le_bytes()); 
382    stream.extend_from_slice(&self.mag_x             .to_le_bytes()); 
383    stream.extend_from_slice(&self.mag_y             .to_le_bytes()); 
384    stream.extend_from_slice(&self.mag_z             .to_le_bytes());
385    // padding - just for compatibility
386    //stream.extend_from_slice(&0.0_f32                 .to_le_bytes());
387    stream.extend_from_slice(&self.lost_event_ids     .to_le_bytes());
388    //stream.extend_from_slice(&0u16                    .to_le_bytes());
389    stream.extend_from_slice(&self.drs_dvdd_voltage   .to_le_bytes()); 
390    stream.extend_from_slice(&self.drs_dvdd_current   .to_le_bytes()); 
391    stream.extend_from_slice(&self.drs_dvdd_power     .to_le_bytes()); 
392    stream.extend_from_slice(&self.p3v3_voltage       .to_le_bytes()); 
393    stream.extend_from_slice(&self.p3v3_current       .to_le_bytes()); 
394    stream.extend_from_slice(&self.p3v3_power         .to_le_bytes()); 
395    stream.extend_from_slice(&self.zynq_voltage       .to_le_bytes()); 
396    stream.extend_from_slice(&self.zynq_current       .to_le_bytes()); 
397    stream.extend_from_slice(&self.zynq_power         .to_le_bytes()); 
398    stream.extend_from_slice(&self.p3v5_voltage       .to_le_bytes()); 
399    stream.extend_from_slice(&self.p3v5_current       .to_le_bytes()); 
400    stream.extend_from_slice(&self.p3v5_power         .to_le_bytes()); 
401    stream.extend_from_slice(&self.adc_dvdd_voltage   .to_le_bytes()); 
402    stream.extend_from_slice(&self.adc_dvdd_current   .to_le_bytes()); 
403    stream.extend_from_slice(&self.adc_dvdd_power     .to_le_bytes()); 
404    stream.extend_from_slice(&self.adc_avdd_voltage   .to_le_bytes()); 
405    stream.extend_from_slice(&self.adc_avdd_current   .to_le_bytes()); 
406    stream.extend_from_slice(&self.adc_avdd_power     .to_le_bytes()); 
407    stream.extend_from_slice(&self.drs_avdd_voltage   .to_le_bytes()); 
408    stream.extend_from_slice(&self.drs_avdd_current   .to_le_bytes()); 
409    stream.extend_from_slice(&self.drs_avdd_power     .to_le_bytes()); 
410    stream.extend_from_slice(&self.n1v5_voltage       .to_le_bytes()); 
411    stream.extend_from_slice(&self.n1v5_current       .to_le_bytes()); 
412    stream.extend_from_slice(&self.n1v5_power         .to_le_bytes()); 
413    stream.extend_from_slice(&Self::TAIL.to_le_bytes());
414    stream
415  }
416
417  fn from_bytestream(stream    : &Vec<u8>, 
418                     pos       : &mut usize) 
419    -> Result<RBMoniData, SerializationError>{
420    let mut moni_data = Self::new();
421    Self::verify_fixed(stream, pos)?;
422    moni_data.board_id           = parse_u8( stream, pos); 
423    moni_data.rate               = parse_u16(stream, pos); 
424    moni_data.tmp_drs            = parse_f32(stream, pos); 
425    moni_data.tmp_clk            = parse_f32(stream, pos); 
426    moni_data.tmp_adc            = parse_f32(stream, pos); 
427    moni_data.tmp_zynq           = parse_f32(stream, pos); 
428    moni_data.tmp_lis3mdltr      = parse_f32(stream, pos); 
429    moni_data.tmp_bm280          = parse_f32(stream, pos); 
430    moni_data.pressure           = parse_f32(stream, pos); 
431    moni_data.humidity           = parse_f32(stream, pos); 
432    moni_data.mag_x              = parse_f32(stream, pos); 
433    moni_data.mag_y              = parse_f32(stream, pos); 
434    moni_data.mag_z              = parse_f32(stream, pos); 
435    
436    // compatibility, no mag_tot anymore - we are using the 
437    // 4 bytes for different values now 
438    moni_data.lost_event_ids     = parse_f32(stream, pos);
439    //*pos += 2;
440    moni_data.drs_dvdd_voltage   = parse_f32(stream, pos); 
441    moni_data.drs_dvdd_current   = parse_f32(stream, pos); 
442    moni_data.drs_dvdd_power     = parse_f32(stream, pos); 
443    moni_data.p3v3_voltage       = parse_f32(stream, pos); 
444    moni_data.p3v3_current       = parse_f32(stream, pos); 
445    moni_data.p3v3_power         = parse_f32(stream, pos); 
446    moni_data.zynq_voltage       = parse_f32(stream, pos); 
447    moni_data.zynq_current       = parse_f32(stream, pos); 
448    moni_data.zynq_power         = parse_f32(stream, pos); 
449    moni_data.p3v5_voltage       = parse_f32(stream, pos); 
450    moni_data.p3v5_current       = parse_f32(stream, pos); 
451    moni_data.p3v5_power         = parse_f32(stream, pos); 
452    moni_data.adc_dvdd_voltage   = parse_f32(stream, pos); 
453    moni_data.adc_dvdd_current   = parse_f32(stream, pos); 
454    moni_data.adc_dvdd_power     = parse_f32(stream, pos); 
455    moni_data.adc_avdd_voltage   = parse_f32(stream, pos); 
456    moni_data.adc_avdd_current   = parse_f32(stream, pos); 
457    moni_data.adc_avdd_power     = parse_f32(stream, pos); 
458    moni_data.drs_avdd_voltage   = parse_f32(stream, pos); 
459    moni_data.drs_avdd_current   = parse_f32(stream, pos); 
460    moni_data.drs_avdd_power     = parse_f32(stream, pos); 
461    moni_data.n1v5_voltage       = parse_f32(stream, pos); 
462    moni_data.n1v5_current       = parse_f32(stream, pos); 
463    moni_data.n1v5_power         = parse_f32(stream, pos); 
464    *pos += 2; // for tail
465    Ok(moni_data) 
466  }
467}
468
469#[cfg(feature = "random")]
470impl FromRandom for RBMoniData {
471    
472  fn from_random() -> RBMoniData {
473    let mut moni = RBMoniData::new();
474    let mut rng = rand::rng();
475    moni.board_id           = rng.random::<u8>(); 
476    moni.rate               = rng.random::<u16>();
477    moni.tmp_drs            = rng.random::<f32>();
478    moni.tmp_clk            = rng.random::<f32>();
479    moni.tmp_adc            = rng.random::<f32>();
480    moni.tmp_zynq           = rng.random::<f32>();
481    moni.tmp_lis3mdltr      = rng.random::<f32>();
482    moni.tmp_bm280          = rng.random::<f32>();
483    moni.pressure           = rng.random::<f32>();
484    moni.humidity           = rng.random::<f32>();
485    moni.mag_x              = rng.random::<f32>();
486    moni.mag_y              = rng.random::<f32>();
487    moni.mag_z              = rng.random::<f32>();
488    moni.lost_event_ids     = rng.random::<f32>();
489    moni.drs_dvdd_voltage   = rng.random::<f32>(); 
490    moni.drs_dvdd_current   = rng.random::<f32>();
491    moni.drs_dvdd_power     = rng.random::<f32>();
492    moni.p3v3_voltage       = rng.random::<f32>();
493    moni.p3v3_current       = rng.random::<f32>();
494    moni.p3v3_power         = rng.random::<f32>();
495    moni.zynq_voltage       = rng.random::<f32>();
496    moni.zynq_current       = rng.random::<f32>();
497    moni.zynq_power         = rng.random::<f32>();
498    moni.p3v5_voltage       = rng.random::<f32>(); 
499    moni.p3v5_current       = rng.random::<f32>();
500    moni.p3v5_power         = rng.random::<f32>();
501    moni.adc_dvdd_voltage   = rng.random::<f32>();
502    moni.adc_dvdd_current   = rng.random::<f32>();
503    moni.adc_dvdd_power     = rng.random::<f32>();
504    moni.adc_avdd_voltage   = rng.random::<f32>();
505    moni.adc_avdd_current   = rng.random::<f32>();
506    moni.adc_avdd_power     = rng.random::<f32>();
507    moni.drs_avdd_voltage   = rng.random::<f32>(); 
508    moni.drs_avdd_current   = rng.random::<f32>();
509    moni.drs_avdd_power     = rng.random::<f32>();
510    moni.n1v5_voltage       = rng.random::<f32>();
511    moni.n1v5_current       = rng.random::<f32>();
512    moni.n1v5_power         = rng.random::<f32>();
513    // don't do the tiemstamp 
514    moni.timestamp          = 0;
515    moni
516  }
517}
518
519#[cfg(feature="pybindings")]
520#[pymethods]
521impl RBMoniData {
522  
523  #[getter]
524  #[pyo3(name="mag_tot")]
525  fn get_mag_tot_py(&self) -> f32 {
526    self.get_mag_tot()
527  }
528
529  #[getter]
530  fn get_rate             (&self) -> u16 {
531    self.rate
532  }
533  
534  #[getter]
535  fn get_tmp_drs          (&self) -> f32 {
536    self.tmp_drs
537  }
538  
539  #[getter]
540  fn get_tmp_clk          (&self) -> f32 {
541    self.tmp_clk
542  }
543  
544
545  #[getter]
546  fn get_tmp_adc          (&self) -> f32 {
547    self.tmp_adc
548  }
549
550  #[getter]
551  fn get_tmp_zynq         (&self) -> f32 {
552    self.tmp_zynq
553  }
554
555  #[getter]
556  fn get_tmp_lis3mdltr    (&self) -> f32 {
557    self.tmp_lis3mdltr
558  }
559
560  #[getter]
561  fn get_tmp_bm280        (&self) -> f32 {
562    self.tmp_bm280
563  }
564  
565  #[getter]
566  fn get_pressure         (&self) -> f32 {
567    self.pressure
568  }
569
570  #[getter]
571  fn get_humidity         (&self) -> f32 {
572    self.humidity
573  }
574
575  #[getter]
576  fn get_mag_x            (&self) -> f32 {
577    self.mag_x
578  }
579  
580  #[getter]
581  fn get_mag_y            (&self) -> f32 {
582    self.mag_y
583  }
584  
585  #[getter]
586  fn get_mag_z            (&self) -> f32 {
587    self.mag_z
588  }
589  
590  #[getter]
591  fn get_drs_dvdd_voltage (&self) -> f32 { 
592    self.drs_dvdd_voltage
593  }
594
595  #[getter]
596  fn get_drs_dvdd_current (&self) -> f32 {
597    self.drs_dvdd_current
598  }
599
600  #[getter]
601  fn get_drs_dvdd_power   (&self) -> f32 {
602    self.drs_dvdd_power
603  }
604
605  #[getter]
606  fn get_p3v3_voltage     (&self) -> f32 {
607    self.p3v3_voltage
608  }
609
610  #[getter]
611  fn get_p3v3_current     (&self) -> f32 {
612    self.p3v3_current
613  }
614
615  #[getter]
616  fn get_p3v3_power       (&self) -> f32 {
617    self.p3v3_power
618  }
619
620  #[getter]
621  fn get_zynq_voltage     (&self) -> f32 {
622    self.zynq_voltage
623  }
624
625  #[getter]
626  fn get_zynq_current     (&self) -> f32 {
627    self.zynq_current
628  }
629
630  #[getter]
631  fn get_zynq_power       (&self) -> f32 {
632    self.zynq_power
633  }
634
635  #[getter]
636  fn get_p3v5_voltage     (&self) -> f32 { 
637    self.p3v5_voltage
638  }
639
640  #[getter]
641  fn get_p3v5_current     (&self) -> f32 {
642    self.p3v5_current
643  }
644
645  #[getter]
646  fn get_p3v5_power       (&self) -> f32 {
647    self.p3v5_power
648  }
649
650  #[getter]
651  fn get_adc_dvdd_voltage (&self) -> f32 {
652    self.adc_dvdd_voltage
653  }
654  
655  #[getter]
656  fn get_adc_dvdd_current (&self) -> f32 {
657    self.adc_dvdd_current
658  }
659  
660  #[getter]
661  fn get_adc_dvdd_power   (&self) -> f32 {
662    self.adc_dvdd_power
663  }
664  
665  #[getter]
666  fn get_adc_avdd_voltage (&self) -> f32 {
667    self.adc_avdd_voltage
668  }
669  
670  #[getter]
671  fn get_adc_avdd_current (&self) -> f32 {
672    self.adc_avdd_current
673  }
674  
675  #[getter]
676  fn get_adc_avdd_power   (&self) -> f32 {
677    self.adc_avdd_power
678  }
679  
680  #[getter]
681  fn get_drs_avdd_voltage (&self) -> f32 { 
682    self.drs_avdd_voltage
683  }
684  
685  #[getter]
686  fn get_drs_avdd_current (&self) -> f32 {
687    self.drs_avdd_current
688  }
689  
690  #[getter]
691  fn get_drs_avdd_power   (&self) -> f32 {
692    self.drs_avdd_power
693  }
694  
695  #[getter]
696  fn get_n1v5_voltage     (&self) -> f32 {
697    self.n1v5_voltage
698  }
699  
700  #[getter]
701  fn get_n1v5_current     (&self) -> f32 {
702    self.n1v5_current
703  }
704  
705  #[getter]
706  fn get_n1v5_power       (&self) -> f32 {
707    self.n1v5_power
708  }
709
710  #[getter]
711  fn get_timestamp        (&self) -> u64 {
712    self.timestamp
713  }
714
715  #[getter]
716  #[pyo3(name = "lost_event_ids_over_rate")]
717  pub fn get_lost_event_ids_over_rate_py(&self) -> f32 {
718    self.get_lost_event_ids_over_rate()
719  }
720}
721
722//----------------------------------------
723
724moniseries!(RBMoniDataSeries, RBMoniData);
725
726#[cfg(feature="pybindings")]
727pythonize_packable!(RBMoniData);
728
729#[cfg(feature="pybindings")]
730pythonize_monidata!(RBMoniData);
731
732//-----------------------------------
733
734#[test]
735#[cfg(feature = "random")]
736fn monidata_rbmonidata() {
737  let data = RBMoniData::from_random();
738  for k in RBMoniData::keys() {
739    assert!(data.get(k).is_some());
740  }
741  assert_eq!(data.get_board_id(), data.board_id);
742}
743
744#[test]
745#[cfg(feature="random")] 
746fn pack_rbmonidata() {
747  let data = RBMoniData::from_random();
748  for _ in 0..100 {
749    assert_eq!(data, data.pack().unpack().unwrap());
750  }
751}
752
gondola_core/monitoring/rb_moni_data.rs

gondola_core/monitoring/
rb_moni_data.rs
