gondola_core/packets/
tracker.rs

1// This file is part of gaps-online-software and published 
2// under the GPLv3 license
3
4use crate::prelude::*;
5
6#[cfg_attr(feature="pybindings", pyclass)]
7pub struct TrackerEventIDEchoPacket {
8  pub telemetry_header : TelemetryPacketHeader,
9  pub tracker_header   : TrackerHeader,
10  pub temp             : [u16;12],
11  pub event_id         : u32,
12  pub event_id_errors  : u16,
13}
14
15impl TrackerEventIDEchoPacket {
16  pub fn new() -> Self {
17    Self {
18      telemetry_header : TelemetryPacketHeader::new(),
19      tracker_header   : TrackerHeader::new(),
20      temp             : [0;12],
21      event_id         : 0,
22      event_id_errors  : 0,
23    }
24  }
25}
26
27impl fmt::Display for TrackerEventIDEchoPacket {
28  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
29    let mut repr = String::from("<TrackerEventIDEchoPacket");
30    repr    += &(format!("\n {}", self.telemetry_header));
31    repr    += &(format!("\n {}", self.tracker_header));
32    repr    += "\n*** TEMP ***";
33    repr    += &(format!("\n {:?}>", self.temp));
34    write!(f, "{}", repr)
35  }
36}
37
38impl Serialization for TrackerEventIDEchoPacket {
39
40  fn from_bytestream(stream: &Vec<u8>,
41                         pos: &mut usize)
42    -> Result<Self, SerializationError> {
43    let mut tp          = TrackerEventIDEchoPacket::new();
44    tp.tracker_header   = TrackerHeader::from_bytestream(stream, pos)?;
45    if tp.tracker_header.packet_id != 0x03 {
46      error!("This is not a TrackerEventIDEchoPacket, but has packet_id {} instead!", tp.tracker_header.packet_id);
47      return Err(SerializationError::IncorrectPacketType);
48    }
49    if stream.len() == *pos as usize {
50      error!("Packet contains only header!");
51      return Ok(tp);
52    }
53    //if stream.len() - *pos < (36*3 + 1) {
54    //  return Err(SerializationError::StreamTooShort);
55    //}
56    tp.event_id        = parse_u32(stream, pos);
57    tp.event_id_errors = parse_u16(stream, pos);
58    Ok(tp)
59  }
60}
61
62#[cfg(feature="pybindings")]
63#[pymethods]
64impl TrackerEventIDEchoPacket {
65
66
67  #[getter]
68  fn get_temp(&self) -> [u16;12] {
69    self.temp
70  }
71}
72
73#[cfg(feature="pybindings")]
74pythonize_telemetry!(TrackerEventIDEchoPacket);
75
76//---------------------------------------------------
77
78#[cfg_attr(feature="pybindings",pyclass)]
79pub struct TrackerTempLeakPacket {
80  pub telemetry_header : TelemetryPacketHeader,
81  pub tracker_header   : TrackerHeader,
82  pub row_offset       : u8,
83  pub templeak         : [[u32;6];6],
84  pub seu              : [[u32;6];6]
85}
86
87impl fmt::Display for TrackerTempLeakPacket {
88  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
89    let mut repr = String::from("<TrackerTempLeakPacket");
90    repr    += &(format!("\n {}", self.telemetry_header));
91    repr    += &(format!("\n {}", self.tracker_header));
92    repr    += &(format!("\n ROW OFFSET {}", self.row_offset));
93    repr    += "\n*** TEMPLEAK ***";
94    for k in 0..6 {
95      repr  += &(format!("\n {:?}", self.templeak[k]));
96    }
97    repr    += "\n*** SEU ***";
98    for k in 0..6 {
99      repr  += &(format!("\n {:?}", self.seu[k]));
100    }
101    repr    += ">";
102    write!(f, "{}", repr)
103  }
104}
105
106impl TrackerTempLeakPacket {
107  pub fn new() -> Self {
108    Self {
109      telemetry_header : TelemetryPacketHeader::new(),
110      tracker_header   : TrackerHeader::new(),
111      row_offset       : 0,
112      templeak         : [[0;6];6],
113      seu              : [[0;6];6]
114    }
115  }
116}
117
118impl Serialization for TrackerTempLeakPacket { 
119  fn from_bytestream(stream: &Vec<u8>,
120                     pos: &mut usize)
121    -> Result<Self, SerializationError> {
122    let mut tp          = TrackerTempLeakPacket::new();
123    tp.tracker_header   = TrackerHeader::from_bytestream(stream, pos)?;
124    if stream.len() == *pos as usize {
125      error!("Packet contains only header!");
126      return Ok(tp);
127    }
128    if stream.len() - *pos < (36*3 + 1) {
129      return Err(SerializationError::StreamTooShort);
130    }
131    let row_info = parse_u8(stream, pos);
132    tp.row_offset = row_info & 0x7;
133    for row in 0..6 {
134      for module in 0..6 {
135        let b0 = parse_u8(stream, pos) as u32;
136        let b1 = parse_u8(stream, pos) as u32;
137        let b2 = parse_u8(stream, pos) as u32;
138        let seu_ : u32 = b2 >> 1;
139        let mut templeak_ : u32 = (b2 << 10) | (b1 << 2)  | (b0 >> 6);
140        templeak_ &= 0x7ff;
141        tp.templeak[row][module] = templeak_;
142        tp.seu[row][module] = seu_;
143      }
144    }
145    Ok(tp)
146  }
147}
148
149#[cfg(feature="pybindings")]
150#[pymethods]
151impl TrackerTempLeakPacket {
152
153  #[getter]
154  fn get_row_offset(&self) -> u8 {
155    self.row_offset
156  }
157  
158  #[getter]
159  fn temp_leak(&self) -> [[u32;6];6] {
160    self.templeak
161  }
162  
163  #[getter]
164  fn get_seu(&self) -> [[u32;6];6] {
165    self.seu
166  }
167}
168
169#[cfg(feature="pybindings")]
170pythonize_telemetry!(TrackerTempLeakPacket);
171
172//---------------------------------------------------
173
174#[cfg_attr(feature="pybindings", pyclass)]
175pub struct TrackerDAQTempPacket {
176  pub telemetry_header : TelemetryPacketHeader,
177  pub tracker_header   : TrackerHeader,
178  pub rom_id           : [u64;256],
179  pub temp             : [u16;256]
180}
181
182impl fmt::Display for TrackerDAQTempPacket {
183  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
184    let mut repr = String::from("<TrackerDAQTempPacket");
185    repr    += &(format!("\n {}", self.telemetry_header));
186    repr    += &(format!("\n {}", self.tracker_header));
187    repr    += "\n*** ROM ID ***";
188    repr  += &(format!("\n {:?}", self.rom_id));
189    repr    += "\n*** TEMP ***";
190    repr  += &(format!("\n {:?}>", self.temp));
191    write!(f, "{}", repr)
192  }
193}
194
195impl TrackerDAQTempPacket {
196  pub fn new() -> Self {
197    Self {
198      telemetry_header : TelemetryPacketHeader::new(),
199      tracker_header   : TrackerHeader::new(),
200      rom_id           : [0;256],
201      temp             : [0;256]
202    }
203  }
204}
205
206impl Serialization for TrackerDAQTempPacket {
207  fn from_bytestream(stream: &Vec<u8>,
208                     pos: &mut usize)
209    -> Result<Self, SerializationError> {
210    let mut tp          = TrackerDAQTempPacket::new();
211    tp.tracker_header   = TrackerHeader::from_bytestream(stream, pos)?;
212    if tp.tracker_header.packet_id != 0x09 {
213      error!("This is not a TrackerDAQTempPacket, but has packet_id {} instead!", tp.tracker_header.packet_id);
214      return Err(SerializationError::IncorrectPacketType);
215    }
216    debug!("tracker header {}", tp.tracker_header);
217    if stream.len() == *pos as usize {
218      error!("Packet contains only header!");
219      return Ok(tp);
220    }
221    //if stream.len() - *pos < (36*3 + 1) {
222    //  return Err(SerializationError::StreamTooShort);
223    //}
224    // this is hack, since the TreckerHeader in this packet does not have a 
225    // version (-> Alex) 
226    *pos -= 1;
227    let dummy64 = 0u64;
228    let dummy16 = 0u16;
229    error!("{}", tp.tracker_header);
230    error!("Expected of the packet {}", (tp.tracker_header.length as usize)/2);
231    for k in 0..256usize {
232      if k < (tp.tracker_header.length as usize)/2 {
233        tp.rom_id[k] = parse_u64(stream, pos);
234        tp.temp[k]   = parse_u16(stream, pos);
235      } else {
236        tp.rom_id[k] = dummy64;
237        tp.temp[k]   = dummy16;
238      }
239    }
240    Ok(tp)
241  }
242}
243
244//---------------------------------------------------
245
246#[cfg(feature="pybindings")]
247#[pymethods]
248impl TrackerDAQTempPacket {
249  
250  #[getter]
251  fn get_rom_id(&self) -> [u64;256] {
252    self.rom_id
253  }
254  
255  #[getter]
256  fn get_temp(&self) -> [u16;256] {
257    self.temp
258  }
259
260}
261
262#[cfg(feature="pybindings")]
263pythonize_telemetry!(TrackerDAQTempPacket);
264
265//---------------------------------------------------
266
267#[cfg_attr(feature="pybindings", pyclass)]
268pub struct TrackerDAQHSKPacket {
269  pub telemetry_header : TelemetryPacketHeader,
270  pub tracker_header   : TrackerHeader,
271  pub temp             : [u16;12],
272}
273
274impl fmt::Display for TrackerDAQHSKPacket {
275  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
276    let mut repr = String::from("<TrackerDAQHSKPacket");
277    repr    += &(format!("\n {}", self.telemetry_header));
278    repr    += &(format!("\n {}", self.tracker_header));
279    repr    += "\n*** TEMP ***";
280    repr    += &(format!("\n {:?}>", self.temp));
281    write!(f, "{}", repr)
282  }
283}
284
285impl TrackerDAQHSKPacket {
286  pub fn new() -> Self {
287    Self {
288      telemetry_header : TelemetryPacketHeader::new(),
289      tracker_header   : TrackerHeader::new(),
290      temp             : [0;12]
291    }
292  }
293}
294
295impl Serialization for TrackerDAQHSKPacket {
296  fn from_bytestream(stream: &Vec<u8>,
297                     pos: &mut usize)
298    -> Result<Self, SerializationError> {
299    let mut tp          = TrackerDAQHSKPacket::new();
300    tp.tracker_header   = TrackerHeader::from_bytestream(stream, pos)?;
301    if tp.tracker_header.packet_id != 0xff {
302      error!("This is not a TrackerDAQHSKPacket, but has packet_id {} instead!", tp.tracker_header.packet_id);
303      return Err(SerializationError::IncorrectPacketType);
304    }
305    if stream.len() == *pos as usize {
306      error!("Packet contains only header!");
307      return Ok(tp);
308    }
309    //if stream.len() - *pos < (36*3 + 1) {
310    //  return Err(SerializationError::StreamTooShort);
311    //}
312    // this is hack, since the TreckerHeader in this packet does not have a 
313    // version (-> Alex) 
314    *pos += 193; // skip a bunch of other stuff right now (Alex)
315    for k in 0..12usize {
316      tp.temp[k]   = parse_u16(stream, pos);
317    }
318    Ok(tp)
319  }
320}
321
322//---------------------------------------------------
323
324#[cfg(feature="pybindings")]
325#[pymethods]
326impl TrackerDAQHSKPacket {
327  
328  #[getter]
329  fn get_temp(&self) -> [u16;12] {
330    self.temp
331  }
332}
333
334#[cfg(feature="pybindings")]
335pythonize_telemetry!(TrackerDAQHSKPacket);
336