1use 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 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#[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#[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 *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#[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#[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 *pos += 193; for k in 0..12usize {
316 tp.temp[k] = parse_u16(stream, pos);
317 }
318 Ok(tp)
319 }
320}
321
322#[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