diff --git a/README.md b/README.md index a6e27e33..024a5f2c 100644 --- a/README.md +++ b/README.md @@ -36,7 +36,7 @@ De-framer is a component that converts soft stream of bits into the frames of sp * Generic [syncword](https://en.wikipedia.org/wiki/Syncword) correlator - [CorrelateSyncword](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/blocks/CorrelateSyncword.java) * [USP](https://github.com/sputnixru/SX-USP) - [UspDecoder](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/usp/UspDecoder.java) * Mobitex - [MobitexBeaconSource](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/mobitex/MobitexBeaconSource.java) - * TUBiX20 - Generic de-framer for TUB-based satellites. [TUBiX20BeaconSource](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/tubix20/TUBiX20BeaconSource.java) + * TUBiX20 - Generic de-framer for TUB-based satellites. [TUBiX20BeaconSource](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/tubix20/TUBiX20BeaconSource.java) * CCSDS Concatenated - CCSDS 131.0-B-4 implementation for concatenated framing (Convolutional + Reed-Solomon). [CcsdsBeaconSource](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/ccsds/CcsdsBeaconSource.java) ## Auxiliary tools @@ -75,6 +75,7 @@ Most likely the algorithm name can't say you much, so it is better to check [cor * [CSP](https://en.wikipedia.org/wiki/Cubesat_Space_Protocol) - Full support * [CCSDS](https://en.wikipedia.org/wiki/Consultative_Committee_for_Space_Data_Systems) - [Basic support](https://github.com/dernasherbrezon/jradio/tree/master/src/main/java/ru/r2cloud/jradio/ccsds) * [PACSAT](https://www.tapr.org/pdf/CNC1990-PacSatBroadcast-NK6K-K8KA.pdf) - [Good support](https://github.com/dernasherbrezon/jradio/tree/master/src/main/java/ru/r2cloud/jradio/falconsat3) + * [OpenLST](https://github.com/OpenLST/openlst) - [OpenLstBeaconSource](https://github.com/dernasherbrezon/jradio/blob/master/src/main/java/ru/r2cloud/jradio/openlst/OpenLstBeaconSource) ## Low-level blocks @@ -619,6 +620,11 @@ jradio has lots of built-in satellite decoders. Some of them have non standard d 58472 ru.r2cloud.jradio.eirsat.EirsatBeacon + + DORA + 61502 + ru.r2cloud.jradio.dora.DoraBeacon + diff --git a/src/main/java/ru/r2cloud/jradio/dora/Adcs.java b/src/main/java/ru/r2cloud/jradio/dora/Adcs.java new file mode 100644 index 00000000..e2ff3ed3 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/Adcs.java @@ -0,0 +1,663 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.util.BitInputStream; +import ru.r2cloud.jradio.util.LittleEndianDataInputStream; + +public class Adcs { + + private boolean adcsCommissioningDone; + private int adcsCurrentCommissioningState; + private int bootStatus; + private int bootCount; + private int currentAdcsControlmode; + private int currentAdcsAttitudeestimation; + private boolean cubesense2Enabled; + private boolean cubesense1Enabled; + private boolean cubecontrolmotorEnabled; + private boolean cubecontrolsignalEnabled; + private int asgp4Mode; + private boolean currentadcsAdcsRunMode; + private boolean sunIsAboveLocalHorizon; + private boolean motorDriverEnabled; + private boolean gpsLnaPowerEnabled; + private boolean gpsReceiverEnable; + private boolean cubestarEnabled; + private boolean cubewheel3Enabled; + private boolean cubewheel2Enabled; + private boolean cubewheel1Enabled; + private boolean cubestarCommsError; + private boolean cubewheel3CommsError; + private boolean cubewheel2CommsError; + private boolean cubewheel1CommsError; + private boolean cubecontrolMotorCommsError; + private boolean cubecontrolSignalCommsError; + private boolean cubesense2CommsError; + private boolean cubesense1CommsError; + private boolean cam23v3OvercurrentDetected; + private boolean cam2SramOvercurrentDetected; + private boolean sunSensorRangeError; + private boolean cam1SensorDetectionError; + private boolean cam1SensorBusyError; + private boolean cam13v3OvercurrentDetected; + private boolean cam1SramOvercurrentDetected; + private boolean magnetometerRangeError; + private boolean starTrackerOvercurrentDetected; + private boolean startrackerMatchError; + private boolean coarseSunSensorError; + private boolean wheelSpeedRangeError; + private boolean rateSensorRangeError; + private boolean nadirSensorRangeError; + private boolean cam2SensorDetectionError; + private boolean cam2SensorBusyError; + + private float cubecontrlCur3v3; + private float cubecontrlCur5v; + private float cubecontrolCurVbat; + private float fineEstAngRatesX; + private float fineEstAngRatesY; + private float fineEstAngRatesZ; + private float fineSvX; + private float fineSvY; + private float fineSvZ; + private float mcuTempa; + private float tempMag; + private float tempRedmag; + private float wheel1Current; + private float wheel2Current; + private float wheel3Current; + private float magnetorquerCurrent; + private float cubesenes13v3Current; + private float cubesenes1SramCurrent; + private float cubesenes23v3Current; + private float cubesenes2SramCurrent; + + public Adcs() { + // do nothing + } + + public Adcs(DataInputStream dis) throws IOException { + BitInputStream bis = new BitInputStream(dis); + adcsCommissioningDone = bis.readBoolean(); + adcsCurrentCommissioningState = bis.readUnsignedInt(7); + bootStatus = bis.readUnsignedByte(); + bootCount = bis.readUnsignedShort(); + currentAdcsControlmode = bis.readUnsignedInt(4); + currentAdcsAttitudeestimation = bis.readUnsignedInt(4); + cubesense2Enabled = bis.readBoolean(); + cubesense1Enabled = bis.readBoolean(); + cubecontrolmotorEnabled = bis.readBoolean(); + cubecontrolsignalEnabled = bis.readBoolean(); + asgp4Mode = bis.readUnsignedInt(2); + currentadcsAdcsRunMode = bis.readBoolean(); + sunIsAboveLocalHorizon = bis.readBoolean(); + motorDriverEnabled = bis.readBoolean(); + gpsLnaPowerEnabled = bis.readBoolean(); + gpsReceiverEnable = bis.readBoolean(); + cubestarEnabled = bis.readBoolean(); + cubewheel3Enabled = bis.readBoolean(); + cubewheel2Enabled = bis.readBoolean(); + cubewheel1Enabled = bis.readBoolean(); + cubestarCommsError = bis.readBoolean(); + cubewheel3CommsError = bis.readBoolean(); + cubewheel2CommsError = bis.readBoolean(); + cubewheel1CommsError = bis.readBoolean(); + cubecontrolMotorCommsError = bis.readBoolean(); + cubecontrolSignalCommsError = bis.readBoolean(); + cubesense2CommsError = bis.readBoolean(); + cubesense1CommsError = bis.readBoolean(); + cam23v3OvercurrentDetected = bis.readBoolean(); + cam2SramOvercurrentDetected = bis.readBoolean(); + sunSensorRangeError = bis.readBoolean(); + cam1SensorDetectionError = bis.readBoolean(); + cam1SensorBusyError = bis.readBoolean(); + cam13v3OvercurrentDetected = bis.readBoolean(); + cam1SramOvercurrentDetected = bis.readBoolean(); + magnetometerRangeError = bis.readBoolean(); + starTrackerOvercurrentDetected = bis.readBoolean(); + startrackerMatchError = bis.readBoolean(); + coarseSunSensorError = bis.readBoolean(); + wheelSpeedRangeError = bis.readBoolean(); + rateSensorRangeError = bis.readBoolean(); + nadirSensorRangeError = bis.readBoolean(); + cam2SensorDetectionError = bis.readBoolean(); + cam2SensorBusyError = bis.readBoolean(); + + LittleEndianDataInputStream ldis = new LittleEndianDataInputStream(dis); + cubecontrlCur3v3 = ldis.readUnsignedShort() * 0.48828125f; + cubecontrlCur5v = ldis.readUnsignedShort() * 0.48828125f; + cubecontrolCurVbat = ldis.readUnsignedShort() * 0.48828125f; + fineEstAngRatesX = ldis.readUnsignedShort() * 0.001f; + fineEstAngRatesY = ldis.readUnsignedShort() * 0.001f; + fineEstAngRatesZ = ldis.readUnsignedShort() * 0.001f; + fineSvX = ldis.readUnsignedShort() * 0.0001f; + fineSvY = ldis.readUnsignedShort() * 0.0001f; + fineSvZ = ldis.readUnsignedShort() * 0.0001f; + mcuTempa = ldis.readUnsignedShort() * 0.1f; + tempMag = ldis.readUnsignedShort() * 0.1f; + tempRedmag = ldis.readUnsignedShort() * 0.1f; + wheel1Current = ldis.readUnsignedShort() * 0.01f; + wheel2Current = ldis.readUnsignedShort() * 0.01f; + wheel3Current = ldis.readUnsignedShort() * 0.01f; + magnetorquerCurrent = ldis.readUnsignedShort() * 0.01f; + cubesenes13v3Current = ldis.readUnsignedShort() * 0.01f; + cubesenes1SramCurrent = ldis.readUnsignedShort() * 0.01f; + cubesenes23v3Current = ldis.readUnsignedShort() * 0.01f; + cubesenes2SramCurrent = ldis.readUnsignedShort() * 0.01f; + } + + public boolean isAdcsCommissioningDone() { + return adcsCommissioningDone; + } + + public void setAdcsCommissioningDone(boolean adcsCommissioningDone) { + this.adcsCommissioningDone = adcsCommissioningDone; + } + + public int getAdcsCurrentCommissioningState() { + return adcsCurrentCommissioningState; + } + + public void setAdcsCurrentCommissioningState(int adcsCurrentCommissioningState) { + this.adcsCurrentCommissioningState = adcsCurrentCommissioningState; + } + + public int getBootStatus() { + return bootStatus; + } + + public void setBootStatus(int bootStatus) { + this.bootStatus = bootStatus; + } + + public int getBootCount() { + return bootCount; + } + + public void setBootCount(int bootCount) { + this.bootCount = bootCount; + } + + public int getCurrentAdcsControlmode() { + return currentAdcsControlmode; + } + + public void setCurrentAdcsControlmode(int currentAdcsControlmode) { + this.currentAdcsControlmode = currentAdcsControlmode; + } + + public int getCurrentAdcsAttitudeestimation() { + return currentAdcsAttitudeestimation; + } + + public void setCurrentAdcsAttitudeestimation(int currentAdcsAttitudeestimation) { + this.currentAdcsAttitudeestimation = currentAdcsAttitudeestimation; + } + + public boolean isCubesense2Enabled() { + return cubesense2Enabled; + } + + public void setCubesense2Enabled(boolean cubesense2Enabled) { + this.cubesense2Enabled = cubesense2Enabled; + } + + public boolean isCubesense1Enabled() { + return cubesense1Enabled; + } + + public void setCubesense1Enabled(boolean cubesense1Enabled) { + this.cubesense1Enabled = cubesense1Enabled; + } + + public boolean isCubecontrolmotorEnabled() { + return cubecontrolmotorEnabled; + } + + public void setCubecontrolmotorEnabled(boolean cubecontrolmotorEnabled) { + this.cubecontrolmotorEnabled = cubecontrolmotorEnabled; + } + + public boolean isCubecontrolsignalEnabled() { + return cubecontrolsignalEnabled; + } + + public void setCubecontrolsignalEnabled(boolean cubecontrolsignalEnabled) { + this.cubecontrolsignalEnabled = cubecontrolsignalEnabled; + } + + public int getAsgp4Mode() { + return asgp4Mode; + } + + public void setAsgp4Mode(int asgp4Mode) { + this.asgp4Mode = asgp4Mode; + } + + public boolean isCurrentadcsAdcsRunMode() { + return currentadcsAdcsRunMode; + } + + public void setCurrentadcsAdcsRunMode(boolean currentadcsAdcsRunMode) { + this.currentadcsAdcsRunMode = currentadcsAdcsRunMode; + } + + public boolean isSunIsAboveLocalHorizon() { + return sunIsAboveLocalHorizon; + } + + public void setSunIsAboveLocalHorizon(boolean sunIsAboveLocalHorizon) { + this.sunIsAboveLocalHorizon = sunIsAboveLocalHorizon; + } + + public boolean isMotorDriverEnabled() { + return motorDriverEnabled; + } + + public void setMotorDriverEnabled(boolean motorDriverEnabled) { + this.motorDriverEnabled = motorDriverEnabled; + } + + public boolean isGpsLnaPowerEnabled() { + return gpsLnaPowerEnabled; + } + + public void setGpsLnaPowerEnabled(boolean gpsLnaPowerEnabled) { + this.gpsLnaPowerEnabled = gpsLnaPowerEnabled; + } + + public boolean isGpsReceiverEnable() { + return gpsReceiverEnable; + } + + public void setGpsReceiverEnable(boolean gpsReceiverEnable) { + this.gpsReceiverEnable = gpsReceiverEnable; + } + + public boolean isCubestarEnabled() { + return cubestarEnabled; + } + + public void setCubestarEnabled(boolean cubestarEnabled) { + this.cubestarEnabled = cubestarEnabled; + } + + public boolean isCubewheel3Enabled() { + return cubewheel3Enabled; + } + + public void setCubewheel3Enabled(boolean cubewheel3Enabled) { + this.cubewheel3Enabled = cubewheel3Enabled; + } + + public boolean isCubewheel2Enabled() { + return cubewheel2Enabled; + } + + public void setCubewheel2Enabled(boolean cubewheel2Enabled) { + this.cubewheel2Enabled = cubewheel2Enabled; + } + + public boolean isCubewheel1Enabled() { + return cubewheel1Enabled; + } + + public void setCubewheel1Enabled(boolean cubewheel1Enabled) { + this.cubewheel1Enabled = cubewheel1Enabled; + } + + public boolean isCubestarCommsError() { + return cubestarCommsError; + } + + public void setCubestarCommsError(boolean cubestarCommsError) { + this.cubestarCommsError = cubestarCommsError; + } + + public boolean isCubewheel3CommsError() { + return cubewheel3CommsError; + } + + public void setCubewheel3CommsError(boolean cubewheel3CommsError) { + this.cubewheel3CommsError = cubewheel3CommsError; + } + + public boolean isCubewheel2CommsError() { + return cubewheel2CommsError; + } + + public void setCubewheel2CommsError(boolean cubewheel2CommsError) { + this.cubewheel2CommsError = cubewheel2CommsError; + } + + public boolean isCubewheel1CommsError() { + return cubewheel1CommsError; + } + + public void setCubewheel1CommsError(boolean cubewheel1CommsError) { + this.cubewheel1CommsError = cubewheel1CommsError; + } + + public boolean isCubecontrolMotorCommsError() { + return cubecontrolMotorCommsError; + } + + public void setCubecontrolMotorCommsError(boolean cubecontrolMotorCommsError) { + this.cubecontrolMotorCommsError = cubecontrolMotorCommsError; + } + + public boolean isCubecontrolSignalCommsError() { + return cubecontrolSignalCommsError; + } + + public void setCubecontrolSignalCommsError(boolean cubecontrolSignalCommsError) { + this.cubecontrolSignalCommsError = cubecontrolSignalCommsError; + } + + public boolean isCubesense2CommsError() { + return cubesense2CommsError; + } + + public void setCubesense2CommsError(boolean cubesense2CommsError) { + this.cubesense2CommsError = cubesense2CommsError; + } + + public boolean isCubesense1CommsError() { + return cubesense1CommsError; + } + + public void setCubesense1CommsError(boolean cubesense1CommsError) { + this.cubesense1CommsError = cubesense1CommsError; + } + + public boolean isCam23v3OvercurrentDetected() { + return cam23v3OvercurrentDetected; + } + + public void setCam23v3OvercurrentDetected(boolean cam23v3OvercurrentDetected) { + this.cam23v3OvercurrentDetected = cam23v3OvercurrentDetected; + } + + public boolean isCam2SramOvercurrentDetected() { + return cam2SramOvercurrentDetected; + } + + public void setCam2SramOvercurrentDetected(boolean cam2SramOvercurrentDetected) { + this.cam2SramOvercurrentDetected = cam2SramOvercurrentDetected; + } + + public boolean isSunSensorRangeError() { + return sunSensorRangeError; + } + + public void setSunSensorRangeError(boolean sunSensorRangeError) { + this.sunSensorRangeError = sunSensorRangeError; + } + + public boolean isCam1SensorDetectionError() { + return cam1SensorDetectionError; + } + + public void setCam1SensorDetectionError(boolean cam1SensorDetectionError) { + this.cam1SensorDetectionError = cam1SensorDetectionError; + } + + public boolean isCam1SensorBusyError() { + return cam1SensorBusyError; + } + + public void setCam1SensorBusyError(boolean cam1SensorBusyError) { + this.cam1SensorBusyError = cam1SensorBusyError; + } + + public boolean isCam13v3OvercurrentDetected() { + return cam13v3OvercurrentDetected; + } + + public void setCam13v3OvercurrentDetected(boolean cam13v3OvercurrentDetected) { + this.cam13v3OvercurrentDetected = cam13v3OvercurrentDetected; + } + + public boolean isCam1SramOvercurrentDetected() { + return cam1SramOvercurrentDetected; + } + + public void setCam1SramOvercurrentDetected(boolean cam1SramOvercurrentDetected) { + this.cam1SramOvercurrentDetected = cam1SramOvercurrentDetected; + } + + public boolean isMagnetometerRangeError() { + return magnetometerRangeError; + } + + public void setMagnetometerRangeError(boolean magnetometerRangeError) { + this.magnetometerRangeError = magnetometerRangeError; + } + + public boolean isStarTrackerOvercurrentDetected() { + return starTrackerOvercurrentDetected; + } + + public void setStarTrackerOvercurrentDetected(boolean starTrackerOvercurrentDetected) { + this.starTrackerOvercurrentDetected = starTrackerOvercurrentDetected; + } + + public boolean isStartrackerMatchError() { + return startrackerMatchError; + } + + public void setStartrackerMatchError(boolean startrackerMatchError) { + this.startrackerMatchError = startrackerMatchError; + } + + public boolean isCoarseSunSensorError() { + return coarseSunSensorError; + } + + public void setCoarseSunSensorError(boolean coarseSunSensorError) { + this.coarseSunSensorError = coarseSunSensorError; + } + + public boolean isWheelSpeedRangeError() { + return wheelSpeedRangeError; + } + + public void setWheelSpeedRangeError(boolean wheelSpeedRangeError) { + this.wheelSpeedRangeError = wheelSpeedRangeError; + } + + public boolean isRateSensorRangeError() { + return rateSensorRangeError; + } + + public void setRateSensorRangeError(boolean rateSensorRangeError) { + this.rateSensorRangeError = rateSensorRangeError; + } + + public boolean isNadirSensorRangeError() { + return nadirSensorRangeError; + } + + public void setNadirSensorRangeError(boolean nadirSensorRangeError) { + this.nadirSensorRangeError = nadirSensorRangeError; + } + + public boolean isCam2SensorDetectionError() { + return cam2SensorDetectionError; + } + + public void setCam2SensorDetectionError(boolean cam2SensorDetectionError) { + this.cam2SensorDetectionError = cam2SensorDetectionError; + } + + public boolean isCam2SensorBusyError() { + return cam2SensorBusyError; + } + + public void setCam2SensorBusyError(boolean cam2SensorBusyError) { + this.cam2SensorBusyError = cam2SensorBusyError; + } + + public float getCubecontrlCur3v3() { + return cubecontrlCur3v3; + } + + public void setCubecontrlCur3v3(float cubecontrlCur3v3) { + this.cubecontrlCur3v3 = cubecontrlCur3v3; + } + + public float getCubecontrlCur5v() { + return cubecontrlCur5v; + } + + public void setCubecontrlCur5v(float cubecontrlCur5v) { + this.cubecontrlCur5v = cubecontrlCur5v; + } + + public float getCubecontrolCurVbat() { + return cubecontrolCurVbat; + } + + public void setCubecontrolCurVbat(float cubecontrolCurVbat) { + this.cubecontrolCurVbat = cubecontrolCurVbat; + } + + public float getFineEstAngRatesX() { + return fineEstAngRatesX; + } + + public void setFineEstAngRatesX(float fineEstAngRatesX) { + this.fineEstAngRatesX = fineEstAngRatesX; + } + + public float getFineEstAngRatesY() { + return fineEstAngRatesY; + } + + public void setFineEstAngRatesY(float fineEstAngRatesY) { + this.fineEstAngRatesY = fineEstAngRatesY; + } + + public float getFineEstAngRatesZ() { + return fineEstAngRatesZ; + } + + public void setFineEstAngRatesZ(float fineEstAngRatesZ) { + this.fineEstAngRatesZ = fineEstAngRatesZ; + } + + public float getFineSvX() { + return fineSvX; + } + + public void setFineSvX(float fineSvX) { + this.fineSvX = fineSvX; + } + + public float getFineSvY() { + return fineSvY; + } + + public void setFineSvY(float fineSvY) { + this.fineSvY = fineSvY; + } + + public float getFineSvZ() { + return fineSvZ; + } + + public void setFineSvZ(float fineSvZ) { + this.fineSvZ = fineSvZ; + } + + public float getMcuTempa() { + return mcuTempa; + } + + public void setMcuTempa(float mcuTempa) { + this.mcuTempa = mcuTempa; + } + + public float getTempMag() { + return tempMag; + } + + public void setTempMag(float tempMag) { + this.tempMag = tempMag; + } + + public float getTempRedmag() { + return tempRedmag; + } + + public void setTempRedmag(float tempRedmag) { + this.tempRedmag = tempRedmag; + } + + public float getWheel1Current() { + return wheel1Current; + } + + public void setWheel1Current(float wheel1Current) { + this.wheel1Current = wheel1Current; + } + + public float getWheel2Current() { + return wheel2Current; + } + + public void setWheel2Current(float wheel2Current) { + this.wheel2Current = wheel2Current; + } + + public float getWheel3Current() { + return wheel3Current; + } + + public void setWheel3Current(float wheel3Current) { + this.wheel3Current = wheel3Current; + } + + public float getMagnetorquerCurrent() { + return magnetorquerCurrent; + } + + public void setMagnetorquerCurrent(float magnetorquerCurrent) { + this.magnetorquerCurrent = magnetorquerCurrent; + } + + public float getCubesenes13v3Current() { + return cubesenes13v3Current; + } + + public void setCubesenes13v3Current(float cubesenes13v3Current) { + this.cubesenes13v3Current = cubesenes13v3Current; + } + + public float getCubesenes1SramCurrent() { + return cubesenes1SramCurrent; + } + + public void setCubesenes1SramCurrent(float cubesenes1SramCurrent) { + this.cubesenes1SramCurrent = cubesenes1SramCurrent; + } + + public float getCubesenes23v3Current() { + return cubesenes23v3Current; + } + + public void setCubesenes23v3Current(float cubesenes23v3Current) { + this.cubesenes23v3Current = cubesenes23v3Current; + } + + public float getCubesenes2SramCurrent() { + return cubesenes2SramCurrent; + } + + public void setCubesenes2SramCurrent(float cubesenes2SramCurrent) { + this.cubesenes2SramCurrent = cubesenes2SramCurrent; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/Battery.java b/src/main/java/ru/r2cloud/jradio/dora/Battery.java new file mode 100644 index 00000000..99b77b59 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/Battery.java @@ -0,0 +1,119 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.util.BitInputStream; + +public class Battery { + + private float motherboardTemperature; + private float outputVoltageBattery; + private float currentMagnitude; + private float daughterTemp1; + private float daughterTemp2; + private float daughterTemp3; + private boolean heaterStatus1; + private boolean heaterStatus2; + private boolean heaterStatus3; + private int currentDirection; + + public Battery() { + // do nothing + } + + public Battery(DataInputStream dis) throws IOException { + motherboardTemperature = dis.readUnsignedShort() * 0.372434f - 273.15f; + outputVoltageBattery = dis.readUnsignedShort() * 0.008993f; + currentMagnitude = dis.readUnsignedShort() * 14.662757f; + daughterTemp1 = dis.readUnsignedShort() * 0.397600f - 238.57f; + daughterTemp2 = dis.readUnsignedShort() * 0.397600f - 238.57f; + daughterTemp3 = dis.readUnsignedShort() * 0.397600f - 238.57f; + BitInputStream bis = new BitInputStream(dis); + heaterStatus1 = bis.readBoolean(); + heaterStatus2 = bis.readBoolean(); + heaterStatus3 = bis.readBoolean(); + currentDirection = bis.readUnsignedInt(5); + } + + public float getMotherboardTemperature() { + return motherboardTemperature; + } + + public void setMotherboardTemperature(float motherboardTemperature) { + this.motherboardTemperature = motherboardTemperature; + } + + public float getOutputVoltageBattery() { + return outputVoltageBattery; + } + + public void setOutputVoltageBattery(float outputVoltageBattery) { + this.outputVoltageBattery = outputVoltageBattery; + } + + public float getCurrentMagnitude() { + return currentMagnitude; + } + + public void setCurrentMagnitude(float currentMagnitude) { + this.currentMagnitude = currentMagnitude; + } + + public float getDaughterTemp1() { + return daughterTemp1; + } + + public void setDaughterTemp1(float daughterTemp1) { + this.daughterTemp1 = daughterTemp1; + } + + public float getDaughterTemp2() { + return daughterTemp2; + } + + public void setDaughterTemp2(float daughterTemp2) { + this.daughterTemp2 = daughterTemp2; + } + + public float getDaughterTemp3() { + return daughterTemp3; + } + + public void setDaughterTemp3(float daughterTemp3) { + this.daughterTemp3 = daughterTemp3; + } + + public boolean isHeaterStatus1() { + return heaterStatus1; + } + + public void setHeaterStatus1(boolean heaterStatus1) { + this.heaterStatus1 = heaterStatus1; + } + + public boolean isHeaterStatus2() { + return heaterStatus2; + } + + public void setHeaterStatus2(boolean heaterStatus2) { + this.heaterStatus2 = heaterStatus2; + } + + public boolean isHeaterStatus3() { + return heaterStatus3; + } + + public void setHeaterStatus3(boolean heaterStatus3) { + this.heaterStatus3 = heaterStatus3; + } + + public int getCurrentDirection() { + return currentDirection; + } + + public void setCurrentDirection(int currentDirection) { + this.currentDirection = currentDirection; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/DoraBeacon.java b/src/main/java/ru/r2cloud/jradio/dora/DoraBeacon.java new file mode 100644 index 00000000..735a6616 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/DoraBeacon.java @@ -0,0 +1,77 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.ccsds.PacketPrimaryHeader; +import ru.r2cloud.jradio.fec.ccsds.UncorrectableException; +import ru.r2cloud.jradio.openlst.OpenLstBeacon; +import ru.r2cloud.jradio.util.BitInputStream; + +public class DoraBeacon extends OpenLstBeacon { + + private String callsign; + private PacketPrimaryHeader header; + private FirstPacket first; + private SecondPacket second; + private byte[] unknownPayload; + + @Override + public void readBeacon(DataInputStream dis) throws IOException, UncorrectableException { + dis.skipBytes(1); // system_byte + byte[] callsignBytes = new byte[6]; + dis.readFully(callsignBytes); + callsign = new String(callsignBytes); + dis.skipBytes(4); // sync bytes + header = new PacketPrimaryHeader(new BitInputStream(dis)); + if (header.getSequenceFlag() == 1) { + first = new FirstPacket(dis); + } else if (header.getSequenceFlag() == 2) { + second = new SecondPacket(dis); + } else { + unknownPayload = new byte[dis.available() - 2]; + dis.readFully(unknownPayload); + } + } + + public String getCallsign() { + return callsign; + } + + public void setCallsign(String callsign) { + this.callsign = callsign; + } + + public PacketPrimaryHeader getHeader() { + return header; + } + + public void setHeader(PacketPrimaryHeader header) { + this.header = header; + } + + public FirstPacket getFirst() { + return first; + } + + public void setFirst(FirstPacket first) { + this.first = first; + } + + public SecondPacket getSecond() { + return second; + } + + public void setSecond(SecondPacket second) { + this.second = second; + } + + public byte[] getUnknownPayload() { + return unknownPayload; + } + + public void setUnknownPayload(byte[] unknownPayload) { + this.unknownPayload = unknownPayload; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/Eps.java b/src/main/java/ru/r2cloud/jradio/dora/Eps.java new file mode 100644 index 00000000..eddefd50 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/Eps.java @@ -0,0 +1,339 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.util.BitInputStream; + +public class Eps { + + private float outputVoltageBattery; + private float outputCurrentBattery; + private float bcrOutputCurrent; + private float motherboardTemperature; + private int actualPdmStatesUnused; + private boolean sdrActualSwitchState; + private boolean cm4PdmActualSwitchState; + private boolean sipmPdmActualSwitchState; + private int pdmActualSwitchStateUnused2; + private float daughterboardTemperature; + private float outputCurrent5v; + private float outputVoltage5v; + private float outputCurrent3v3; + private float outputVoltage3v3; + private float outputVoltageSwitch5; + private float outputCurrentSwitch5; + private float outputVoltageSwitch6; + private float outputCurrentSwitch6; + private float outputVoltageSwitch7; + private float outputCurrentSwitch7; + private float voltageFeedingBcr6; + private float currentBcr6ConnectorSa6a; + private float currentBcr6ConnectorSa6b; + private float voltageFeedingBcr7; + private float currentBcr7ConnectorSa7a; + private float currentBcr7ConnectorSa7b; + private float voltageFeedingBcr8; + private float currentBcr8ConnectorSa8a; + private float currentBcr8ConnectorSa8b; + private float voltageFeedingBcr9; + private float currentBcr9ConnectorSa9a; + private float currentBcr9ConnectorSa9b; + + public Eps() { + // do nothing + } + + public Eps(DataInputStream dis) throws IOException { + outputVoltageBattery = dis.readUnsignedShort() * 0.008978f; + outputCurrentBattery = dis.readUnsignedShort() * 0.00681988679f; + bcrOutputCurrent = dis.readUnsignedShort() * 0.014662757f; + motherboardTemperature = dis.readUnsignedShort() * 0.372434f - 273.15f; + actualPdmStatesUnused = dis.readUnsignedByte(); + BitInputStream bis = new BitInputStream(dis); + sdrActualSwitchState = bis.readBoolean(); + cm4PdmActualSwitchState = bis.readBoolean(); + sipmPdmActualSwitchState = bis.readBoolean(); + pdmActualSwitchStateUnused2 = bis.readUnsignedInt(5); + daughterboardTemperature = dis.readUnsignedShort() * 0.372434f - 273.15f; + outputCurrent5v = dis.readUnsignedShort() * 0.00681988679f; + outputVoltage5v = dis.readUnsignedShort() * 0.005865f; + outputCurrent3v3 = dis.readUnsignedShort() * 0.00681988679f; + outputVoltage3v3 = dis.readUnsignedShort() * 0.004311f; + outputVoltageSwitch5 = dis.readUnsignedShort() * 0.005865f; + outputCurrentSwitch5 = dis.readUnsignedShort() * 0.001328f; + outputVoltageSwitch6 = dis.readUnsignedShort() * 0.005865f; + outputCurrentSwitch6 = dis.readUnsignedShort() * 0.001328f; + outputVoltageSwitch7 = dis.readUnsignedShort() * 0.005865f; + outputCurrentSwitch7 = dis.readUnsignedShort() * 0.001328f; + voltageFeedingBcr6 = dis.readUnsignedShort() * 0.0322581f; + currentBcr6ConnectorSa6a = dis.readUnsignedShort() * 0.0009775f; + currentBcr6ConnectorSa6b = dis.readUnsignedShort() * 0.0009775f; + voltageFeedingBcr7 = dis.readUnsignedShort() * 0.0322581f; + currentBcr7ConnectorSa7a = dis.readUnsignedShort() * 0.0009775f; + currentBcr7ConnectorSa7b = dis.readUnsignedShort() * 0.0009775f; + voltageFeedingBcr8 = dis.readUnsignedShort() * 0.0322581f; + currentBcr8ConnectorSa8a = dis.readUnsignedShort() * 0.0009775f; + currentBcr8ConnectorSa8b = dis.readUnsignedShort() * 0.0009775f; + voltageFeedingBcr9 = dis.readUnsignedShort() * 0.0322581f; + currentBcr9ConnectorSa9a = dis.readUnsignedShort() * 0.0009775f; + currentBcr9ConnectorSa9b = dis.readUnsignedShort() * 0.0009775f; + } + + public float getOutputVoltageBattery() { + return outputVoltageBattery; + } + + public void setOutputVoltageBattery(float outputVoltageBattery) { + this.outputVoltageBattery = outputVoltageBattery; + } + + public float getOutputCurrentBattery() { + return outputCurrentBattery; + } + + public void setOutputCurrentBattery(float outputCurrentBattery) { + this.outputCurrentBattery = outputCurrentBattery; + } + + public float getBcrOutputCurrent() { + return bcrOutputCurrent; + } + + public void setBcrOutputCurrent(float bcrOutputCurrent) { + this.bcrOutputCurrent = bcrOutputCurrent; + } + + public float getMotherboardTemperature() { + return motherboardTemperature; + } + + public void setMotherboardTemperature(float motherboardTemperature) { + this.motherboardTemperature = motherboardTemperature; + } + + public int getActualPdmStatesUnused() { + return actualPdmStatesUnused; + } + + public void setActualPdmStatesUnused(int actualPdmStatesUnused) { + this.actualPdmStatesUnused = actualPdmStatesUnused; + } + + public boolean isSdrActualSwitchState() { + return sdrActualSwitchState; + } + + public void setSdrActualSwitchState(boolean sdrActualSwitchState) { + this.sdrActualSwitchState = sdrActualSwitchState; + } + + public boolean isCm4PdmActualSwitchState() { + return cm4PdmActualSwitchState; + } + + public void setCm4PdmActualSwitchState(boolean cm4PdmActualSwitchState) { + this.cm4PdmActualSwitchState = cm4PdmActualSwitchState; + } + + public boolean isSipmPdmActualSwitchState() { + return sipmPdmActualSwitchState; + } + + public void setSipmPdmActualSwitchState(boolean sipmPdmActualSwitchState) { + this.sipmPdmActualSwitchState = sipmPdmActualSwitchState; + } + + public int getPdmActualSwitchStateUnused2() { + return pdmActualSwitchStateUnused2; + } + + public void setPdmActualSwitchStateUnused2(int pdmActualSwitchStateUnused2) { + this.pdmActualSwitchStateUnused2 = pdmActualSwitchStateUnused2; + } + + public float getDaughterboardTemperature() { + return daughterboardTemperature; + } + + public void setDaughterboardTemperature(float daughterboardTemperature) { + this.daughterboardTemperature = daughterboardTemperature; + } + + public float getOutputCurrent5v() { + return outputCurrent5v; + } + + public void setOutputCurrent5v(float outputCurrent5v) { + this.outputCurrent5v = outputCurrent5v; + } + + public float getOutputVoltage5v() { + return outputVoltage5v; + } + + public void setOutputVoltage5v(float outputVoltage5v) { + this.outputVoltage5v = outputVoltage5v; + } + + public float getOutputCurrent3v3() { + return outputCurrent3v3; + } + + public void setOutputCurrent3v3(float outputCurrent3v3) { + this.outputCurrent3v3 = outputCurrent3v3; + } + + public float getOutputVoltage3v3() { + return outputVoltage3v3; + } + + public void setOutputVoltage3v3(float outputVoltage3v3) { + this.outputVoltage3v3 = outputVoltage3v3; + } + + public float getOutputVoltageSwitch5() { + return outputVoltageSwitch5; + } + + public void setOutputVoltageSwitch5(float outputVoltageSwitch5) { + this.outputVoltageSwitch5 = outputVoltageSwitch5; + } + + public float getOutputCurrentSwitch5() { + return outputCurrentSwitch5; + } + + public void setOutputCurrentSwitch5(float outputCurrentSwitch5) { + this.outputCurrentSwitch5 = outputCurrentSwitch5; + } + + public float getOutputVoltageSwitch6() { + return outputVoltageSwitch6; + } + + public void setOutputVoltageSwitch6(float outputVoltageSwitch6) { + this.outputVoltageSwitch6 = outputVoltageSwitch6; + } + + public float getOutputCurrentSwitch6() { + return outputCurrentSwitch6; + } + + public void setOutputCurrentSwitch6(float outputCurrentSwitch6) { + this.outputCurrentSwitch6 = outputCurrentSwitch6; + } + + public float getOutputVoltageSwitch7() { + return outputVoltageSwitch7; + } + + public void setOutputVoltageSwitch7(float outputVoltageSwitch7) { + this.outputVoltageSwitch7 = outputVoltageSwitch7; + } + + public float getOutputCurrentSwitch7() { + return outputCurrentSwitch7; + } + + public void setOutputCurrentSwitch7(float outputCurrentSwitch7) { + this.outputCurrentSwitch7 = outputCurrentSwitch7; + } + + public float getVoltageFeedingBcr6() { + return voltageFeedingBcr6; + } + + public void setVoltageFeedingBcr6(float voltageFeedingBcr6) { + this.voltageFeedingBcr6 = voltageFeedingBcr6; + } + + public float getCurrentBcr6ConnectorSa6a() { + return currentBcr6ConnectorSa6a; + } + + public void setCurrentBcr6ConnectorSa6a(float currentBcr6ConnectorSa6a) { + this.currentBcr6ConnectorSa6a = currentBcr6ConnectorSa6a; + } + + public float getCurrentBcr6ConnectorSa6b() { + return currentBcr6ConnectorSa6b; + } + + public void setCurrentBcr6ConnectorSa6b(float currentBcr6ConnectorSa6b) { + this.currentBcr6ConnectorSa6b = currentBcr6ConnectorSa6b; + } + + public float getVoltageFeedingBcr7() { + return voltageFeedingBcr7; + } + + public void setVoltageFeedingBcr7(float voltageFeedingBcr7) { + this.voltageFeedingBcr7 = voltageFeedingBcr7; + } + + public float getCurrentBcr7ConnectorSa7a() { + return currentBcr7ConnectorSa7a; + } + + public void setCurrentBcr7ConnectorSa7a(float currentBcr7ConnectorSa7a) { + this.currentBcr7ConnectorSa7a = currentBcr7ConnectorSa7a; + } + + public float getCurrentBcr7ConnectorSa7b() { + return currentBcr7ConnectorSa7b; + } + + public void setCurrentBcr7ConnectorSa7b(float currentBcr7ConnectorSa7b) { + this.currentBcr7ConnectorSa7b = currentBcr7ConnectorSa7b; + } + + public float getVoltageFeedingBcr8() { + return voltageFeedingBcr8; + } + + public void setVoltageFeedingBcr8(float voltageFeedingBcr8) { + this.voltageFeedingBcr8 = voltageFeedingBcr8; + } + + public float getCurrentBcr8ConnectorSa8a() { + return currentBcr8ConnectorSa8a; + } + + public void setCurrentBcr8ConnectorSa8a(float currentBcr8ConnectorSa8a) { + this.currentBcr8ConnectorSa8a = currentBcr8ConnectorSa8a; + } + + public float getCurrentBcr8ConnectorSa8b() { + return currentBcr8ConnectorSa8b; + } + + public void setCurrentBcr8ConnectorSa8b(float currentBcr8ConnectorSa8b) { + this.currentBcr8ConnectorSa8b = currentBcr8ConnectorSa8b; + } + + public float getVoltageFeedingBcr9() { + return voltageFeedingBcr9; + } + + public void setVoltageFeedingBcr9(float voltageFeedingBcr9) { + this.voltageFeedingBcr9 = voltageFeedingBcr9; + } + + public float getCurrentBcr9ConnectorSa9a() { + return currentBcr9ConnectorSa9a; + } + + public void setCurrentBcr9ConnectorSa9a(float currentBcr9ConnectorSa9a) { + this.currentBcr9ConnectorSa9a = currentBcr9ConnectorSa9a; + } + + public float getCurrentBcr9ConnectorSa9b() { + return currentBcr9ConnectorSa9b; + } + + public void setCurrentBcr9ConnectorSa9b(float currentBcr9ConnectorSa9b) { + this.currentBcr9ConnectorSa9b = currentBcr9ConnectorSa9b; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/FirstPacket.java b/src/main/java/ru/r2cloud/jradio/dora/FirstPacket.java new file mode 100644 index 00000000..cbb338ec --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/FirstPacket.java @@ -0,0 +1,128 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.util.StreamUtils; + +public class FirstPacket { + + private long timestamp; + private long missionticks; + private int state; + private long receivedPackets; + private int lastLoggedErrorThread; + private int lastLoggedErrorCode; + private long obcRebootCount; + private Adcs adcs; + private Eps eps; + private Battery battery; + private Payload1 payload1; + + public FirstPacket() { + // do nothing + } + + public FirstPacket(DataInputStream dis) throws IOException { + timestamp = dis.readLong(); + missionticks = dis.readLong() & 0xFFFFFFFFFFFFL; + state = dis.readUnsignedByte(); + receivedPackets = StreamUtils.readUnsignedInt(dis); + lastLoggedErrorThread = dis.readUnsignedByte(); + lastLoggedErrorCode = dis.readUnsignedByte(); + obcRebootCount = StreamUtils.readUnsignedInt(dis); + adcs = new Adcs(dis); + eps = new Eps(dis); + battery = new Battery(dis); + payload1 = new Payload1(dis); + } + + public long getTimestamp() { + return timestamp; + } + + public void setTimestamp(long timestamp) { + this.timestamp = timestamp; + } + + public long getMissionticks() { + return missionticks; + } + + public void setMissionticks(long missionticks) { + this.missionticks = missionticks; + } + + public int getState() { + return state; + } + + public void setState(int state) { + this.state = state; + } + + public long getReceivedPackets() { + return receivedPackets; + } + + public void setReceivedPackets(long receivedPackets) { + this.receivedPackets = receivedPackets; + } + + public int getLastLoggedErrorThread() { + return lastLoggedErrorThread; + } + + public void setLastLoggedErrorThread(int lastLoggedErrorThread) { + this.lastLoggedErrorThread = lastLoggedErrorThread; + } + + public int getLastLoggedErrorCode() { + return lastLoggedErrorCode; + } + + public void setLastLoggedErrorCode(int lastLoggedErrorCode) { + this.lastLoggedErrorCode = lastLoggedErrorCode; + } + + public long getObcRebootCount() { + return obcRebootCount; + } + + public void setObcRebootCount(long obcRebootCount) { + this.obcRebootCount = obcRebootCount; + } + + public Adcs getAdcs() { + return adcs; + } + + public void setAdcs(Adcs adcs) { + this.adcs = adcs; + } + + public Eps getEps() { + return eps; + } + + public void setEps(Eps eps) { + this.eps = eps; + } + + public Battery getBattery() { + return battery; + } + + public void setBattery(Battery battery) { + this.battery = battery; + } + + public Payload1 getPayload1() { + return payload1; + } + + public void setPayload1(Payload1 payload1) { + this.payload1 = payload1; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/Payload1.java b/src/main/java/ru/r2cloud/jradio/dora/Payload1.java new file mode 100644 index 00000000..60bad338 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/Payload1.java @@ -0,0 +1,158 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.util.StreamUtils; + +public class Payload1 { + + private int sipmAdcValue; + private int currentPayloadSchedule; + private long timestamp; + private int mode; + private long availableStorage; + private long availableMemory; + private long cpuLoad; + private long rpiUptime; + private long rebootCount; + private long numberOfReceivedCommands; + private int lastReceivedCommand; + private long errorCount; + private int filterBankPowerCh1; + private int filterBankPowerCh2; + + public Payload1() { + // do nothing + } + + public Payload1(DataInputStream dis) throws IOException { + sipmAdcValue = dis.readUnsignedShort(); + currentPayloadSchedule = dis.readUnsignedShort(); + timestamp = dis.readLong() & 0xFFFFFFFFL; + mode = dis.readUnsignedByte(); + availableStorage = StreamUtils.readUnsignedInt(dis); + availableMemory = StreamUtils.readUnsignedInt(dis); + cpuLoad = StreamUtils.readUnsignedInt(dis); + rpiUptime = StreamUtils.readUnsignedInt(dis); + rebootCount = StreamUtils.readUnsignedInt(dis); + numberOfReceivedCommands = StreamUtils.readUnsignedInt(dis); + lastReceivedCommand = dis.readUnsignedByte(); + errorCount = StreamUtils.readUnsignedInt(dis); + filterBankPowerCh1 = dis.readUnsignedByte(); + filterBankPowerCh2 = dis.readUnsignedByte(); + } + + public int getSipmAdcValue() { + return sipmAdcValue; + } + + public void setSipmAdcValue(int sipmAdcValue) { + this.sipmAdcValue = sipmAdcValue; + } + + public int getCurrentPayloadSchedule() { + return currentPayloadSchedule; + } + + public void setCurrentPayloadSchedule(int currentPayloadSchedule) { + this.currentPayloadSchedule = currentPayloadSchedule; + } + + public long getTimestamp() { + return timestamp; + } + + public void setTimestamp(long timestamp) { + this.timestamp = timestamp; + } + + public int getMode() { + return mode; + } + + public void setMode(int mode) { + this.mode = mode; + } + + public long getAvailableStorage() { + return availableStorage; + } + + public void setAvailableStorage(long availableStorage) { + this.availableStorage = availableStorage; + } + + public long getAvailableMemory() { + return availableMemory; + } + + public void setAvailableMemory(long availableMemory) { + this.availableMemory = availableMemory; + } + + public long getCpuLoad() { + return cpuLoad; + } + + public void setCpuLoad(long cpuLoad) { + this.cpuLoad = cpuLoad; + } + + public long getRpiUptime() { + return rpiUptime; + } + + public void setRpiUptime(long rpiUptime) { + this.rpiUptime = rpiUptime; + } + + public long getRebootCount() { + return rebootCount; + } + + public void setRebootCount(long rebootCount) { + this.rebootCount = rebootCount; + } + + public long getNumberOfReceivedCommands() { + return numberOfReceivedCommands; + } + + public void setNumberOfReceivedCommands(long numberOfReceivedCommands) { + this.numberOfReceivedCommands = numberOfReceivedCommands; + } + + public int getLastReceivedCommand() { + return lastReceivedCommand; + } + + public void setLastReceivedCommand(int lastReceivedCommand) { + this.lastReceivedCommand = lastReceivedCommand; + } + + public long getErrorCount() { + return errorCount; + } + + public void setErrorCount(long errorCount) { + this.errorCount = errorCount; + } + + public int getFilterBankPowerCh1() { + return filterBankPowerCh1; + } + + public void setFilterBankPowerCh1(int filterBankPowerCh1) { + this.filterBankPowerCh1 = filterBankPowerCh1; + } + + public int getFilterBankPowerCh2() { + return filterBankPowerCh2; + } + + public void setFilterBankPowerCh2(int filterBankPowerCh2) { + this.filterBankPowerCh2 = filterBankPowerCh2; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/Payload2.java b/src/main/java/ru/r2cloud/jradio/dora/Payload2.java new file mode 100644 index 00000000..53d8bab7 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/Payload2.java @@ -0,0 +1,186 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +public class Payload2 { + + private int filterBankPowerCh3; + private int filterBankPowerCh4; + private int filterBankPowerCh5; + private int filterBankPowerCh6; + private int filterBankPowerCh7; + private int filterBankPowerCh8; + private int sdrPower; + private int sdrBright1; + private int sdrBright2; + private int sdrBright3; + private int sdrBright4; + private int sdrBright5; + private int sdrBright6; + private int sdrBright7; + private int sdrBright8; + private int sdrBright9; + private int sdrBright10; + + public Payload2() { + // do nothing + } + + public Payload2(DataInputStream dis) throws IOException { + filterBankPowerCh3 = dis.readUnsignedByte(); + filterBankPowerCh4 = dis.readUnsignedByte(); + filterBankPowerCh5 = dis.readUnsignedByte(); + filterBankPowerCh6 = dis.readUnsignedByte(); + filterBankPowerCh7 = dis.readUnsignedByte(); + filterBankPowerCh8 = dis.readUnsignedByte(); + sdrPower = dis.readUnsignedShort(); + sdrBright1 = dis.readUnsignedShort(); + sdrBright2 = dis.readUnsignedShort(); + sdrBright3 = dis.readUnsignedShort(); + sdrBright4 = dis.readUnsignedShort(); + sdrBright5 = dis.readUnsignedShort(); + sdrBright6 = dis.readUnsignedShort(); + sdrBright7 = dis.readUnsignedShort(); + sdrBright8 = dis.readUnsignedShort(); + sdrBright9 = dis.readUnsignedShort(); + sdrBright10 = dis.readUnsignedShort(); + } + + public int getFilterBankPowerCh3() { + return filterBankPowerCh3; + } + + public void setFilterBankPowerCh3(int filterBankPowerCh3) { + this.filterBankPowerCh3 = filterBankPowerCh3; + } + + public int getFilterBankPowerCh4() { + return filterBankPowerCh4; + } + + public void setFilterBankPowerCh4(int filterBankPowerCh4) { + this.filterBankPowerCh4 = filterBankPowerCh4; + } + + public int getFilterBankPowerCh5() { + return filterBankPowerCh5; + } + + public void setFilterBankPowerCh5(int filterBankPowerCh5) { + this.filterBankPowerCh5 = filterBankPowerCh5; + } + + public int getFilterBankPowerCh6() { + return filterBankPowerCh6; + } + + public void setFilterBankPowerCh6(int filterBankPowerCh6) { + this.filterBankPowerCh6 = filterBankPowerCh6; + } + + public int getFilterBankPowerCh7() { + return filterBankPowerCh7; + } + + public void setFilterBankPowerCh7(int filterBankPowerCh7) { + this.filterBankPowerCh7 = filterBankPowerCh7; + } + + public int getFilterBankPowerCh8() { + return filterBankPowerCh8; + } + + public void setFilterBankPowerCh8(int filterBankPowerCh8) { + this.filterBankPowerCh8 = filterBankPowerCh8; + } + + public int getSdrPower() { + return sdrPower; + } + + public void setSdrPower(int sdrPower) { + this.sdrPower = sdrPower; + } + + public int getSdrBright1() { + return sdrBright1; + } + + public void setSdrBright1(int sdrBright1) { + this.sdrBright1 = sdrBright1; + } + + public int getSdrBright2() { + return sdrBright2; + } + + public void setSdrBright2(int sdrBright2) { + this.sdrBright2 = sdrBright2; + } + + public int getSdrBright3() { + return sdrBright3; + } + + public void setSdrBright3(int sdrBright3) { + this.sdrBright3 = sdrBright3; + } + + public int getSdrBright4() { + return sdrBright4; + } + + public void setSdrBright4(int sdrBright4) { + this.sdrBright4 = sdrBright4; + } + + public int getSdrBright5() { + return sdrBright5; + } + + public void setSdrBright5(int sdrBright5) { + this.sdrBright5 = sdrBright5; + } + + public int getSdrBright6() { + return sdrBright6; + } + + public void setSdrBright6(int sdrBright6) { + this.sdrBright6 = sdrBright6; + } + + public int getSdrBright7() { + return sdrBright7; + } + + public void setSdrBright7(int sdrBright7) { + this.sdrBright7 = sdrBright7; + } + + public int getSdrBright8() { + return sdrBright8; + } + + public void setSdrBright8(int sdrBright8) { + this.sdrBright8 = sdrBright8; + } + + public int getSdrBright9() { + return sdrBright9; + } + + public void setSdrBright9(int sdrBright9) { + this.sdrBright9 = sdrBright9; + } + + public int getSdrBright10() { + return sdrBright10; + } + + public void setSdrBright10(int sdrBright10) { + this.sdrBright10 = sdrBright10; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/dora/SecondPacket.java b/src/main/java/ru/r2cloud/jradio/dora/SecondPacket.java new file mode 100644 index 00000000..55288893 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/dora/SecondPacket.java @@ -0,0 +1,26 @@ +package ru.r2cloud.jradio.dora; + +import java.io.DataInputStream; +import java.io.IOException; + +public class SecondPacket { + + private Payload2 payload2; + + public SecondPacket() { + // do nothing + } + + public SecondPacket(DataInputStream dis) throws IOException { + payload2 = new Payload2(dis); + } + + public Payload2 getPayload2() { + return payload2; + } + + public void setPayload2(Payload2 payload2) { + this.payload2 = payload2; + } + +} diff --git a/src/test/java/ru/r2cloud/jradio/dora/DoraBeaconTest.java b/src/test/java/ru/r2cloud/jradio/dora/DoraBeaconTest.java new file mode 100644 index 00000000..411209ea --- /dev/null +++ b/src/test/java/ru/r2cloud/jradio/dora/DoraBeaconTest.java @@ -0,0 +1,35 @@ +package ru.r2cloud.jradio.dora; + +import static com.google.code.beanmatchers.BeanMatchers.hasValidBeanConstructor; +import static com.google.code.beanmatchers.BeanMatchers.hasValidGettersAndSetters; +import static org.hamcrest.CoreMatchers.allOf; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.Test; + +import ru.r2cloud.jradio.AssertJson; +import ru.r2cloud.jradio.fec.ViterbiTest; + +public class DoraBeaconTest { + + @Test + public void testSecondPacket() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray("400000004b4537444851352ef85300038001001bffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d00"); + DoraBeacon result = new DoraBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("DoraSecondPacket.json", result); + } + + @Test + public void testPojo() { + assertThat(DoraBeacon.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Eps.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Battery.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Payload1.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Payload2.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(FirstPacket.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(SecondPacket.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + } + +} diff --git a/src/test/java/ru/r2cloud/jradio/openlst/OpenLstBeaconSourceTest.java b/src/test/java/ru/r2cloud/jradio/openlst/OpenLstBeaconSourceTest.java index e4e44139..011a338a 100644 --- a/src/test/java/ru/r2cloud/jradio/openlst/OpenLstBeaconSourceTest.java +++ b/src/test/java/ru/r2cloud/jradio/openlst/OpenLstBeaconSourceTest.java @@ -7,17 +7,18 @@ import ru.r2cloud.jradio.AssertJson; import ru.r2cloud.jradio.demod.FskDemodulator; +import ru.r2cloud.jradio.dora.DoraBeacon; import ru.r2cloud.jradio.source.WavFileSource; public class OpenLstBeaconSourceTest { - private OpenLstBeaconSource input; + private OpenLstBeaconSource input; @Test public void testDecodeTelemetry() throws Exception { WavFileSource source = new WavFileSource(OpenLstBeaconSourceTest.class.getClassLoader().getResourceAsStream("dora.wav")); FskDemodulator demod = new FskDemodulator(source, 7416); - input = new OpenLstBeaconSource<>(demod, OpenLstBeacon.class); + input = new OpenLstBeaconSource<>(demod, DoraBeacon.class); assertTrue(input.hasNext()); AssertJson.assertObjectsEqual("Dora.json", input.next()); } diff --git a/src/test/resources/expected/Dora.json b/src/test/resources/expected/Dora.json index 45a0974a..36715c4b 100644 --- a/src/test/resources/expected/Dora.json +++ b/src/test/resources/expected/Dora.json @@ -1,216 +1,154 @@ { + "callsign": "KE7DHQ", + "header": { + "packetVersion": 0, + "packetType": 0, + "secondaryHeader": false, + "applicationProcessId": 3, + "sequenceFlag": 1, + "packetName": 12087, + "packetDataLength": 189 + }, + "first": { + "timestamp": 1728640747, + "missionticks": 254970908, + "state": 1, + "receivedPackets": 33, + "lastLoggedErrorThread": 11, + "lastLoggedErrorCode": 36, + "obcRebootCount": 11, + "adcs": { + "adcsCommissioningDone": true, + "adcsCurrentCommissioningState": 0, + "bootStatus": 1, + "bootCount": 17921, + "currentAdcsControlmode": 0, + "currentAdcsAttitudeestimation": 0, + "cubesense2Enabled": true, + "cubesense1Enabled": true, + "cubecontrolmotorEnabled": true, + "cubecontrolsignalEnabled": false, + "asgp4Mode": 0, + "currentadcsAdcsRunMode": false, + "sunIsAboveLocalHorizon": true, + "motorDriverEnabled": true, + "gpsLnaPowerEnabled": false, + "gpsReceiverEnable": false, + "cubestarEnabled": false, + "cubewheel3Enabled": false, + "cubewheel2Enabled": true, + "cubewheel1Enabled": true, + "cubestarCommsError": true, + "cubewheel3CommsError": false, + "cubewheel2CommsError": false, + "cubewheel1CommsError": false, + "cubecontrolMotorCommsError": false, + "cubecontrolSignalCommsError": false, + "cubesense2CommsError": false, + "cubesense1CommsError": false, + "cam23v3OvercurrentDetected": false, + "cam2SramOvercurrentDetected": false, + "sunSensorRangeError": false, + "cam1SensorDetectionError": true, + "cam1SensorBusyError": true, + "cam13v3OvercurrentDetected": false, + "cam1SramOvercurrentDetected": false, + "magnetometerRangeError": false, + "starTrackerOvercurrentDetected": false, + "startrackerMatchError": false, + "coarseSunSensorError": false, + "wheelSpeedRangeError": false, + "rateSensorRangeError": false, + "nadirSensorRangeError": false, + "cam2SensorDetectionError": true, + "cam2SensorBusyError": true, + "cubecontrlCur3v3": 0.0, + "cubecontrlCur5v": 0.0, + "cubecontrolCurVbat": 0.0, + "fineEstAngRatesX": 0.0, + "fineEstAngRatesY": 0.0, + "fineEstAngRatesZ": 0.0, + "fineSvX": 0.0, + "fineSvY": 0.0, + "fineSvZ": 0.0, + "mcuTempa": 2.3, + "tempMag": 0.0, + "tempRedmag": 0.0, + "wheel1Current": 5.8599997, + "wheel2Current": 5.8599997, + "wheel3Current": 5.37, + "magnetorquerCurrent": 1.1999999, + "cubesenes13v3Current": 1.7099999, + "cubesenes1SramCurrent": 0.099999994, + "cubesenes23v3Current": 1.77, + "cubesenes2SramCurrent": 0.19 + }, + "eps": { + "outputVoltageBattery": 7.8826838, + "outputCurrentBattery": 0.02045966, + "bcrOutputCurrent": 0.029325513, + "motherboardTemperature": 26.659363, + "actualPdmStatesUnused": 1, + "sdrActualSwitchState": false, + "cm4PdmActualSwitchState": false, + "sipmPdmActualSwitchState": false, + "pdmActualSwitchStateUnused2": 0, + "daughterboardTemperature": 30.756134, + "outputCurrent5v": 0.4637523, + "outputVoltage5v": 5.049765, + "outputCurrent3v3": 0.2591557, + "outputVoltage3v3": 3.336714, + "outputVoltageSwitch5": 0.017595, + "outputCurrentSwitch5": 0.002656, + "outputVoltageSwitch6": 0.01173, + "outputCurrentSwitch6": 0.003984, + "outputVoltageSwitch7": 0.01173, + "outputCurrentSwitch7": 0.003984, + "voltageFeedingBcr6": 2.7741966, + "currentBcr6ConnectorSa6a": 0.0029325, + "currentBcr6ConnectorSa6b": 0.001955, + "voltageFeedingBcr7": 6.9677496, + "currentBcr7ConnectorSa7a": 0.0087975, + "currentBcr7ConnectorSa7b": 0.001955, + "voltageFeedingBcr8": 2.3548415, + "currentBcr8ConnectorSa8a": 0.001955, + "currentBcr8ConnectorSa8b": 0.001955, + "voltageFeedingBcr9": 3.0000033, + "currentBcr9ConnectorSa9a": 0.0224825, + "currentBcr9ConnectorSa9b": 0.0029325 + }, + "battery": { + "motherboardTemperature": 26.659363, + "outputVoltageBattery": 7.940819, + "currentMagnitude": 175.95308, + "daughterTemp1": 25.833984, + "daughterTemp2": 25.038788, + "daughterTemp3": 27.026794, + "heaterStatus1": false, + "heaterStatus2": false, + "heaterStatus3": false, + "currentDirection": 0 + }, + "payload1": { + "sipmAdcValue": 985, + "currentPayloadSchedule": 0, + "timestamp": 4294967295, + "mode": 255, + "availableStorage": 4294967295, + "availableMemory": 4294967295, + "cpuLoad": 4294967295, + "rpiUptime": 4294967295, + "rebootCount": 4294967295, + "numberOfReceivedCommands": 4294967295, + "lastReceivedCommand": 255, + "errorCount": 4294967295, + "filterBankPowerCh1": 255, + "filterBankPowerCh2": 255 + } + }, "flags": 64, "seqnum": 0, "hwid": 3328, - "payload": [ - 0, - 75, - 69, - 55, - 68, - 72, - 81, - 53, - 46, - -8, - 83, - 0, - 3, - 111, - 55, - 0, - -67, - 0, - 0, - 0, - 0, - 103, - 8, - -10, - -21, - 0, - 0, - 0, - 0, - 15, - 50, - -116, - 28, - 1, - 0, - 0, - 0, - 33, - 11, - 36, - 0, - 0, - 0, - 11, - -128, - 1, - 70, - 1, - 0, - -31, - -121, - 0, - 48, - 6, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 23, - 0, - 0, - 0, - 0, - 0, - 74, - 2, - 74, - 2, - 25, - 2, - 120, - 0, - -85, - 0, - 10, - 0, - -79, - 0, - 19, - 0, - 3, - 110, - 0, - 3, - 0, - 2, - 3, - 37, - 1, - 0, - 3, - 48, - 0, - 68, - 3, - 93, - 0, - 38, - 3, - 6, - 0, - 3, - 0, - 2, - 0, - 2, - 0, - 3, - 0, - 2, - 0, - 3, - 0, - 86, - 0, - 3, - 0, - 2, - 0, - -40, - 0, - 9, - 0, - 2, - 0, - 73, - 0, - 2, - 0, - 2, - 0, - 93, - 0, - 23, - 0, - 3, - 3, - 37, - 3, - 115, - 0, - 12, - 2, - -103, - 2, - -105, - 2, - -100, - 0, - 3, - -39, - 0, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1 - ], "rawData": [ 64, 0, diff --git a/src/test/resources/expected/DoraSecondPacket.json b/src/test/resources/expected/DoraSecondPacket.json new file mode 100644 index 00000000..28590da3 --- /dev/null +++ b/src/test/resources/expected/DoraSecondPacket.json @@ -0,0 +1,39 @@ +{ + "callsign": "KE7DHQ", + "header": { + "packetVersion": 0, + "packetType": 0, + "secondaryHeader": false, + "applicationProcessId": 3, + "sequenceFlag": 2, + "packetName": 1, + "packetDataLength": 27 + }, + "second": { + "payload2": { + "filterBankPowerCh3": 255, + "filterBankPowerCh4": 255, + "filterBankPowerCh5": 255, + "filterBankPowerCh6": 255, + "filterBankPowerCh7": 255, + "filterBankPowerCh8": 255, + "sdrPower": 65535, + "sdrBright1": 65535, + "sdrBright2": 65535, + "sdrBright3": 65535, + "sdrBright4": 65535, + "sdrBright5": 65535, + "sdrBright6": 65535, + "sdrBright7": 65535, + "sdrBright8": 65535, + "sdrBright9": 65535, + "sdrBright10": 65535 + } + }, + "flags": 64, + "seqnum": 0, + "hwid": 3328, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file