chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 10:40:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into test-dataflow

Browse Source
This commit is contained in:
Phil Olynyk 2020-08-08 14:22:16 -04:00
commit a89b5f8cdd
3 changed files with 190 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Htmldocs/release_notes.html
View File

@ -14,6 +14,9 @@
<ul>
<li>[new] Additional Philips Respironics devices tested and fully supported:
<ul>
<li>REMstar Plus (System One 60 Series) (261CA)</li>
<li>REMstar Pro (System One 60 Series) (462P)</li>
<li>DreamStation CPAP Pro (400X120)</li>
<li>DreamStation BiPAP autoSV (900X150)</li>
</ul>
<li>[new] OSCAR checks automatically for new releases.</li>

207
oscar/SleepLib/loader_plugins/prs1_loader.cpp
View File

@ -259,8 +259,10 @@ static const PRS1TestedModel s_PRS1TestedModels[] = {
{ "551P", 0, 2, "REMstar Auto (System One)" },
{ "750P", 0, 2, "BiPAP Auto (System One)" },
{ "261CA", 0, 4, "REMstar Plus (System One 60 Series)" }, // (brick)
{ "460P", 0, 4, "REMstar Pro (System One 60 Series)" },
{ "461P", 0, 4, "REMstar Pro (System One 60 Series)" },
{ "462P", 0, 4, "REMstar Pro (System One 60 Series)" },
{ "461CA", 0, 4, "REMstar Pro (System One 60 Series)" },
{ "560P", 0, 4, "REMstar Auto (System One 60 Series)" },
{ "560PBT", 0, 4, "REMstar Auto (System One 60 Series)" },
@ -272,6 +274,7 @@ static const PRS1TestedModel s_PRS1TestedModels[] = {
{ "200X110", 0, 6, "DreamStation CPAP" }, // (brick)
{ "400G110", 0, 6, "DreamStation Go" },
{ "400X110", 0, 6, "DreamStation CPAP Pro" },
{ "400X120", 0, 6, "DreamStation CPAP Pro" },
{ "400X130", 0, 6, "DreamStation CPAP Pro" },
{ "400X150", 0, 6, "DreamStation CPAP Pro" },
{ "500X110", 0, 6, "DreamStation Auto CPAP" },
@ -318,7 +321,7 @@ PRS1ModelInfo::PRS1ModelInfo()
m_modelNames[model.model] = model.name;
}
m_bricks = { "251P", "200X110" };
m_bricks = { "251P", "261CA", "200X110" };
}
bool PRS1ModelInfo::IsSupported(int family, int familyVersion) const
@ -4311,8 +4314,7 @@ bool PRS1Import::ImportCompliance()
session->settings[PRS1_MaskResistLock] = (bool) e->m_value;
break;
case PRS1_SETTING_MASK_RESIST_SETTING:
// Don't bother importing these for bricks, because they're always locked off.
CHECK_VALUE(e->m_value, 0);
session->settings[PRS1_MaskResistSet] = e->m_value;
break;
case PRS1_SETTING_HOSE_DIAMETER:
session->settings[PRS1_HoseDiam] = e->m_value;
@ -4358,16 +4360,20 @@ bool PRS1DataChunk::ParseCompliance(void)
{
switch (this->family) {
case 0:
if (this->familyVersion == 6) {
return this->ParseComplianceF0V6();
} else if (this->familyVersion == 2 || this->familyVersion == 3) {
switch (this->familyVersion) {
case 2:
case 3:
return this->ParseComplianceF0V23();
case 4:
return this->ParseComplianceF0V4();
case 6:
return this->ParseComplianceF0V6();
}
default:
;
}
qWarning() << "unexpected family" << this->family << "familyVersion" << this->familyVersion;
qWarning() << "unexpected compliance family" << this->family << "familyVersion" << this->familyVersion;
return false;
}
@ -4392,7 +4398,7 @@ bool PRS1DataChunk::ParseComplianceF0V23(void)
int pos = 0;
int code, size, delta;
int tt = 0;
do {
while (ok && pos < chunk_size) {
code = data[pos++];
// There is no hblock prior to F0V6.
size = 0;
@ -4421,7 +4427,7 @@ bool PRS1DataChunk::ParseComplianceF0V23(void)
} else {
if (delta % 60) UNEXPECTED_VALUE(delta, "even minutes"); // mask-off events seem to be whole minutes?
}
tt += data[pos] | (data[pos+1] << 8);
tt += delta;
this->AddEvent(new PRS1ParsedSliceEvent(tt, MaskOn));
// no per-slice humidifer settings as in F0V6
break;
@ -4436,11 +4442,8 @@ bool PRS1DataChunk::ParseComplianceF0V23(void)
// also seems to be a trailing 01 00 81 after the slices?
CHECK_VALUES(data[pos+2], 1, 0); // usually 1, occasionally 0, no visible difference in report
//CHECK_VALUE(data[pos+3], 0); // sometimes 1, 2, or 5, no visible difference in report
//CHECK_VALUES(data[pos+4], 0x81, 0x80); // seems to be humidifier setting at end of session
if (data[pos+4] && (((data[pos+4] & 0x80) == 0) || (data[pos+4] & 0x07) > 5)) {
UNEXPECTED_VALUE(data[pos+4], "valid humidifier setting");
}
//CHECK_VALUE(data[pos+3], 0); // sometimes 1, 2, or 5, no visible difference in report, maybe ramp?
ParseHumidifierSetting50Series(data[pos+4]);
break;
default:
UNEXPECTED_VALUE(code, "known slice code");
@ -4448,7 +4451,7 @@ bool PRS1DataChunk::ParseComplianceF0V23(void)
break;
}
pos += size;
} while (ok && pos < chunk_size);
}
if (ok && pos != chunk_size) {
qWarning() << this->sessionid << (this->size() - pos) << "trailing bytes";
@ -4478,7 +4481,7 @@ bool PRS1DataChunk::ParseSummaryF0V23()
bool ok = true;
int pos = 0;
int code, size;
int code, size, delta;
int tt = 0;
while (ok && pos < chunk_size) {
code = data[pos++];
@ -4518,7 +4521,15 @@ bool PRS1DataChunk::ParseSummaryF0V23()
//}
break;
case 2: // Mask On
tt += data[pos] | (data[pos+1] << 8);
delta = data[pos] | (data[pos+1] << 8);
if (tt == 0) {
if (delta) {
CHECK_VALUES(delta, 1, 59); // we've seen the 550P start its first mask-on at these time deltas
}
} else {
if (delta % 60) UNEXPECTED_VALUE(delta, "even minutes"); // mask-off events seem to be whole minutes?
}
tt += delta;
this->AddEvent(new PRS1ParsedSliceEvent(tt, MaskOn));
// no per-slice humidifer settings as in F0V6
break;
@ -4755,8 +4766,7 @@ bool PRS1DataChunk::ParseSettingsF0V4(const unsigned char* data, int /*size*/)
this->ParseHumidifierSetting60Series(data[0x0b], data[0x0c], true);
int resist_level = (data[0x0d] >> 3) & 7; // 0x18 resist=3, 0x11 resist=2
CHECK_VALUE(data[0x0d] & 0x20, 0); // never seen, but would clarify whether above mask is correct
int resist_level = (data[0x0d] >> 3) & 7; // 0x18 resist=3, 0x11 resist=2, 0x28 resist=5
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_MASK_RESIST_LOCK, (data[0x0d] & 0x40) != 0));
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_MASK_RESIST_SETTING, resist_level));
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_HOSE_DIAMETER, (data[0x0d] & 0x01) ? 15 : 22));
@ -4771,6 +4781,7 @@ bool PRS1DataChunk::ParseSettingsF0V4(const unsigned char* data, int /*size*/)
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_SHOW_AHI, (data[0x0f] & 0x02) != 0));
CHECK_VALUE(data[0x0f] & (0xA0 | 0x08), 0);
//CHECK_VALUE(data[0x0f] & 0x01, 0); // TODO: What is bit 1? It's sometimes set.
// TODO: Where is altitude compensation set? We've seen it on 261CA.
CHECK_VALUE(data[0x10], 0);
if (cpapmode == PRS1_MODE_AUTOTRIAL) {
@ -4945,6 +4956,156 @@ void PRS1DataChunk::ParseHumidifierSetting60Series(unsigned char humid1, unsigne
}
bool PRS1DataChunk::ParseComplianceF0V4(void)
{
if (this->family != 0 || (this->familyVersion != 4)) {
qWarning() << "ParseComplianceF0V4 called with family" << this->family << "familyVersion" << this->familyVersion;
return false;
}
const unsigned char * data = (unsigned char *)this->m_data.constData();
int chunk_size = this->m_data.size();
static const int minimum_sizes[] = { 0x18, 7, 4, 2, 0, 0, 0, 4, 0 };
static const int ncodes = sizeof(minimum_sizes) / sizeof(int);
// NOTE: These are fixed sizes, but are called minimum to more closely match the F0V6 parser.
bool ok = true;
int pos = 0;
int code, size;
int tt = 0;
while (ok && pos < chunk_size) {
code = data[pos++];
// There is no hblock prior to F0V6.
size = 0;
if (code < ncodes) {
// make sure the handlers below don't go past the end of the buffer
size = minimum_sizes[code];
} // else if it's past ncodes, we'll log its information below (rather than handle it)
if (pos + size > chunk_size) {
qWarning() << this->sessionid << "slice" << code << "@" << pos << "longer than remaining chunk";
ok = false;
break;
}
switch (code) {
case 0: // Equipment On
CHECK_VALUE(pos, 1); // Always first
CHECK_VALUES(data[pos], 1, 3);
// F0V4 doesn't have a separate settings record like F0V6 does, the settings just follow the EquipmentOn data.
ok = ParseSettingsF0V4(data, 0x0f);
CHECK_VALUE(data[pos+0x11], 0);
CHECK_VALUE(data[pos+0x12], 0);
CHECK_VALUE(data[pos+0x13], 0);
CHECK_VALUE(data[pos+0x14], 0);
CHECK_VALUE(data[pos+0x15], 0);
CHECK_VALUE(data[pos+0x16], 0);
CHECK_VALUE(data[pos+0x17], 0);
break;
case 2: // Mask On
tt += data[pos] | (data[pos+1] << 8);
this->AddEvent(new PRS1ParsedSliceEvent(tt, MaskOn));
this->ParseHumidifierSetting60Series(data[pos+2], data[pos+3]);
break;
case 3: // Mask Off
tt += data[pos] | (data[pos+1] << 8);
this->AddEvent(new PRS1ParsedSliceEvent(tt, MaskOff));
// Compliance doesn't have any MaskOff stats like summary does
break;
case 1: // Equipment Off
tt += data[pos] | (data[pos+1] << 8);
this->AddEvent(new PRS1ParsedSliceEvent(tt, EquipmentOff));
// TODO: check values
CHECK_VALUES(data[pos+2], 1, 3);
//CHECK_VALUE(data[pos+2] & ~(0x40|8|4|2|1), 0); // ???, seen various bit combinations
//CHECK_VALUE(data[pos+3], 0x19); // 0x17, 0x16
CHECK_VALUES(data[pos+4], 0, 1);
//CHECK_VALUES(data[pos+4], 0, 1); // or 2
//CHECK_VALUE(data[pos+5], 0x35); // 0x36, 0x36
if (data[pos+6] != 1) {
CHECK_VALUE(data[pos+6] & ~(4|2|1), 0); // On F0V23 0 seems to be related to errors, 3 seen after 90 sec large leak before turning off?
}
// pos+4 == 2, pos+6 == 10 on the session that had a time-elapsed event, maybe it shut itself off
// when approaching 24h of continuous use?
break;
/*
case 4: // Time Elapsed
// For example: mask-on 5:18:49 in a session of 23:41:20 total leaves mask-off time of 18:22:31.
// That's represented by a mask-off event 19129 seconds after the mask-on, then a time-elapsed
// event after 65535 seconds, then an equipment off event after another 616 seconds.
tt += data[pos] | (data[pos+1] << 8);
// TODO: see if this event exists in earlier versions
break;
case 5: // Clock adjustment?
CHECK_VALUE(pos, 1); // Always first
CHECK_VALUE(chunk_size, 5); // and the only record in the session.
// This looks like it's minor adjustments to the clock, but 560PBT-3917 sessions 1-2 are weird:
// session 1 starts at 2015-12-23T00:01:20 and contains this event with timestamp 2015-12-23T00:05:14.
// session 2 starts at 2015-12-23T00:01:29, which suggests the event didn't change the clock.
//
// It looks like this happens when there are discontinuities in timestamps, for example 560P-4727:
// session 58 ends at 2015-05-26T09:53:17.
// session 59 starts at 2015-05-26T09:53:15 with an event 5 timestamp of 2015-05-26T09:53:18.
//
// So the session/chunk timestamp has gone backwards. Whenever this happens, it seems to be in
// a session with an event-5 event having a timestamp that hasn't gone backwards. So maybe
// this timestamp is the old clock before adjustment? This would explain the 560PBT-3917 sessions above.
//
// This doesn't seem particularly associated with discontinuities in the waveform data: there are
// often clock adjustments without corresponding discontinuities in the waveform, and vice versa.
// It's possible internal clock inaccuracy causes both independently.
//
// TODO: why do some machines have lots of these and others none? Maybe cellular modems make daily tweaks?
if (false) {
long value = data[pos] | data[pos+1]<<8 | data[pos+2]<<16 | data[pos+3]<<24;
qDebug() << this->sessionid << "clock changing from" << ts(value * 1000L)
<< "to" << ts(this->timestamp * 1000L)
<< "delta:" << (this->timestamp - value);
}
break;
*/
case 6: // Cleared?
// Appears in the very first session when that session number is > 1.
// Presumably previous sessions were cleared out.
// TODO: add an internal event for this.
CHECK_VALUE(pos, 1); // Always first
CHECK_VALUE(chunk_size, 1); // and the only record in the session.
if (this->sessionid == 1) UNEXPECTED_VALUE(this->sessionid, ">1");
break;
case 7: // Humidifier setting change (logged in events in 50 series)
tt += data[pos] | (data[pos+1] << 8); // This adds to the total duration (otherwise it won't match report)
this->ParseHumidifierSetting60Series(data[pos+2], data[pos+3]);
break;
/*
case 8: // CPAP-Check related, follows Mask On in CPAP-Check mode
tt += data[pos] | (data[pos+1] << 8); // This adds to the total duration (otherwise it won't match report)
//CHECK_VALUES(data[pos+2], 0, 79); // probably 16-bit value, sometimes matches OA + H + FL + VS + RE?
CHECK_VALUE(data[pos+3], 0);
//CHECK_VALUES(data[pos+4], 0, 10); // probably 16-bit value
CHECK_VALUE(data[pos+5], 0);
//CHECK_VALUES(data[pos+6], 0, 79); // probably 16-bit value, usually the same as +2, but not always?
CHECK_VALUE(data[pos+7], 0);
//CHECK_VALUES(data[pos+8], 0, 10); // probably 16-bit value
CHECK_VALUE(data[pos+9], 0);
//CHECK_VALUES(data[pos+0xa], 0, 4); // or 0? 44 when changed pressure mid-session?
break;
*/
default:
UNEXPECTED_VALUE(code, "known slice code");
ok = false; // unlike F0V6, we don't know the size of unknown slices, so we can't recover
break;
}
pos += size;
}
if (ok && pos != chunk_size) {
qWarning() << this->sessionid << (this->size() - pos) << "trailing bytes";
}
this->duration = tt;
return ok;
}
bool PRS1DataChunk::ParseSummaryF0V4(void)
{
if (this->family != 0 || (this->familyVersion != 4)) {
@ -5906,7 +6067,7 @@ bool PRS1DataChunk::ParseSettingsF3V6(const unsigned char* data, int size)
breath_rate = data[pos+1];
timed_inspiration = data[pos+2];
if (breath_rate < 9 || breath_rate > 12) UNEXPECTED_VALUE(breath_rate, "9-12");
if (timed_inspiration < 10 || timed_inspiration > 20) UNEXPECTED_VALUE(timed_inspiration, "10-20");
if (timed_inspiration < 8 || timed_inspiration > 20) UNEXPECTED_VALUE(timed_inspiration, "8-20");
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_BACKUP_BREATH_MODE, PRS1Backup_Fixed));
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_BACKUP_BREATH_RATE, breath_rate));
this->AddEvent(new PRS1ScaledSettingEvent(PRS1_SETTING_BACKUP_TIMED_INSPIRATION, timed_inspiration, 0.1));
@ -5959,7 +6120,7 @@ bool PRS1DataChunk::ParseSettingsF3V6(const unsigned char* data, int size)
break;
case 0x36: // Mask Resistance Lock
CHECK_VALUE(len, 1);
CHECK_VALUE(data[pos], 0); // 0x80 = locked on F5V3, not yet observed on F3V6
CHECK_VALUES(data[pos], 0, 0x80);
this->AddEvent(new PRS1ParsedSettingEvent(PRS1_SETTING_MASK_RESIST_LOCK, data[pos] != 0));
break;
case 0x38: // Mask Resistance
@ -6530,7 +6691,7 @@ bool PRS1DataChunk::ParseComplianceF0V6(void)
int pos = 0;
int code, size;
int tt = 0;
do {
while (ok && pos < chunk_size) {
code = data[pos++];
if (!this->hblock.contains(code)) {
qWarning() << this->sessionid << "missing hblock entry for" << code;
@ -6604,7 +6765,7 @@ bool PRS1DataChunk::ParseComplianceF0V6(void)
break;
}
pos += size;
} while (ok && pos < chunk_size);
}
this->duration = tt;

3
oscar/SleepLib/loader_plugins/prs1_loader.h
View File

@ -138,6 +138,9 @@ public:
//! \brief Parse a single data chunk from a .000 file containing compliance data for a P25x brick
bool ParseComplianceF0V23(void);
//! \brief Parse a single data chunk from a .000 file containing compliance data for a P256x brick
bool ParseComplianceF0V4(void);
//! \brief Parse a single data chunk from a .000 file containing compliance data for a DreamStation 200X brick
bool ParseComplianceF0V6(void);