| Linduino 1.3.0 Linear Technology Arduino-Compatible Demonstration Board

LT_2977FaultLog.cpp
Go to the documentation of this file.
1 /*!
2 LTC SMBus Support: API for a LTC2977 Fault Log
3
4 @verbatim
5
6 This API is shared with Linduino and RTOS code. End users should code to this
7 API to enable use of the PMBus code without modifications.
8
9 @endverbatim
10
11
12 Copyright 2018(c) Analog Devices, Inc.
13
14 All rights reserved.
15
16 Redistribution and use in source and binary forms, with or without
17 modification, are permitted provided that the following conditions are met:
18 - Redistributions of source code must retain the above copyright
19 notice, this list of conditions and the following disclaimer.
20 - Redistributions in binary form must reproduce the above copyright
21 notice, this list of conditions and the following disclaimer in
22 the documentation and/or other materials provided with the
23 distribution.
24 - Neither the name of Analog Devices, Inc. nor the names of its
25 contributors may be used to endorse or promote products derived
26 from this software without specific prior written permission.
27 - The use of this software may or may not infringe the patent rights
28 of one or more patent holders. This license does not release you
29 from the requirement that you obtain separate licenses from these
30 patent holders to use this software.
31 - Use of the software either in source or binary form, must be run
32 on or directly connected to an Analog Devices Inc. component.
33
34 THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
35 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
36 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
37 IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
38 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
39 LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR
40 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
41 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
42 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
43 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
44 */
45
46 //! @ingroup PMBus_SMBus
47 //! @{
48 //! @defgroup LT_2977FaultLog LT_2977FaultLog
49 //! @}
50
51 /*! @file
52 @ingroup LT_2977FaultLog
53 Library Header File for LT_2977FaultLog
54 */
55
56 #include <Arduino.h>
57 #include "LT_2977FaultLog.h"
58
59 #define RAW_EEPROM
60
61 LT_2977FaultLog::LT_2977FaultLog(LT_PMBus *pmbus):LT_CommandPlusFaultLog(pmbus)
62 {
63 faultLog2977 = NULL;
64
65 buffer = NULL;
66 voutPeaks = NULL;
67 chanStatuses = NULL;
68 voutDatas = NULL;
69 }
70
71
72 bool LT_2977FaultLog::FaultLogLtc2977::isValidData(void *pos, uint8_t size)
73 {
74 return (uint8_t *)pos >= (uint8_t *)this + firstValidByte && (uint8_t *)pos + (size - 1) <= (uint8_t *)this + lastValidByte;
75 }
76
77 /*
78 * Read LTC2977 fault log
79 *
80 * address: PMBUS address
81 */
82 void
83 LT_2977FaultLog::read(uint8_t address)
84 {
85 // Copy to RAM
86 pmbus_->smbus()->sendByte(address, MFR_FAULT_LOG_RESTORE);
87 // Monitor BUSY bit
88 while ((pmbus_->smbus()->readByte(address, MFR_COMMON) & (1 << 6)) == 0);
89
90 uint16_t size = sizeof(struct LT_2977FaultLog::FaultLogLtc2977);
91 uint8_t *data = (uint8_t *) malloc(size);
92 if (data == 0)
93 Serial.print(F("bad malloc."));
94 #ifdef RAW_EEPROM
95 getNvmBlock(address, 0, 128, 0xC0, data);
96 #else
97 // Read block data with log
98 pmbus_->smbus()->readBlock(address, MFR_FAULT_LOG, data, 255);
99 #endif
100
101 struct LT_2977FaultLog::FaultLogLtc2977 *log = (struct LT_2977FaultLog::FaultLogLtc2977 *)data;
102
103 log->firstValidByte = 72;
104
105 uint8_t count = log->preamble.cyclic_data_count;
106 if (count == 255)
107 log->lastValidByte = 237;
108 else
109 log->lastValidByte = 237 - (166-count);
110
111 uint8_t cycle_start = log->preamble.position_last;
112
113 log->loops = (LT_2977FaultLog::FaultLogReadLoopLtc2977 *) (log->telemetryData - 45 + cycle_start);
114
115 faultLog2977 = log;
116 }
117
118
119 void LT_2977FaultLog::release()
120 {
121 free(faultLog2977);
122 faultLog2977 = 0;
123 }
124
125 uint8_t *LT_2977FaultLog::getBinary()
126 {
127 return (uint8_t *)faultLog2977;
128 }
129
130 uint16_t LT_2977FaultLog::getBinarySize()
131 {
132 return 255;
133 }
134
135 void LT_2977FaultLog::dumpBinary(Print *printer)
136 {
137 dumpBin(printer, (uint8_t *)faultLog2977, 255);
138 }
139
140 void LT_2977FaultLog::print(Print *printer)
141 {
142 if (printer == 0)
143 printer = &Serial;
144 buffer = new char[FILE_TEXT_LINE_MAX];
145
146 printTitle(printer);
147
148 printTime(printer);
149
150 printPeaks(printer);
151
152 printAllLoops(printer);
153
154
155 delete [] buffer;
156 }
157
158
159 void LT_2977FaultLog::printTitle(Print *printer)
160 {
161 printer->print(F("LTC2977 Log Data\n"));
162 }
163
164 void LT_2977FaultLog::printTime(Print *printer)
165 {
166 uint8_t *time = (uint8_t *)&faultLog2977->preamble.shared_time;
167 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR("Fault Time 0x%02x%02x%02x%02x%02x%02x\n"), time[5], time[4], time[3], time[2], time[1], time[0]);
168 printer->print(buffer);
169 printer->print((long) getSharedTime200us(faultLog2977->preamble.shared_time));
170 printer->println(F(" Ticks (200us each)"));
171 }
172
173 void LT_2977FaultLog::printPeaks(Print *printer)
174 {
175 voutPeaks = new Peak16Words*[8];
176 chanStatuses = new ChanStatus*[8];
177
178 voutPeaks[0] = &faultLog2977->preamble.peaks.vout0_peaks;
179 voutPeaks[1] = &faultLog2977->preamble.peaks.vout1_peaks;
180 voutPeaks[2] = &faultLog2977->preamble.peaks.vout2_peaks;
181 voutPeaks[3] = &faultLog2977->preamble.peaks.vout3_peaks;
182 voutPeaks[4] = &faultLog2977->preamble.peaks.vout4_peaks;
183 voutPeaks[5] = &faultLog2977->preamble.peaks.vout5_peaks;
184 voutPeaks[6] = &faultLog2977->preamble.peaks.vout6_peaks;
185 voutPeaks[7] = &faultLog2977->preamble.peaks.vout7_peaks;
186
187 chanStatuses[0] = &faultLog2977->preamble.fault_log_status.chan_status0;
188 chanStatuses[1] = &faultLog2977->preamble.fault_log_status.chan_status1;
189 chanStatuses[2] = &faultLog2977->preamble.fault_log_status.chan_status2;
190 chanStatuses[3] = &faultLog2977->preamble.fault_log_status.chan_status3;
191 chanStatuses[4] = &faultLog2977->preamble.fault_log_status.chan_status4;
192 chanStatuses[5] = &faultLog2977->preamble.fault_log_status.chan_status5;
193 chanStatuses[6] = &faultLog2977->preamble.fault_log_status.chan_status6;
194 chanStatuses[7] = &faultLog2977->preamble.fault_log_status.chan_status7;
195
196
197 printer->println(F("\nPeak Values and Fast Status:"));
198 printer->println(F("--------"));
199
200 printFastChannel(0, printer);
201 printFastChannel(1, printer);
202
203 float vin_max, vin_min, temp_max, temp_min;
204 vin_max = math_.lin11_to_float(getLin5_11WordVal(faultLog2977->preamble.peaks.vin_peaks.peak));
205 vin_min = math_.lin11_to_float(getLin5_11WordVal(faultLog2977->preamble.peaks.vin_peaks.min));
206 printer->print(F("Vin: Min: "));
207 printer->print(vin_min, 6);
208 printer->print(F(", Peak: "));
209 printer->println(vin_max, 6);
210 printer->println();
211
212 printFastChannel(2, printer);
213 printFastChannel(3, printer);
214
215 temp_max = math_.lin11_to_float(getLin5_11WordVal(faultLog2977->preamble.peaks.temp_peaks.peak));
216 temp_min = math_.lin11_to_float(getLin5_11WordVal(faultLog2977->preamble.peaks.temp_peaks.min));
217 printer->print(F("Temp: Min: "));
218 printer->print(temp_min, 6);
219 printer->print(F(", Peak: "));
220 printer->println(temp_max, 6);
221 printer->println();
222
223 printFastChannel(4, printer);
224 printFastChannel(5, printer);
225 printFastChannel(6, printer);
226 printFastChannel(7, printer);
227
228 delete [] voutPeaks;
229 delete [] chanStatuses;
230 }
231
232 void LT_2977FaultLog::printFastChannel(uint8_t index, Print *printer)
233 {
234 float vout_peak, vout_min;
235 uint8_t status;
236 vout_peak = math_.lin16_to_float(getLin16WordVal(voutPeaks[index]->peak), 0x13);
237 vout_min = math_.lin16_to_float(getLin16WordVal(voutPeaks[index]->min), 0x13);
238 printer->print(F("Vout"));
239 printer->print(index);
240 printer->print(F(": Min: "));
241 printer->print(vout_min, 6);
242 printer->print(F(", Peak: "));
243 printer->println(vout_peak, 6);
244 printer->print(F("Fast Status"));
245 printer->println(index);
246 status = getRawByteVal(chanStatuses[index]->status_vout);
247 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" STATUS_VOUT%u: 0x%02x\n"), index, status);
248 printer->print(buffer);
249 status = getRawByteVal(chanStatuses[index]->status_mfr);
250 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" STATUS_MFR%u: 0x%02x\n"), index, status);
251 printer->print(buffer);
252 status = getRawByteVal(chanStatuses[index]->mfr_status2);
253 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" MFR_STATUS_2%u: 0x%02x\n"), index, status);
254 printer->println(buffer);
255 }
256
257 void LT_2977FaultLog::printAllLoops(Print *printer)
258 {
259 voutDatas = new VoutData*[8];
260
261 printer->println(F("Fault Log Loops Follow:"));
262 printer->println(F("(most recent data first)"));
263
264 for (int index = 0; index <= 4 && (index < 4 || faultLog2977->isValidData(&faultLog2977->loops[index])); index++)
265 {
266 printLoop(index, printer);
267 }
268
269 delete [] voutDatas;
270 }
271
272 void LT_2977FaultLog::printLoop(uint8_t index, Print *printer)
273 {
274 printer->println(F("-------"));
275 printer->print(F("Loop: "));
276 printer->println(index);
277 printer->println(F("-------"));
278
279 voutDatas[0] = &faultLog2977->loops[index].vout_data0;
280 voutDatas[1] = &faultLog2977->loops[index].vout_data1;
281 voutDatas[2] = &faultLog2977->loops[index].vout_data2;
282 voutDatas[3] = &faultLog2977->loops[index].vout_data3;
283 voutDatas[4] = &faultLog2977->loops[index].vout_data4;
284 voutDatas[5] = &faultLog2977->loops[index].vout_data5;
285 voutDatas[6] = &faultLog2977->loops[index].vout_data6;
286 voutDatas[7] = &faultLog2977->loops[index].vout_data7;
287
288 uint8_t stat;
289 float val;
290
291 printLoopChannel(7, printer);
292 printLoopChannel(6, printer);
293 printLoopChannel(5, printer);
294 printLoopChannel(4, printer);
295
296 if (faultLog2977->isValidData(&faultLog2977->loops[index].temp_data.status_temp, 1))
297 {
298 printer->println(F("TEMPERATURE:"));
299 stat = getRawByteVal(faultLog2977->loops[index].temp_data.status_temp);
300 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" STATUS_TEMP: 0x%02x\n"), stat);
301 printer->print(buffer);
302 }
303 if (faultLog2977->isValidData(&faultLog2977->loops[index].temp_data.temp))
304 {
305 val = math_.lin11_to_float(getLin5_11WordReverseVal(faultLog2977->loops[index].temp_data.temp));
306 printer->print(F(" READ_TEMP: "));
307 printer->print(val, 6);
308 printer->println(F(" C"));
309 }
310
311 printLoopChannel(3, printer);
312 printLoopChannel(2, printer);
313
314 if (faultLog2977->isValidData(&faultLog2977->loops[index].vin_data.status_vin, 1))
315 {
316 printer->println(F("VIN:"));
317 stat = getRawByteVal(faultLog2977->loops[index].vin_data.status_vin);
318 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" STATUS_INPUT: 0x%02x\n"), stat);
319 printer->print(buffer);
320 }
321 if (faultLog2977->isValidData(&faultLog2977->loops[index].vin_data.vin))
322 {
323 val = math_.lin11_to_float(getLin5_11WordReverseVal(faultLog2977->loops[index].vin_data.vin));
324 printer->print(F(" READ_VIN: "));
325 printer->print(val, 6);
326 printer->println(F(" V"));
327 }
328
329 printLoopChannel(1, printer);
330 printLoopChannel(0, printer);
331 }
332
333 void LT_2977FaultLog::printLoopChannel(uint8_t index, Print *printer)
334 {
335 uint8_t stat;
336 float val;
337
338 if (faultLog2977->isValidData(&voutDatas[index]->mfr_status2, 1))
339 {
340 printer->print(F("CHAN"));
341 printer->print(index);
342 printer->println(F(":"));
343 stat = getRawByteVal(voutDatas[index]->mfr_status2);
344 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" MFR_STATUS_2: 0x%02x\n"), stat);
345 printer->print(buffer);
346 }
347 if (faultLog2977->isValidData(&voutDatas[index]->status_mfr, 1))
348 {
349 stat = getRawByteVal(voutDatas[index]->status_mfr);
350 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" STATUS_MFR: 0x%02x\n"), stat);
351 printer->print(buffer);
352 }
353 if (faultLog2977->isValidData(&voutDatas[index]->status_vout, 1))
354 {
355 stat = getRawByteVal(voutDatas[index]->status_vout);
356 snprintf_P(buffer, FILE_TEXT_LINE_MAX, PSTR(" STATUS_VOUT: 0x%02x\n"), stat);
357 printer->print(buffer);
358 }
359 if (faultLog2977->isValidData(&voutDatas[index]->read_vout))
360 {
361 val = math_.lin16_to_float(getLin16WordReverseVal(voutDatas[index]->read_vout), 0x13);
362 printer->print(F(" READ_VOUT: "));
363 printer->print(val, 6);
364 printer->println(F(" V"));
365 }
366 }
367
368
369
LT_2977FaultLog::FaultLogReadLoopLtc2977::temp_data
struct TempData temp_data
Definition: LT_2977FaultLog.h:173
LT_2977FaultLog::FaultLogPeaksLtc2977::vout5_peaks
struct Peak16Words vout5_peaks
Definition: LT_2977FaultLog.h:138
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status6
struct ChanStatus chan_status6
Definition: LT_2977FaultLog.h:152
LT_2977FaultLog::FaultLogPreambleLtc2977::peaks
struct FaultLogPeaksLtc2977 peaks
Definition: LT_2977FaultLog.h:162
LT_2977FaultLog::FaultLogLtc2977
Definition: LT_2977FaultLog.h:181
LT_FaultLog::getLin5_11WordReverseVal
uint16_t getLin5_11WordReverseVal(Lin5_11WordReverse value)
Definition: LT_FaultLog.cpp:291
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status3
struct ChanStatus chan_status3
Definition: LT_2977FaultLog.h:149
LT_2977FaultLog::FaultLogLtc2977::firstValidByte
uint8_t firstValidByte
Definition: LT_2977FaultLog.h:187
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data0
struct VoutData vout_data0
Definition: LT_2977FaultLog.h:178
LT_FaultLog::dumpBin
void dumpBin(Print *printer, uint8_t *log, uint8_t size)
Definition: LT_FaultLog.cpp:217
MFR_FAULT_LOG
#define MFR_FAULT_LOG
Definition: LT_PMBus.h:140
LT_2977FaultLog::VoutData::read_vout
struct Lin16WordReverse read_vout
Definition: LT_2977FaultLog.h:85
LT_PMBusMath::lin16_to_float
float lin16_to_float(lin16_t lin16_mant, lin16m_t vout_mode)
Definition: LT_PMBusMath.cpp:435
status
String status(void)
Returns a descriptive string based on status of pins.
Definition: DC2364A.ino:217
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status1
struct ChanStatus chan_status1
Definition: LT_2977FaultLog.h:147
LT_2977FaultLog.h
LTC SMBus Support: Implementation for a LTC2977 Fault Log.
LT_SMBus::sendByte
virtual void sendByte(uint8_t address, uint8_t command)=0
SMBus send byte command.
LT_2977FaultLog::FaultLogLtc2977::lastValidByte
uint8_t lastValidByte
Definition: LT_2977FaultLog.h:188
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status5
struct ChanStatus chan_status5
Definition: LT_2977FaultLog.h:151
LT_FaultLog::getLin5_11WordVal
uint16_t getLin5_11WordVal(Lin5_11Word value)
Definition: LT_FaultLog.cpp:285
LT_2977FaultLog::dumpBinary
void dumpBinary(Print *printer=0)
Dumps binary of the fault log to a Print inheriting object, or Serial if none specified.
Definition: LT_2977FaultLog.cpp:135
LT_2977FaultLog::FaultLogReadLoopLtc2977::vin_data
struct VinData vin_data
Definition: LT_2977FaultLog.h:176
LT_2977FaultLog::FaultLogLtc2977::preamble
struct FaultLogPreambleLtc2977 preamble
Definition: LT_2977FaultLog.h:184
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status7
struct ChanStatus chan_status7
Definition: LT_2977FaultLog.h:153
LT_CommandPlusFaultLog::getNvmBlock
void getNvmBlock(uint8_t address, uint16_t offset, uint16_t numWords, uint8_t command, uint8_t *data)
Definition: LT_CommandPlusFaultLog.h:66
LT_2977FaultLog::TempData::temp
struct Lin5_11WordReverse temp
Definition: LT_2977FaultLog.h:98
math_
LT_PMBusMath math_
Definition: LT_PMBusMath.cpp:460
pmbus
static LT_PMBus * pmbus
Definition: DC2875A.ino:82
LT_PMBusMath::lin11_to_float
float lin11_to_float(lin11_t xin)
Definition: LT_PMBusMath.cpp:427
LT_2977FaultLog::VoutData::mfr_status2
struct RawByte mfr_status2
Definition: LT_2977FaultLog.h:82
FILE_TEXT_LINE_MAX
#define FILE_TEXT_LINE_MAX
Definition: LT_FaultLog.h:60
min
#define min(a, b)
Definition: Adafruit_GFX.cpp:66
LT_FaultLog::pmbus_
LT_PMBus * pmbus_
Definition: LT_FaultLog.h:129
LT_2977FaultLog::read
void read(uint8_t address)
Reads the fault log from the specified address, reserves memory to hold the data. ...
Definition: LT_2977FaultLog.cpp:83
address
static uint8_t address
Definition: DC2091A.ino:83
data
union LT_union_int32_4bytes data
Definition: DC2094A.ino:138
pos
static int16_t pos
Definition: Precision_Voltage_Source.ino:73
LT_2977FaultLog::FaultLogLtc2977::isValidData
bool isValidData(void *pos, uint8_t size=2)
Definition: LT_2977FaultLog.cpp:72
LT_FaultLog::getLin16WordVal
uint16_t getLin16WordVal(Lin16Word value)
Definition: LT_FaultLog.cpp:297
LT_2977FaultLog::FaultLogPreambleLtc2977::fault_log_status
struct FaultLogReadStatusLtc2977 fault_log_status
Definition: LT_2977FaultLog.h:163
LT_2977FaultLog::FaultLogLtc2977::telemetryData
uint8_t telemetryData[208]
Definition: LT_2977FaultLog.h:185
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data2
struct VoutData vout_data2
Definition: LT_2977FaultLog.h:175
LT_2977FaultLog::FaultLogPeaksLtc2977::temp_peaks
struct Peak5_11Words temp_peaks
Definition: LT_2977FaultLog.h:136
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status0
struct ChanStatus chan_status0
Definition: LT_2977FaultLog.h:146
LT_2977FaultLog::FaultLogPreambleLtc2977::shared_time
struct LT_FaultLog::FaultLogTimeStamp shared_time
Definition: LT_2977FaultLog.h:161
LT_2977FaultLog::getBinary
uint8_t * getBinary()
Get binary of the fault log or NULL if no log.
Definition: LT_2977FaultLog.cpp:125
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data4
struct VoutData vout_data4
Definition: LT_2977FaultLog.h:172
LT_2977FaultLog::FaultLogPreambleLtc2977::position_last
uint8_t position_last
Definition: LT_2977FaultLog.h:159
LT_SMBus::readByte
virtual uint8_t readByte(uint8_t address, uint8_t command)=0
SMBus read byte command.
LT_2977FaultLog::TempData::status_temp
struct RawByte status_temp
Definition: LT_2977FaultLog.h:97
LT_2977FaultLog::FaultLogPeaksLtc2977::vout0_peaks
struct Peak16Words vout0_peaks
Definition: LT_2977FaultLog.h:131
LT_2977FaultLog::FaultLogPeaksLtc2977::vout3_peaks
struct Peak16Words vout3_peaks
Definition: LT_2977FaultLog.h:135
LT_2977FaultLog::FaultLogReadLoopLtc2977
Definition: LT_2977FaultLog.h:166
LT_2977FaultLog::FaultLogPreambleLtc2977::cyclic_data_count
uint8_t cyclic_data_count
Definition: LT_2977FaultLog.h:160
LT_2977FaultLog::FaultLogPeaksLtc2977::vout7_peaks
struct Peak16Words vout7_peaks
Definition: LT_2977FaultLog.h:140
MFR_COMMON
#define MFR_COMMON
Definition: LT_PMBus.h:141
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data1
struct VoutData vout_data1
Definition: LT_2977FaultLog.h:177
LT_PMBus::smbus
LT_SMBus * smbus()
Definition: LT_PMBus.h:401
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status2
struct ChanStatus chan_status2
Definition: LT_2977FaultLog.h:148
LT_2977FaultLog::ChanStatus
Definition: LT_2977FaultLog.h:71
LT_FaultLog::getSharedTime200us
uint64_t getSharedTime200us(FaultLogTimeStamp time_stamp)
Definition: LT_FaultLog.cpp:247
LT_2977FaultLog::FaultLogLtc2977::loops
struct FaultLogReadLoopLtc2977 * loops
Definition: LT_2977FaultLog.h:186
LT_2977FaultLog::FaultLogReadStatusLtc2977::chan_status4
struct ChanStatus chan_status4
Definition: LT_2977FaultLog.h:150
LT_2977FaultLog::print
void print(Print *printer=0)
Pretty prints this part&#39;s fault log to a Print inheriting object, or Serial if none specified...
Definition: LT_2977FaultLog.cpp:140
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data5
struct VoutData vout_data5
Definition: LT_2977FaultLog.h:171
index
static int index
Definition: device_logger.ino:91
LT_2977FaultLog::VoutData
Definition: LT_2977FaultLog.h:79
LT_2977FaultLog::FaultLogPeaksLtc2977::vin_peaks
struct Peak5_11Words vin_peaks
Definition: LT_2977FaultLog.h:133
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data7
struct VoutData vout_data7
Definition: LT_2977FaultLog.h:169
LT_SMBus::readBlock
virtual uint8_t readBlock(uint8_t address, uint8_t command, uint8_t *block, uint16_t block_size)=0
SMBus read block command.
LT_2977FaultLog::LT_2977FaultLog
LT_2977FaultLog(LT_PMBus *pmbus)
Constructor.
Definition: LT_2977FaultLog.cpp:61
LT_2977FaultLog::VoutData::status_mfr
struct RawByte status_mfr
Definition: LT_2977FaultLog.h:83
LT_2977FaultLog::FaultLogPeaksLtc2977::vout2_peaks
struct Peak16Words vout2_peaks
Definition: LT_2977FaultLog.h:134
LT_2977FaultLog::FaultLogPeaksLtc2977::vout6_peaks
struct Peak16Words vout6_peaks
Definition: LT_2977FaultLog.h:139
LT_2977FaultLog::VinData::vin
struct Lin5_11WordReverse vin
Definition: LT_2977FaultLog.h:111
LT_FaultLog::getRawByteVal
uint8_t getRawByteVal(RawByte value)
Definition: LT_FaultLog.cpp:267
LT_2977FaultLog::VinData::status_vin
struct RawByte status_vin
Definition: LT_2977FaultLog.h:110
LT_FaultLog::getLin16WordReverseVal
uint16_t getLin16WordReverseVal(Lin16WordReverse value)
Definition: LT_FaultLog.cpp:303
LT_2977FaultLog::release
void release()
Frees the memory reserved for the fault log.
Definition: LT_2977FaultLog.cpp:119
LT_2977FaultLog::getBinarySize
uint16_t getBinarySize()
Get size of binary data.
Definition: LT_2977FaultLog.cpp:130
MFR_FAULT_LOG_RESTORE
#define MFR_FAULT_LOG_RESTORE
Definition: LT_PMBus.h:136
LT_2977FaultLog::Peak16Words
Definition: LT_2977FaultLog.h:114
LT_CommandPlusFaultLog
Definition: LT_CommandPlusFaultLog.h:57
LT_2977FaultLog::VoutData::status_vout
struct RawByte status_vout
Definition: LT_2977FaultLog.h:84
LT_2977FaultLog::FaultLogPeaksLtc2977::vout1_peaks
struct Peak16Words vout1_peaks
Definition: LT_2977FaultLog.h:132
LT_2977FaultLog::faultLog2977
FaultLogLtc2977 * faultLog2977
Definition: LT_2977FaultLog.h:196
LT_2977FaultLog::FaultLogPeaksLtc2977::vout4_peaks
struct Peak16Words vout4_peaks
Definition: LT_2977FaultLog.h:137
LT_2977FaultLog::Peak5_11Words::peak
struct Lin5_11Word peak
Definition: LT_2977FaultLog.h:124
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data3
struct VoutData vout_data3
Definition: LT_2977FaultLog.h:174
LT_2977FaultLog::Peak5_11Words::min
struct Lin5_11Word min
Definition: LT_2977FaultLog.h:125
LT_2977FaultLog::FaultLogReadLoopLtc2977::vout_data6
struct VoutData vout_data6
Definition: LT_2977FaultLog.h:170
LT_PMBus
PMBus communication.
Definition: LT_PMBus.h:370