diff --git a/ShimmerDriver/src/main/java/com/shimmerresearch/driver/ShimmerObject.java b/ShimmerDriver/src/main/java/com/shimmerresearch/driver/ShimmerObject.java index a181f3628..26d39129f 100644 --- a/ShimmerDriver/src/main/java/com/shimmerresearch/driver/ShimmerObject.java +++ b/ShimmerDriver/src/main/java/com/shimmerresearch/driver/ShimmerObject.java @@ -78,6 +78,7 @@ import com.shimmerresearch.sensors.bmpX80.SensorBMP390; import com.shimmerresearch.sensors.bmpX80.SensorBMP581; import com.shimmerresearch.sensors.bmpX80.SensorBMPX80; +import com.shimmerresearch.sensors.bmpX80.SdHeaderPressureSensorId; import com.shimmerresearch.sensors.kionix.SensorKionixAccel; import com.shimmerresearch.sensors.kionix.SensorKionixKXRB52042; import com.shimmerresearch.sensors.kionix.SensorKionixKXTC92050; @@ -697,6 +698,11 @@ public String toString() { * {@link #isSupportedBmp581()}. Cleared whenever the expansion board details * change, so each connection starts from the SR-number rule again. */ protected Integer mPressureSensorIdInBand = null; + /** The pressure sensor an SD log file's header records at offset 224, or + * null if none has been applied. When present it overrides the SR-number + * rule in {@link #isSupportedBmp581()} and {@link #isSupportedBmp280()}. + * Cleared whenever the expansion board details change. */ + protected SdHeaderPressureSensorId mPressureSensorIdSdHeader = null; // Shimmer3r - Mag private SensorLIS2MDL mSensorLIS2MDL = new SensorLIS2MDL(this); @@ -2045,7 +2051,7 @@ else if (isEXGUsingDefaultThreeUnipolarConfiguration()){ uncalibratedData[iUP]=(double)newPacketInt[iUP]; uncalibratedDataUnits[iUT]=CHANNEL_UNITS.NO_UNITS; uncalibratedDataUnits[iUP]=CHANNEL_UNITS.NO_UNITS; - if (mEnableCalibration){ + if (mEnableCalibration && isPressureSensorCalibratable()){ double[] bmp180caldata = mSensorBMPX80.calibratePressureSensorData(UP,UT); objectCluster.addDataToMap(signalNameBmpX80Pressure,CHANNEL_TYPE.CAL.toString(),CHANNEL_UNITS.KPASCAL,bmp180caldata[0]/1000); objectCluster.addDataToMap(signalNameBmpX80Temperature,CHANNEL_TYPE.CAL.toString(),CHANNEL_UNITS.DEGREES_CELSIUS,bmp180caldata[1]); @@ -2053,6 +2059,12 @@ else if (isEXGUsingDefaultThreeUnipolarConfiguration()){ calibratedData[iUP]=bmp180caldata[0]/1000; calibratedDataUnits[iUT]=CHANNEL_UNITS.DEGREES_CELSIUS; calibratedDataUnits[iUP]=CHANNEL_UNITS.KPASCAL; + } else if (mEnableCalibration){ + // The SD header names a sensor this parser cannot calibrate, or + // none fitted. The multimap has no CAL entry, so it reads NaN; + // leaving the arrays at 0 would look like a real reading. + calibratedData[iUT]=Double.NaN; + calibratedData[iUP]=Double.NaN; } } @@ -5535,7 +5547,9 @@ private void createMapOfSensorClasses() { } else if(isSupportedNewImuSensors()){ - mSensorBMPX80 = new SensorBMP280(this); + // The barometer follows isSupportedBmp280(), which an SD header's + // pressure sensor ID can set apart from the IMU generation + mSensorBMPX80 = isSupportedBmp280()? new SensorBMP280(this):new SensorBMP180(this); addSensorClass(mSensorBMPX80); mSensorLSM303 = new SensorLSM303AH(this); @@ -5551,7 +5565,7 @@ else if(isSupportedNewImuSensors()){ } else{ - mSensorBMPX80 = new SensorBMP180(this); + mSensorBMPX80 = isSupportedBmp280()? new SensorBMP280(this):new SensorBMP180(this); addSensorClass(mSensorBMPX80); mSensorLSM303 = new SensorLSM303DLHC(this); @@ -10825,9 +10839,17 @@ public boolean isSupportedErrorLedControl() { /** Returns true if the Shimmer is using new sensors. These sensors are: *
+ * If an SD log file's header names its pressure sensor (see + * {@link #setPressureSensorIdFromSdHeader(int)}), that answer is used + * instead of the board revision. + * * @return */ public boolean isSupportedBmp280() { + if(mPressureSensorIdSdHeader!=null && mPressureSensorIdSdHeader.isPresent() && getHardwareVersion()==HW_ID.SHIMMER_3){ + return mPressureSensorIdSdHeader.isSensor(PRESSURE_SENSOR_ID.BMP280); + } return isSupportedNewImuSensors(); } @@ -10849,18 +10871,27 @@ public static boolean isSupportedBmp280(ShimmerVerObject svo, ExpansionBoardDeta * in either direction. Otherwise, e.g. when the firmware NACKs the command * or is too old to have it, the SR-number rule decides. * + *
+ * An SD log file's header names its pressure sensor from + * LogAndStream_Shimmer3R v1.01.018 (see + * {@link #setPressureSensorIdFromSdHeader(int)}), and that overrides the + * SR-number rule in the same way. + * * @return true if the connected Shimmer3R reported a BMP581, or if its board revision and firmware version indicate BMP581 output support */ public boolean isSupportedBmp581() { if(mPressureSensorIdInBand!=null && getHardwareVersion()==HW_ID.SHIMMER_3R){ return mPressureSensorIdInBand==PRESSURE_SENSOR_ID.BMP581; } + if(mPressureSensorIdSdHeader!=null && mPressureSensorIdSdHeader.isPresent() && getHardwareVersion()==HW_ID.SHIMMER_3R){ + return mPressureSensorIdSdHeader.isSensor(PRESSURE_SENSOR_ID.BMP581); + } return isSupportedBmp581(getShimmerVerObject(), getExpansionBoardDetails()); } /** The SR-number rule alone, used when the Shimmer hasn't identified its - * pressure sensor in-band and for SD log files (whose header carries no - * sensor ID). It mirrors the firmware's own fallback, + * pressure sensor in-band and for SD log files whose header doesn't name + * it. It mirrors the firmware's own fallback, * ShimBrd_isBmp581PresentPerSrNumber() in log-and-stream-common * Boards/shimmer_boards.c, plus a firmware-version guard. * @@ -10925,6 +10956,64 @@ public Integer getPressureSensorIdInBand() { return mPressureSensorIdInBand; } + /** Applies the pressure sensor an SD log file's header records at offset + * 224. The byte is ignored (the SR-number rule decides, as before) unless + * the firmware is new enough to write it. Call this after the version and + * expansion board details are set, because setting the board clears it, + * and before {@link #sensorAndConfigMapsCreate()}, which builds the + * pressure sensor class from it. + * + * @param headerValue the byte at {@link SdHeaderPressureSensorId#SD_HEADER_INDEX}, 0-255 + * @return what the byte means for this file + */ + public SdHeaderPressureSensorId setPressureSensorIdFromSdHeader(int headerValue) { + SdHeaderPressureSensorId sdHeaderId = SdHeaderPressureSensorId.parse(getShimmerVerObject(), headerValue); + + mPressureSensorIdSdHeader = sdHeaderId; + + boolean isShimmer3R = getHardwareVersion()==HW_ID.SHIMMER_3R; + boolean isNewerSensorPerSrRule = isShimmer3R? + isSupportedBmp581(getShimmerVerObject(), getExpansionBoardDetails()):isSupportedNewImuSensors(); + + if(sdHeaderId.isKnown()){ + boolean isNewerSensorPerHeader = sdHeaderId.isSensor(isShimmer3R? PRESSURE_SENSOR_ID.BMP581:PRESSURE_SENSOR_ID.BMP280); + if(isNewerSensorPerHeader!=isNewerSensorPerSrRule){ + consolePrintLn("Pressure sensor in the SD header, " + sdHeaderId + ", differs from the SR-number rule, using the SD header"); + } + if(sdHeaderId.isInferred()){ + consolePrintErrLn("Pressure sensor in the SD header, " + sdHeaderId + ", was not confirmed by chip ID"); + } + } else if(sdHeaderId.getState()==SdHeaderPressureSensorId.STATE.UNKNOWN){ + consolePrintErrLn("Pressure sensor in the SD header, " + sdHeaderId + ", is not one this parser knows, pressure and temperature will be uncalibrated"); + } + return sdHeaderId; + } + + /** + * @return the pressure sensor ID applied from an SD log file's header, or + * null if none has been applied + */ + public SdHeaderPressureSensorId getPressureSensorIdSdHeader() { + return mPressureSensorIdSdHeader; + } + + /** + * @return true if an SD log file's header says the pressure sensor was + * inferred from the SR number rather than confirmed by chip ID + */ + public boolean isPressureSensorInferred() { + return mPressureSensorIdSdHeader!=null && mPressureSensorIdSdHeader.isPresent() && mPressureSensorIdSdHeader.isInferred(); + } + + /** + * @return false if an SD log file's header names a pressure sensor this + * parser doesn't know, or says none is fitted, in which case the + * pressure and temperature channels are emitted uncalibrated + */ + public boolean isPressureSensorCalibratable() { + return mPressureSensorIdSdHeader==null || !mPressureSensorIdSdHeader.isUncalibrated(); + } + /** * @param pressureSensorId a {@link PRESSURE_SENSOR_ID} * @return the number of coefficient bytes that follow this sensor ID in a @@ -10950,12 +11039,14 @@ public void setExpansionBoardDetails(ExpansionBoardDetails eBD){ super.setExpansionBoardDetails(eBD); // A different board may carry a different pressure sensor mPressureSensorIdInBand = null; + mPressureSensorIdSdHeader = null; } @Override public void clearExpansionBoardDetails(){ super.clearExpansionBoardDetails(); mPressureSensorIdInBand = null; + mPressureSensorIdSdHeader = null; } /** Returns true if the Shimmer is using new sensors. These sensors are: diff --git a/ShimmerDriver/src/main/java/com/shimmerresearch/sensors/bmpX80/SdHeaderPressureSensorId.java b/ShimmerDriver/src/main/java/com/shimmerresearch/sensors/bmpX80/SdHeaderPressureSensorId.java new file mode 100644 index 000000000..fdaf6a081 --- /dev/null +++ b/ShimmerDriver/src/main/java/com/shimmerresearch/sensors/bmpX80/SdHeaderPressureSensorId.java @@ -0,0 +1,171 @@ +package com.shimmerresearch.sensors.bmpX80; + +import java.io.Serializable; + +import com.shimmerresearch.driver.ShimmerObject.PRESSURE_SENSOR_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.FW_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.HW_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerObject; +import com.shimmerresearch.driverUtilities.UtilShimmer; + +/** + * The pressure sensor LogAndStream firmware records at SD header offset 224 + * (SDH_PRESSURE_SENSOR_ID in log-and-stream-common SDCard/shimmer_sd_header.h). + * Offset 224 is the same in the 256-byte Shimmer3 header and the 384-byte + * Shimmer3R header. + * + *
+ * Bits 0-6 hold a {@link PRESSURE_SENSOR_ID}, the same numbering as the 0xA6 + * response. Bit 7 means the firmware inferred the sensor from the SR number + * because the chip-ID check was inconclusive. 0xFE means no pressure sensor is + * fitted (Shimmer3 only). The firmware pre-fills the header with 0xFF, so 0xFF + * means the firmware predates the field. + * + *
+ * The byte is only trusted from LogAndStream_Shimmer3R v1.01.018 and + * LogAndStream_Shimmer3 v1.01.006. The two version lines overlap, so the gate + * checks the hardware version too. + */ +public class SdHeaderPressureSensorId implements Serializable { + + // ShimmerObject holds one, and ShimmerPC.deepClone() serialises the device + private static final long serialVersionUID = 1258143216796546316L; + + public static final int SD_HEADER_INDEX = 224; + + public static final int ID_MASK = 0x7F; + public static final int INFERRED_FLAG = 0x80; + public static final int NOT_FITTED = 0xFE; + public static final int NOT_RECORDED = 0xFF; + + public enum STATE { + /** Firmware below the gate, or 0xFF: the SR-number rule decides, as before. */ + ABSENT, + /** A sensor this platform's parser handles; it overrides the SR-number rule. */ + KNOWN, + /** Present but not a sensor this parser handles on this platform: emit the channels uncalibrated, no SR-number fallback. */ + UNKNOWN, + /** 0xFE, no pressure sensor fitted: any pressure channels in the file are emitted uncalibrated. */ + NOT_FITTED + } + + private final STATE mState; + private final int mSensorId; + private final boolean mIsInferred; + private final int mRawValue; + + private SdHeaderPressureSensorId(STATE state, int sensorId, boolean isInferred, int rawValue) { + mState = state; + mSensorId = sensorId; + mIsInferred = isInferred; + mRawValue = rawValue; + } + + /** + * @param svo the version details from the same header + * @return true if this firmware writes a trustworthy offset 224 + */ + public static boolean isSupported(ShimmerVerObject svo) { + if(svo==null){ + return false; + } + return isVerAtLeast(svo, HW_ID.SHIMMER_3R, 1, 1, 18) + || isVerAtLeast(svo, HW_ID.SHIMMER_3, 1, 1, 6); + } + + // ShimmerVerObject.compareVersions(svo, hw, ...) ignores the hardware + // version, so go to UtilShimmer directly + private static boolean isVerAtLeast(ShimmerVerObject svo, int hardwareVersion, int major, int minor, int internal) { + return UtilShimmer.compareVersions(svo.getHardwareVersion(), svo.getFirmwareIdentifier(), + svo.getFirmwareVersionMajor(), svo.getFirmwareVersionMinor(), svo.getFirmwareVersionInternal(), + hardwareVersion, FW_ID.LOGANDSTREAM, major, minor, internal); + } + + /** + * @param svo the version details from the same header + * @param headerValue the byte at {@link #SD_HEADER_INDEX}, 0-255 + * @return what the byte means for this file + */ + public static SdHeaderPressureSensorId parse(ShimmerVerObject svo, int headerValue) { + headerValue &= 0xFF; + if(headerValue==NOT_RECORDED || !isSupported(svo)){ + return new SdHeaderPressureSensorId(STATE.ABSENT, -1, false, headerValue); + } + if(headerValue==NOT_FITTED){ + return new SdHeaderPressureSensorId(STATE.NOT_FITTED, -1, false, headerValue); + } + + int sensorId = headerValue & ID_MASK; + boolean isInferred = (headerValue & INFERRED_FLAG)!=0; + STATE state = isSensorHandled(svo.getHardwareVersion(), sensorId)? STATE.KNOWN:STATE.UNKNOWN; + return new SdHeaderPressureSensorId(state, sensorId, isInferred, headerValue); + } + + /** The parser has no Shimmer3R path for a BMP180/280 or Shimmer3 path for a + * BMP390/581, so those are as unknown as a future ID would be. */ + private static boolean isSensorHandled(int hardwareVersion, int sensorId) { + if(hardwareVersion==HW_ID.SHIMMER_3R){ + return sensorId==PRESSURE_SENSOR_ID.BMP390 || sensorId==PRESSURE_SENSOR_ID.BMP581; + } + return sensorId==PRESSURE_SENSOR_ID.BMP180 || sensorId==PRESSURE_SENSOR_ID.BMP280; + } + + public STATE getState() { + return mState; + } + + /** + * @return true unless the SR-number rule should decide ({@link STATE#ABSENT}) + */ + public boolean isPresent() { + return mState!=STATE.ABSENT; + } + + /** + * @return true if the byte names a sensor this parser can calibrate + */ + public boolean isKnown() { + return mState==STATE.KNOWN; + } + + /** + * @return true if the channels must not be calibrated as any BMP + * ({@link STATE#UNKNOWN} or {@link STATE#NOT_FITTED}) + */ + public boolean isUncalibrated() { + return mState==STATE.UNKNOWN || mState==STATE.NOT_FITTED; + } + + /** + * @param sensorId a {@link PRESSURE_SENSOR_ID} + * @return true if the byte names this sensor and the parser handles it + */ + public boolean isSensor(int sensorId) { + return mState==STATE.KNOWN && mSensorId==sensorId; + } + + /** + * @return the low 7 bits, a {@link PRESSURE_SENSOR_ID} if known, or -1 if + * {@link STATE#ABSENT} or {@link STATE#NOT_FITTED} + */ + public int getSensorId() { + return mSensorId; + } + + /** + * @return true if the firmware inferred the sensor from the SR number + * rather than confirming it by chip ID + */ + public boolean isInferred() { + return mIsInferred; + } + + public int getRawValue() { + return mRawValue; + } + + @Override + public String toString() { + return String.format("0x%02X (%s%s)", mRawValue, mState, mIsInferred? ", inferred from SR number":""); + } +} diff --git a/ShimmerDriver/src/test/java/com/shimmerresearch/driver/API_00022_SdHeaderPressureSensorIdTest.java b/ShimmerDriver/src/test/java/com/shimmerresearch/driver/API_00022_SdHeaderPressureSensorIdTest.java new file mode 100644 index 000000000..670dad9b2 --- /dev/null +++ b/ShimmerDriver/src/test/java/com/shimmerresearch/driver/API_00022_SdHeaderPressureSensorIdTest.java @@ -0,0 +1,181 @@ +package com.shimmerresearch.driver; + +import static org.junit.Assert.*; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +import org.junit.Test; + +import com.shimmerresearch.driver.ShimmerObject.PRESSURE_SENSOR_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.FW_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.HW_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerObject; +import com.shimmerresearch.sensors.bmpX80.SdHeaderPressureSensorId; +import com.shimmerresearch.sensors.bmpX80.SdHeaderPressureSensorId.STATE; + +/** + * Decoding of the pressure sensor ID LogAndStream writes at SD header offset + * 224 (DEV-1123), and the firmware-version gate that decides whether it is + * trusted. The gate has to check the hardware version, because Shimmer3 and + * Shimmer3R firmware version numbers overlap. Choosing the sensor class from + * it, against the SR-number rule, is covered end to end through ShimmerSDLog + * in Shimmer-Advance-API. + * + * @author Mark Nolan + */ +public class API_00022_SdHeaderPressureSensorIdTest { + + private static ShimmerVerObject s3r(int major, int minor, int internal) { + return new ShimmerVerObject(HW_ID.SHIMMER_3R, FW_ID.LOGANDSTREAM, major, minor, internal); + } + + private static ShimmerVerObject s3(int major, int minor, int internal) { + return new ShimmerVerObject(HW_ID.SHIMMER_3, FW_ID.LOGANDSTREAM, major, minor, internal); + } + + private static final ShimmerVerObject S3R_GATE = s3r(1, 1, 18); + private static final ShimmerVerObject S3_GATE = s3(1, 1, 6); + + private static void assertKnown(SdHeaderPressureSensorId id, int sensorId, boolean inferred) { + assertEquals(id.toString(), STATE.KNOWN, id.getState()); + assertTrue(id.isPresent()); + assertTrue(id.isSensor(sensorId)); + assertEquals(sensorId, id.getSensorId()); + assertEquals(inferred, id.isInferred()); + assertFalse(id.isUncalibrated()); + } + + private static void assertAbsent(SdHeaderPressureSensorId id) { + assertEquals(id.toString(), STATE.ABSENT, id.getState()); + assertFalse(id.isPresent()); + assertFalse(id.isUncalibrated()); + assertFalse(id.isSensor(PRESSURE_SENSOR_ID.BMP581)); + } + + private static void assertUnknown(SdHeaderPressureSensorId id) { + assertEquals(id.toString(), STATE.UNKNOWN, id.getState()); + assertTrue(id.isPresent()); + assertTrue(id.isUncalibrated()); + for (int sensorId = PRESSURE_SENSOR_ID.BMP180; sensorId <= PRESSURE_SENSOR_ID.BMP581; sensorId++) { + assertFalse("never treated as sensor " + sensorId, id.isSensor(sensorId)); + } + } + + @Test + public void shimmer3rKnownIds() { + assertKnown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x02), PRESSURE_SENSOR_ID.BMP390, false); + assertKnown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x03), PRESSURE_SENSOR_ID.BMP581, false); + } + + @Test + public void inferredFlag() { + assertKnown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x83), PRESSURE_SENSOR_ID.BMP581, true); + assertKnown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x82), PRESSURE_SENSOR_ID.BMP390, true); + } + + @Test + public void notRecordedFallsBackToSrRule() { + assertAbsent(SdHeaderPressureSensorId.parse(S3R_GATE, 0xFF)); + assertAbsent(SdHeaderPressureSensorId.parse(S3_GATE, 0xFF)); + } + + @Test + public void unknownIdsAreUncalibrated() { + assertUnknown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x04)); + assertUnknown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x7D)); + // 0x7E-0x7F were never allocated + assertUnknown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x7E)); + assertUnknown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x7F)); + + SdHeaderPressureSensorId inferredUnknown = SdHeaderPressureSensorId.parse(S3R_GATE, 0x84); + assertUnknown(inferredUnknown); + assertTrue(inferredUnknown.isInferred()); + } + + /** The parser has no Shimmer3R path for a BMP180/280 or Shimmer3 path for a BMP390/581. */ + @Test + public void sensorsTheOtherPlatformCarriesAreUnknown() { + assertUnknown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x00)); + assertUnknown(SdHeaderPressureSensorId.parse(S3R_GATE, 0x01)); + assertUnknown(SdHeaderPressureSensorId.parse(S3_GATE, 0x02)); + assertUnknown(SdHeaderPressureSensorId.parse(S3_GATE, 0x03)); + } + + @Test + public void shimmer3Ids() { + assertKnown(SdHeaderPressureSensorId.parse(S3_GATE, 0x00), PRESSURE_SENSOR_ID.BMP180, false); + assertKnown(SdHeaderPressureSensorId.parse(S3_GATE, 0x01), PRESSURE_SENSOR_ID.BMP280, false); + + SdHeaderPressureSensorId none = SdHeaderPressureSensorId.parse(S3_GATE, 0xFE); + assertEquals(STATE.NOT_FITTED, none.getState()); + assertTrue(none.isPresent()); + assertTrue("any pressure channels are emitted uncalibrated", none.isUncalibrated()); + assertFalse(none.isSensor(PRESSURE_SENSOR_ID.BMP180)); + assertFalse(none.isSensor(PRESSURE_SENSOR_ID.BMP280)); + } + + @Test + public void oldFirmwareIsIgnored() { + assertAbsent(SdHeaderPressureSensorId.parse(s3r(1, 1, 17), 0x03)); + assertAbsent(SdHeaderPressureSensorId.parse(s3(1, 1, 5), 0x01)); + assertAbsent(SdHeaderPressureSensorId.parse(s3(1, 1, 5), 0xFE)); + } + + @Test + public void gateChecksHardware() { + // Shimmer3 v1.01.018 is gated on the Shimmer3 threshold, so it passes + assertTrue(SdHeaderPressureSensorId.isSupported(s3(1, 1, 18))); + assertKnown(SdHeaderPressureSensorId.parse(s3(1, 1, 18), 0x01), PRESSURE_SENSOR_ID.BMP280, false); + + // Shimmer3R v1.01.006-v1.01.017 would pass the Shimmer3 threshold but must not + for (int internal = 6; internal <= 17; internal++) { + assertFalse("S3R v1.01." + internal, SdHeaderPressureSensorId.isSupported(s3r(1, 1, internal))); + assertAbsent(SdHeaderPressureSensorId.parse(s3r(1, 1, internal), 0x03)); + } + } + + @Test + public void gateBoundaries() { + assertTrue(SdHeaderPressureSensorId.isSupported(s3r(1, 1, 18))); + assertTrue(SdHeaderPressureSensorId.isSupported(s3r(1, 2, 0))); + assertTrue(SdHeaderPressureSensorId.isSupported(s3r(2, 0, 0))); + assertFalse(SdHeaderPressureSensorId.isSupported(s3r(1, 0, 99))); + + assertTrue(SdHeaderPressureSensorId.isSupported(s3(1, 1, 6))); + assertTrue(SdHeaderPressureSensorId.isSupported(s3(1, 2, 0))); + assertFalse(SdHeaderPressureSensorId.isSupported(s3(1, 1, 5))); + assertFalse(SdHeaderPressureSensorId.isSupported(s3(0, 16, 99))); + + // Only LogAndStream writes it; SDLog used 224 for MPL gyro calibration + assertFalse(SdHeaderPressureSensorId.isSupported(new ShimmerVerObject(HW_ID.SHIMMER_3, FW_ID.SDLOG, 1, 1, 6))); + assertAbsent(SdHeaderPressureSensorId.parse(new ShimmerVerObject(HW_ID.SHIMMER_3, FW_ID.SDLOG, 1, 1, 6), 0x01)); + // Other hardware + assertFalse(SdHeaderPressureSensorId.isSupported(new ShimmerVerObject(HW_ID.SHIMMER_4_SDK, FW_ID.LOGANDSTREAM, 1, 1, 18))); + assertFalse(SdHeaderPressureSensorId.isSupported(null)); + } + + private static SdHeaderPressureSensorId serialiseAndRead(SdHeaderPressureSensorId id) throws Exception { + ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + try (ObjectOutputStream out = new ObjectOutputStream(bytes)) { + out.writeObject(id); + } + try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) { + return (SdHeaderPressureSensorId) in.readObject(); + } + } + + /** ShimmerObject holds one, and ShimmerPC.deepClone() serialises the device */ + @Test + public void survivesSerialisation() throws Exception { + assertKnown(serialiseAndRead(SdHeaderPressureSensorId.parse(S3R_GATE, 0x83)), PRESSURE_SENSOR_ID.BMP581, true); + assertUnknown(serialiseAndRead(SdHeaderPressureSensorId.parse(S3R_GATE, 0x04))); + assertAbsent(serialiseAndRead(SdHeaderPressureSensorId.parse(S3R_GATE, 0xFF))); + assertEquals(STATE.NOT_FITTED, serialiseAndRead(SdHeaderPressureSensorId.parse(S3_GATE, 0xFE)).getState()); + + SdHeaderPressureSensorId bmp280 = SdHeaderPressureSensorId.parse(S3_GATE, 0x01); + assertEquals(bmp280.toString(), serialiseAndRead(bmp280).toString()); + } +} diff --git a/ShimmerDriverPC/src/test/java/com/shimmerresearch/pcDriver/API_00023_SdHeaderPressureSensorIdShimmerPCTest.java b/ShimmerDriverPC/src/test/java/com/shimmerresearch/pcDriver/API_00023_SdHeaderPressureSensorIdShimmerPCTest.java new file mode 100644 index 000000000..348f90db9 --- /dev/null +++ b/ShimmerDriverPC/src/test/java/com/shimmerresearch/pcDriver/API_00023_SdHeaderPressureSensorIdShimmerPCTest.java @@ -0,0 +1,132 @@ +package com.shimmerresearch.pcDriver; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import com.shimmerresearch.driver.Configuration.COMMUNICATION_TYPE; +import com.shimmerresearch.driver.ObjectCluster; +import com.shimmerresearch.driver.ShimmerObject; +import com.shimmerresearch.driverUtilities.ChannelDetails.CHANNEL_TYPE; +import com.shimmerresearch.driverUtilities.ExpansionBoardDetails; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.FW_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.HW_ID; +import com.shimmerresearch.driverUtilities.ShimmerVerDetails.HW_ID_SR_CODES; +import com.shimmerresearch.driverUtilities.ShimmerVerObject; +import com.shimmerresearch.sensors.bmpX80.SdHeaderPressureSensorId.STATE; +import com.shimmerresearch.sensors.bmpX80.SensorBMP390; +import com.shimmerresearch.sensors.bmpX80.SensorBMP581; + +/** + * DEV-1123: a ShimmerPC with the SD header's pressure sensor ID applied, through + * the paths that see the whole device. API_00022 covers decoding the byte. + * + * @author Mark Nolan + */ +public class API_00023_SdHeaderPressureSensorIdShimmerPCTest { + + /** A BMP581 reads 101325 Pa as 101325 x 64 and 23.5 degC as 23.5 x 65536 */ + private static final int RAW_PRESSURE = 101325 * 64; + private static final int RAW_TEMPERATURE = 23 * 65536 + 32768; + + /** SR48-8-2, a BMP581 board by the SR-number rule, on firmware that writes offset 224 */ + private static ShimmerPC sr48_8_2(int sdHeaderValue) { + ShimmerPC device = new ShimmerPC("COM99"); + device.setShimmerVersionObjectAndCreateSensorMap(new ShimmerVerObject(HW_ID.SHIMMER_3R, FW_ID.LOGANDSTREAM, 1, 1, 18)); + device.setExpansionBoardDetailsAndCreateSensorMap(new ExpansionBoardDetails(HW_ID_SR_CODES.EXP_BRD_GSR_UNIFIED, 8, 2)); + device.setPressureSensorIdFromSdHeader(sdHeaderValue); + device.sensorAndConfigMapsCreate(); + return device; + } + + /** The pressure and temperature channel names buildMsg uses for this device */ + private static String[] pressureChannels(ShimmerPC device) { + return device.isSupportedBmp581() + ? new String[] {SensorBMP581.ObjectClusterSensorName.PRESSURE_BMP581, SensorBMP581.ObjectClusterSensorName.TEMPERATURE_BMP581} + : new String[] {SensorBMP390.ObjectClusterSensorName.PRESSURE_BMP390, SensorBMP390.ObjectClusterSensorName.TEMPERATURE_BMP390}; + } + + /** One packet carrying only the pressure sensor: [timestamp][temperature][pressure] */ + private static ObjectCluster pressurePacket(ShimmerPC device, boolean arraysDataStructure) { + device.mNChannels = 2; + device.interpretDataPacketFormat(2, new byte[] {0x1A, 0x1B}); + device.setEnabledSensors(ShimmerObject.SENSOR_BMPX80); + device.enableArraysDataStructure(arraysDataStructure); + byte[] packet = new byte[device.getPacketSize()]; + int iTemperature = packet.length - 6; + putU24(packet, iTemperature, RAW_TEMPERATURE); + putU24(packet, iTemperature + 3, RAW_PRESSURE); + return device.buildMsg(packet, COMMUNICATION_TYPE.BLUETOOTH, false, 0); + } + + private static void putU24(byte[] packet, int index, int value) { + packet[index] = (byte) value; + packet[index + 1] = (byte) (value >> 8); + packet[index + 2] = (byte) (value >> 16); + } + + private static double value(ObjectCluster objectCluster, String channel, CHANNEL_TYPE channelType) { + return objectCluster.getFormatClusterValue(channel, channelType.toString()); + } + + /** The calibrated array buildMsg hands over, read directly, whichever data structure is enabled */ + private static double calArray(ObjectCluster objectCluster, String channel) { + int index = objectCluster.getIndexForChannelName(channel); + assertTrue(channel + " is in the packet", index >= 0); + return objectCluster.mEnableArraysDataStructure? objectCluster.sensorDataArray.mCalData[index]:objectCluster.mCalData[index]; + } + + @Test + public void deepCloneKeepsTheSdHeaderPressureSensorId() { + // ShimmerPC.deepClone() serialises the device, and returns null if any field can't be + for (int sdHeaderValue : new int[] {0x03, 0x83, 0x04, 0xFE, 0xFF}) { + String header = "0x" + Integer.toHexString(sdHeaderValue); + ShimmerPC device = sr48_8_2(sdHeaderValue); + ShimmerPC clone = device.deepClone(); + assertNotNull(header, clone); + assertEquals(header, device.getPressureSensorIdSdHeader().toString(), clone.getPressureSensorIdSdHeader().toString()); + assertEquals(header, device.isSupportedBmp581(), clone.isSupportedBmp581()); + assertEquals(header, device.isPressureSensorCalibratable(), clone.isPressureSensorCalibratable()); + assertEquals(header, device.isPressureSensorInferred(), clone.isPressureSensorInferred()); + } + } + + @Test + public void sensorItCannotCalibrateReadsNaNInEveryDataStructure() { + // 0x04 is a sensor newer than this parser, 0xFE none fitted + for (int sdHeaderValue : new int[] {0x04, 0xFE}) { + for (boolean arraysDataStructure : new boolean[] {false, true}) { + String context = "0x" + Integer.toHexString(sdHeaderValue) + (arraysDataStructure? ", arrays":", multimap"); + ShimmerPC device = sr48_8_2(sdHeaderValue); + assertFalse(context, device.isPressureSensorCalibratable()); + ObjectCluster objectCluster = pressurePacket(device, arraysDataStructure); + + for (String channel : pressureChannels(device)) { + assertTrue(context + " " + channel, Double.isNaN(value(objectCluster, channel, CHANNEL_TYPE.CAL))); + assertTrue(context + " " + channel, Double.isNaN(calArray(objectCluster, channel))); + } + // The raw readings still come through + String[] channels = pressureChannels(device); + assertEquals(context, RAW_PRESSURE, value(objectCluster, channels[0], CHANNEL_TYPE.UNCAL), 0); + assertEquals(context, RAW_TEMPERATURE, value(objectCluster, channels[1], CHANNEL_TYPE.UNCAL), 0); + } + } + } + + @Test + public void knownSensorIsStillCalibrated() { + for (boolean arraysDataStructure : new boolean[] {false, true}) { + String context = arraysDataStructure? "arrays":"multimap"; + ShimmerPC device = sr48_8_2(0x03); + assertEquals(STATE.KNOWN, device.getPressureSensorIdSdHeader().getState()); + assertTrue(device.isSupportedBmp581()); + ObjectCluster objectCluster = pressurePacket(device, arraysDataStructure); + + String[] channels = pressureChannels(device); + assertEquals(context, 101.325, value(objectCluster, channels[0], CHANNEL_TYPE.CAL), 1e-9); + assertEquals(context, 23.5, value(objectCluster, channels[1], CHANNEL_TYPE.CAL), 1e-9); + assertEquals(context, 101.325, calArray(objectCluster, channels[0]), 1e-9); + assertEquals(context, 23.5, calArray(objectCluster, channels[1]), 1e-9); + } + } +}