diff --git a/README.md b/README.md index b73183bd..2e4f3ed7 100644 --- a/README.md +++ b/README.md @@ -604,6 +604,11 @@ jradio has lots of built-in satellite decoders. Some of them have non standard d 60237 ru.r2cloud.jradio.grbbeta.GRBBetaBeacon + + CatSat + 60246 + ru.r2cloud.jradio.catsat.CatsatBeacon + diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs0.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs0.java new file mode 100644 index 00000000..44cc5a4e --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs0.java @@ -0,0 +1,169 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs0 { + + private BeaconElementHeader hk41507; + private float[] extmag; + private float[] torquerDuty; + private BeaconElementHeader hk41517; + private float[] bdotRate; + private float[] bdotDmag; + private float[] bdotTorquer; + private int bdotDetumble; + private BeaconElementHeader hk41547; + private float[] ctrlRefq; + private float[] ctrlErrq; + private float[] ctrlM; + private float[] ctrlMwspeed; + private float[] ctrlEuleroff; + private float[] ctrlBtorque; + + public Adcs0() { + // do nothing + } + + public Adcs0(DataInputStream dis) throws IOException { + hk41507 = new BeaconElementHeader(dis); + extmag = StreamUtils.readFloatArray(dis, 3); + torquerDuty = StreamUtils.readFloatArray(dis, 3); + hk41517 = new BeaconElementHeader(dis); + bdotRate = StreamUtils.readFloatArray(dis, 2); + bdotDmag = StreamUtils.readFloatArray(dis, 3); + bdotTorquer = StreamUtils.readFloatArray(dis, 3); + bdotDetumble = dis.readUnsignedByte(); + hk41547 = new BeaconElementHeader(dis); + ctrlRefq = StreamUtils.readFloatArray(dis, 4); + ctrlErrq = StreamUtils.readFloatArray(dis, 4); + ctrlM = StreamUtils.readFloatArray(dis, 3); + ctrlMwspeed = StreamUtils.readFloatArray(dis, 4); + ctrlEuleroff = StreamUtils.readFloatArray(dis, 3); + ctrlBtorque = StreamUtils.readFloatArray(dis, 3); + } + + public BeaconElementHeader getHk41507() { + return hk41507; + } + + public void setHk41507(BeaconElementHeader hk41507) { + this.hk41507 = hk41507; + } + + public float[] getExtmag() { + return extmag; + } + + public void setExtmag(float[] extmag) { + this.extmag = extmag; + } + + public float[] getTorquerDuty() { + return torquerDuty; + } + + public void setTorquerDuty(float[] torquerDuty) { + this.torquerDuty = torquerDuty; + } + + public BeaconElementHeader getHk41517() { + return hk41517; + } + + public void setHk41517(BeaconElementHeader hk41517) { + this.hk41517 = hk41517; + } + + public float[] getBdotRate() { + return bdotRate; + } + + public void setBdotRate(float[] bdotRate) { + this.bdotRate = bdotRate; + } + + public float[] getBdotDmag() { + return bdotDmag; + } + + public void setBdotDmag(float[] bdotDmag) { + this.bdotDmag = bdotDmag; + } + + public float[] getBdotTorquer() { + return bdotTorquer; + } + + public void setBdotTorquer(float[] bdotTorquer) { + this.bdotTorquer = bdotTorquer; + } + + public int getBdotDetumble() { + return bdotDetumble; + } + + public void setBdotDetumble(int bdotDetumble) { + this.bdotDetumble = bdotDetumble; + } + + public BeaconElementHeader getHk41547() { + return hk41547; + } + + public void setHk41547(BeaconElementHeader hk41547) { + this.hk41547 = hk41547; + } + + public float[] getCtrlRefq() { + return ctrlRefq; + } + + public void setCtrlRefq(float[] ctrlRefq) { + this.ctrlRefq = ctrlRefq; + } + + public float[] getCtrlErrq() { + return ctrlErrq; + } + + public void setCtrlErrq(float[] ctrlErrq) { + this.ctrlErrq = ctrlErrq; + } + + public float[] getCtrlM() { + return ctrlM; + } + + public void setCtrlM(float[] ctrlM) { + this.ctrlM = ctrlM; + } + + public float[] getCtrlMwspeed() { + return ctrlMwspeed; + } + + public void setCtrlMwspeed(float[] ctrlMwspeed) { + this.ctrlMwspeed = ctrlMwspeed; + } + + public float[] getCtrlEuleroff() { + return ctrlEuleroff; + } + + public void setCtrlEuleroff(float[] ctrlEuleroff) { + this.ctrlEuleroff = ctrlEuleroff; + } + + public float[] getCtrlBtorque() { + return ctrlBtorque; + } + + public void setCtrlBtorque(float[] ctrlBtorque) { + this.ctrlBtorque = ctrlBtorque; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs1.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs1.java new file mode 100644 index 00000000..cb4ca5be --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs1.java @@ -0,0 +1,219 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs1 { + + private BeaconElementHeader hk415011; + private float[] extmag; + private float extmagTemp; + private int extmagValid; + private float[] suns; + private int sunsValid; + private short[] sunsTemp; + private float[] extgyro; + private float extgyroTemp; + private int extgyroValid; + private float[] fss; + private float fssTemp; + private int[] fssValid; + private float[] gpsPos; + private float[] gpsVel; + private long gpsEpoch; + private int gpsValid; + private int gpsSat; + private int gpsSatsol; + private long ppsUnix; + + public Adcs1() { + // do nothing + } + + public Adcs1(DataInputStream dis) throws IOException { + hk415011 = new BeaconElementHeader(dis); + extmag = StreamUtils.readFloatArray(dis, 3); + extmagTemp = dis.readFloat(); + extmagValid = dis.readUnsignedByte(); + suns = StreamUtils.readFloatArray(dis, 6); + sunsValid = dis.readUnsignedByte(); + sunsTemp = StreamUtils.readShortArray(dis, 6); + extgyro = StreamUtils.readFloatArray(dis, 3); + extgyroTemp = dis.readFloat(); + extgyroValid = dis.readUnsignedByte(); + fss = StreamUtils.readFloatArray(dis, 16); + fssTemp = dis.readFloat(); + fssValid = StreamUtils.readUnsignedByteArray(dis, 5); + gpsPos = StreamUtils.readFloatArray(dis, 3); + gpsVel = StreamUtils.readFloatArray(dis, 3); + gpsEpoch = StreamUtils.readUnsignedInt(dis); + gpsValid = dis.readUnsignedByte(); + gpsSat = dis.readUnsignedByte(); + gpsSatsol = dis.readUnsignedByte(); + ppsUnix = StreamUtils.readUnsignedInt(dis); + } + + public BeaconElementHeader getHk415011() { + return hk415011; + } + + public void setHk415011(BeaconElementHeader hk415011) { + this.hk415011 = hk415011; + } + + public float[] getExtmag() { + return extmag; + } + + public void setExtmag(float[] extmag) { + this.extmag = extmag; + } + + public float getExtmagTemp() { + return extmagTemp; + } + + public void setExtmagTemp(float extmagTemp) { + this.extmagTemp = extmagTemp; + } + + public int getExtmagValid() { + return extmagValid; + } + + public void setExtmagValid(int extmagValid) { + this.extmagValid = extmagValid; + } + + public float[] getSuns() { + return suns; + } + + public void setSuns(float[] suns) { + this.suns = suns; + } + + public int getSunsValid() { + return sunsValid; + } + + public void setSunsValid(int sunsValid) { + this.sunsValid = sunsValid; + } + + public short[] getSunsTemp() { + return sunsTemp; + } + + public void setSunsTemp(short[] sunsTemp) { + this.sunsTemp = sunsTemp; + } + + public float[] getExtgyro() { + return extgyro; + } + + public void setExtgyro(float[] extgyro) { + this.extgyro = extgyro; + } + + public float getExtgyroTemp() { + return extgyroTemp; + } + + public void setExtgyroTemp(float extgyroTemp) { + this.extgyroTemp = extgyroTemp; + } + + public int getExtgyroValid() { + return extgyroValid; + } + + public void setExtgyroValid(int extgyroValid) { + this.extgyroValid = extgyroValid; + } + + public float[] getFss() { + return fss; + } + + public void setFss(float[] fss) { + this.fss = fss; + } + + public float getFssTemp() { + return fssTemp; + } + + public void setFssTemp(float fssTemp) { + this.fssTemp = fssTemp; + } + + public int[] getFssValid() { + return fssValid; + } + + public void setFssValid(int[] fssValid) { + this.fssValid = fssValid; + } + + public float[] getGpsPos() { + return gpsPos; + } + + public void setGpsPos(float[] gpsPos) { + this.gpsPos = gpsPos; + } + + public float[] getGpsVel() { + return gpsVel; + } + + public void setGpsVel(float[] gpsVel) { + this.gpsVel = gpsVel; + } + + public long getGpsEpoch() { + return gpsEpoch; + } + + public void setGpsEpoch(long gpsEpoch) { + this.gpsEpoch = gpsEpoch; + } + + public int getGpsValid() { + return gpsValid; + } + + public void setGpsValid(int gpsValid) { + this.gpsValid = gpsValid; + } + + public int getGpsSat() { + return gpsSat; + } + + public void setGpsSat(int gpsSat) { + this.gpsSat = gpsSat; + } + + public int getGpsSatsol() { + return gpsSatsol; + } + + public void setGpsSatsol(int gpsSatsol) { + this.gpsSatsol = gpsSatsol; + } + + public long getPpsUnix() { + return ppsUnix; + } + + public void setPpsUnix(long ppsUnix) { + this.ppsUnix = ppsUnix; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs2.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs2.java new file mode 100644 index 00000000..9132e9c7 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs2.java @@ -0,0 +1,370 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs2 { + + private BeaconElementHeader hk415012; + private float[] wheelTorque; + private float[] wheelMomentum; + private float[] wheelSpeed; + private int[] wheelEnable; + private int[] wheelCurrent; + private short[] wheelTemp; + private float[] torquerDuty; + private float[] torquerCalib; + private BeaconElementHeader hk415112; + private byte acsMode; + private byte acsDmode; + private byte adsMode; + private byte adsDmode; + private byte ephemMode; + private byte ephemDmode; + private byte spinMode; + private byte statusMag; + private byte statusExtmag; + private byte statusCss; + private byte[] statusFss; + private byte statusGyro; + private byte statusExtgyro; + private byte statusGps; + private byte statusBdot; + private byte statusUkf; + private byte statusEtime; + private byte statusEphem; + private byte statusRun; + private short looptime; + private short maxLooptime; + private float[] bdotRate; + private float[] bdotDmag; + private float[] bdotTorquer; + private int bdotDetumble; + + public Adcs2() { + // do nothing + } + + public Adcs2(DataInputStream dis) throws IOException { + hk415012 = new BeaconElementHeader(dis); + wheelTorque = StreamUtils.readFloatArray(dis, 4); + wheelMomentum = StreamUtils.readFloatArray(dis, 4); + wheelSpeed = StreamUtils.readFloatArray(dis, 4); + wheelEnable = StreamUtils.readUnsignedByteArray(dis, 4); + wheelCurrent = StreamUtils.readUnsignedShortArray(dis, 4); + wheelTemp = StreamUtils.readShortArray(dis, 4); + torquerDuty = StreamUtils.readFloatArray(dis, 3); + torquerCalib = StreamUtils.readFloatArray(dis, 3); + hk415112 = new BeaconElementHeader(dis); + acsMode = dis.readByte(); + acsDmode = dis.readByte(); + adsMode = dis.readByte(); + adsDmode = dis.readByte(); + ephemMode = dis.readByte(); + ephemDmode = dis.readByte(); + spinMode = dis.readByte(); + statusMag = dis.readByte(); + statusExtmag = dis.readByte(); + statusCss = dis.readByte(); + statusFss = new byte[5]; + dis.readFully(statusFss); + statusGyro = dis.readByte(); + statusExtgyro = dis.readByte(); + statusGps = dis.readByte(); + statusBdot = dis.readByte(); + statusUkf = dis.readByte(); + statusEtime = dis.readByte(); + statusEphem = dis.readByte(); + statusRun = dis.readByte(); + looptime = dis.readShort(); + maxLooptime = dis.readShort(); + bdotRate = StreamUtils.readFloatArray(dis, 2); + bdotDmag = StreamUtils.readFloatArray(dis, 3); + bdotTorquer = StreamUtils.readFloatArray(dis, 3); + bdotDetumble = dis.readUnsignedByte(); + } + + public BeaconElementHeader getHk415012() { + return hk415012; + } + + public void setHk415012(BeaconElementHeader hk415012) { + this.hk415012 = hk415012; + } + + public float[] getWheelTorque() { + return wheelTorque; + } + + public void setWheelTorque(float[] wheelTorque) { + this.wheelTorque = wheelTorque; + } + + public float[] getWheelMomentum() { + return wheelMomentum; + } + + public void setWheelMomentum(float[] wheelMomentum) { + this.wheelMomentum = wheelMomentum; + } + + public float[] getWheelSpeed() { + return wheelSpeed; + } + + public void setWheelSpeed(float[] wheelSpeed) { + this.wheelSpeed = wheelSpeed; + } + + public int[] getWheelEnable() { + return wheelEnable; + } + + public void setWheelEnable(int[] wheelEnable) { + this.wheelEnable = wheelEnable; + } + + public int[] getWheelCurrent() { + return wheelCurrent; + } + + public void setWheelCurrent(int[] wheelCurrent) { + this.wheelCurrent = wheelCurrent; + } + + public short[] getWheelTemp() { + return wheelTemp; + } + + public void setWheelTemp(short[] wheelTemp) { + this.wheelTemp = wheelTemp; + } + + public float[] getTorquerDuty() { + return torquerDuty; + } + + public void setTorquerDuty(float[] torquerDuty) { + this.torquerDuty = torquerDuty; + } + + public float[] getTorquerCalib() { + return torquerCalib; + } + + public void setTorquerCalib(float[] torquerCalib) { + this.torquerCalib = torquerCalib; + } + + public BeaconElementHeader getHk415112() { + return hk415112; + } + + public void setHk415112(BeaconElementHeader hk415112) { + this.hk415112 = hk415112; + } + + public byte getAcsMode() { + return acsMode; + } + + public void setAcsMode(byte acsMode) { + this.acsMode = acsMode; + } + + public byte getAcsDmode() { + return acsDmode; + } + + public void setAcsDmode(byte acsDmode) { + this.acsDmode = acsDmode; + } + + public byte getAdsMode() { + return adsMode; + } + + public void setAdsMode(byte adsMode) { + this.adsMode = adsMode; + } + + public byte getAdsDmode() { + return adsDmode; + } + + public void setAdsDmode(byte adsDmode) { + this.adsDmode = adsDmode; + } + + public byte getEphemMode() { + return ephemMode; + } + + public void setEphemMode(byte ephemMode) { + this.ephemMode = ephemMode; + } + + public byte getEphemDmode() { + return ephemDmode; + } + + public void setEphemDmode(byte ephemDmode) { + this.ephemDmode = ephemDmode; + } + + public byte getSpinMode() { + return spinMode; + } + + public void setSpinMode(byte spinMode) { + this.spinMode = spinMode; + } + + public byte getStatusMag() { + return statusMag; + } + + public void setStatusMag(byte statusMag) { + this.statusMag = statusMag; + } + + public byte getStatusExtmag() { + return statusExtmag; + } + + public void setStatusExtmag(byte statusExtmag) { + this.statusExtmag = statusExtmag; + } + + public byte getStatusCss() { + return statusCss; + } + + public void setStatusCss(byte statusCss) { + this.statusCss = statusCss; + } + + public byte[] getStatusFss() { + return statusFss; + } + + public void setStatusFss(byte[] statusFss) { + this.statusFss = statusFss; + } + + public byte getStatusGyro() { + return statusGyro; + } + + public void setStatusGyro(byte statusGyro) { + this.statusGyro = statusGyro; + } + + public byte getStatusExtgyro() { + return statusExtgyro; + } + + public void setStatusExtgyro(byte statusExtgyro) { + this.statusExtgyro = statusExtgyro; + } + + public byte getStatusGps() { + return statusGps; + } + + public void setStatusGps(byte statusGps) { + this.statusGps = statusGps; + } + + public byte getStatusBdot() { + return statusBdot; + } + + public void setStatusBdot(byte statusBdot) { + this.statusBdot = statusBdot; + } + + public byte getStatusUkf() { + return statusUkf; + } + + public void setStatusUkf(byte statusUkf) { + this.statusUkf = statusUkf; + } + + public byte getStatusEtime() { + return statusEtime; + } + + public void setStatusEtime(byte statusEtime) { + this.statusEtime = statusEtime; + } + + public byte getStatusEphem() { + return statusEphem; + } + + public void setStatusEphem(byte statusEphem) { + this.statusEphem = statusEphem; + } + + public byte getStatusRun() { + return statusRun; + } + + public void setStatusRun(byte statusRun) { + this.statusRun = statusRun; + } + + public short getLooptime() { + return looptime; + } + + public void setLooptime(short looptime) { + this.looptime = looptime; + } + + public short getMaxLooptime() { + return maxLooptime; + } + + public void setMaxLooptime(short maxLooptime) { + this.maxLooptime = maxLooptime; + } + + public float[] getBdotRate() { + return bdotRate; + } + + public void setBdotRate(float[] bdotRate) { + this.bdotRate = bdotRate; + } + + public float[] getBdotDmag() { + return bdotDmag; + } + + public void setBdotDmag(float[] bdotDmag) { + this.bdotDmag = bdotDmag; + } + + public float[] getBdotTorquer() { + return bdotTorquer; + } + + public void setBdotTorquer(float[] bdotTorquer) { + this.bdotTorquer = bdotTorquer; + } + + public int getBdotDetumble() { + return bdotDetumble; + } + + public void setBdotDetumble(int bdotDetumble) { + this.bdotDetumble = bdotDetumble; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs3.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs3.java new file mode 100644 index 00000000..ce191c11 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs3.java @@ -0,0 +1,79 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs3 { + + private BeaconElementHeader hk415213; + private float[] ukfX; + private float[] ukfQ; + private float[] ukfW; + private float[] ukfXpred; + private float[] ukfZpred; + + public Adcs3() { + // do nothing + } + + public Adcs3(DataInputStream dis) throws IOException { + hk415213 = new BeaconElementHeader(dis); + ukfX = StreamUtils.readFloatArray(dis, 13); + ukfQ = StreamUtils.readFloatArray(dis, 4); + ukfW = StreamUtils.readFloatArray(dis, 3); + ukfXpred = StreamUtils.readFloatArray(dis, 13); + ukfZpred = StreamUtils.readFloatArray(dis, 12); + } + + public BeaconElementHeader getHk415213() { + return hk415213; + } + + public void setHk415213(BeaconElementHeader hk415213) { + this.hk415213 = hk415213; + } + + public float[] getUkfX() { + return ukfX; + } + + public void setUkfX(float[] ukfX) { + this.ukfX = ukfX; + } + + public float[] getUkfQ() { + return ukfQ; + } + + public void setUkfQ(float[] ukfQ) { + this.ukfQ = ukfQ; + } + + public float[] getUkfW() { + return ukfW; + } + + public void setUkfW(float[] ukfW) { + this.ukfW = ukfW; + } + + public float[] getUkfXpred() { + return ukfXpred; + } + + public void setUkfXpred(float[] ukfXpred) { + this.ukfXpred = ukfXpred; + } + + public float[] getUkfZpred() { + return ukfZpred; + } + + public void setUkfZpred(float[] ukfZpred) { + this.ukfZpred = ukfZpred; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs4.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs4.java new file mode 100644 index 00000000..3a626737 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs4.java @@ -0,0 +1,109 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs4 { + + private BeaconElementHeader hk415214; + private float[] ukfZ; + private int[] ukfEnable; + private float[] ukfSunmax; + private int ukfInEclipse; + private int ukfChoice; + private float[] ukfCtrlT; + private float[] ukfCtrlM; + private float[] ukfRate; + + public Adcs4() { + // do nothing + } + + public Adcs4(DataInputStream dis) throws IOException { + hk415214 = new BeaconElementHeader(dis); + ukfZ = StreamUtils.readFloatArray(dis, 12); + ukfEnable = StreamUtils.readUnsignedByteArray(dis, 12); + ukfSunmax = StreamUtils.readFloatArray(dis, 6); + ukfInEclipse = dis.readUnsignedByte(); + ukfChoice = dis.readUnsignedByte(); + ukfCtrlT = StreamUtils.readFloatArray(dis, 3); + ukfCtrlM = StreamUtils.readFloatArray(dis, 3); + ukfRate = StreamUtils.readFloatArray(dis, 3); + } + + public BeaconElementHeader getHk415214() { + return hk415214; + } + + public void setHk415214(BeaconElementHeader hk415214) { + this.hk415214 = hk415214; + } + + public float[] getUkfZ() { + return ukfZ; + } + + public void setUkfZ(float[] ukfZ) { + this.ukfZ = ukfZ; + } + + public int[] getUkfEnable() { + return ukfEnable; + } + + public void setUkfEnable(int[] ukfEnable) { + this.ukfEnable = ukfEnable; + } + + public float[] getUkfSunmax() { + return ukfSunmax; + } + + public void setUkfSunmax(float[] ukfSunmax) { + this.ukfSunmax = ukfSunmax; + } + + public int getUkfInEclipse() { + return ukfInEclipse; + } + + public void setUkfInEclipse(int ukfInEclipse) { + this.ukfInEclipse = ukfInEclipse; + } + + public int getUkfChoice() { + return ukfChoice; + } + + public void setUkfChoice(int ukfChoice) { + this.ukfChoice = ukfChoice; + } + + public float[] getUkfCtrlT() { + return ukfCtrlT; + } + + public void setUkfCtrlT(float[] ukfCtrlT) { + this.ukfCtrlT = ukfCtrlT; + } + + public float[] getUkfCtrlM() { + return ukfCtrlM; + } + + public void setUkfCtrlM(float[] ukfCtrlM) { + this.ukfCtrlM = ukfCtrlM; + } + + public float[] getUkfRate() { + return ukfRate; + } + + public void setUkfRate(float[] ukfRate) { + this.ukfRate = ukfRate; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs5.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs5.java new file mode 100644 index 00000000..457f3f11 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs5.java @@ -0,0 +1,179 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs5 { + + private BeaconElementHeader hk415315; + private double ephemJdat; + private float[] ephemReci; + private float[] ephemVeci; + private float[] ephemSunEci; + private float[] ephemQuatIe; + private float[] ephemQuatIo; + private float[] ephemQuatIl; + private float[] ephemRateIo; + private float[] ephemRateIl; + private int ephemTEclipse; + private BeaconElementHeader hk415615; + private long ephemTime; + private long adsTime; + private long acsTime; + private long sensTime; + + public Adcs5() { + // do nothing + } + + public Adcs5(DataInputStream dis) throws IOException { + hk415315 = new BeaconElementHeader(dis); + ephemJdat = dis.readDouble(); + ephemReci = StreamUtils.readFloatArray(dis, 3); + ephemVeci = StreamUtils.readFloatArray(dis, 3); + ephemSunEci = StreamUtils.readFloatArray(dis, 3); + ephemQuatIe = StreamUtils.readFloatArray(dis, 4); + ephemQuatIo = StreamUtils.readFloatArray(dis, 4); + ephemQuatIl = StreamUtils.readFloatArray(dis, 4); + ephemRateIo = StreamUtils.readFloatArray(dis, 3); + ephemRateIl = StreamUtils.readFloatArray(dis, 3); + ephemTEclipse = dis.readInt(); + hk415615 = new BeaconElementHeader(dis); + ephemTime = StreamUtils.readUnsignedInt(dis); + adsTime = StreamUtils.readUnsignedInt(dis); + acsTime = StreamUtils.readUnsignedInt(dis); + sensTime = StreamUtils.readUnsignedInt(dis); + } + + public BeaconElementHeader getHk415315() { + return hk415315; + } + + public void setHk415315(BeaconElementHeader hk415315) { + this.hk415315 = hk415315; + } + + public double getEphemJdat() { + return ephemJdat; + } + + public void setEphemJdat(double ephemJdat) { + this.ephemJdat = ephemJdat; + } + + public float[] getEphemReci() { + return ephemReci; + } + + public void setEphemReci(float[] ephemReci) { + this.ephemReci = ephemReci; + } + + public float[] getEphemVeci() { + return ephemVeci; + } + + public void setEphemVeci(float[] ephemVeci) { + this.ephemVeci = ephemVeci; + } + + public float[] getEphemSunEci() { + return ephemSunEci; + } + + public void setEphemSunEci(float[] ephemSunEci) { + this.ephemSunEci = ephemSunEci; + } + + public float[] getEphemQuatIe() { + return ephemQuatIe; + } + + public void setEphemQuatIe(float[] ephemQuatIe) { + this.ephemQuatIe = ephemQuatIe; + } + + public float[] getEphemQuatIo() { + return ephemQuatIo; + } + + public void setEphemQuatIo(float[] ephemQuatIo) { + this.ephemQuatIo = ephemQuatIo; + } + + public float[] getEphemQuatIl() { + return ephemQuatIl; + } + + public void setEphemQuatIl(float[] ephemQuatIl) { + this.ephemQuatIl = ephemQuatIl; + } + + public float[] getEphemRateIo() { + return ephemRateIo; + } + + public void setEphemRateIo(float[] ephemRateIo) { + this.ephemRateIo = ephemRateIo; + } + + public float[] getEphemRateIl() { + return ephemRateIl; + } + + public void setEphemRateIl(float[] ephemRateIl) { + this.ephemRateIl = ephemRateIl; + } + + public int getEphemTEclipse() { + return ephemTEclipse; + } + + public void setEphemTEclipse(int ephemTEclipse) { + this.ephemTEclipse = ephemTEclipse; + } + + public BeaconElementHeader getHk415615() { + return hk415615; + } + + public void setHk415615(BeaconElementHeader hk415615) { + this.hk415615 = hk415615; + } + + public long getEphemTime() { + return ephemTime; + } + + public void setEphemTime(long ephemTime) { + this.ephemTime = ephemTime; + } + + public long getAdsTime() { + return adsTime; + } + + public void setAdsTime(long adsTime) { + this.adsTime = adsTime; + } + + public long getAcsTime() { + return acsTime; + } + + public void setAcsTime(long acsTime) { + this.acsTime = acsTime; + } + + public long getSensTime() { + return sensTime; + } + + public void setSensTime(long sensTime) { + this.sensTime = sensTime; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs6.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs6.java new file mode 100644 index 00000000..6ce4847f --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs6.java @@ -0,0 +1,129 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs6 { + + private BeaconElementHeader hk4116; + private int adcsSwloadCnt1; + private BeaconElementHeader hk4416; + private int adcsFsMounted; + private short adcsTempMcu; + private short adcsTempRam; + private long adcsResetcause; + private long adcsBootcause; + private int adcsBootCnt; + private long adcsClock; + private long adcsUptime; + + public Adcs6() { + // do nothing + } + + public Adcs6(DataInputStream dis) throws IOException { + hk4116 = new BeaconElementHeader(dis); + adcsSwloadCnt1 = dis.readUnsignedShort(); + hk4416 = new BeaconElementHeader(dis); + adcsFsMounted = dis.readUnsignedByte(); + adcsTempMcu = dis.readShort(); + adcsTempRam = dis.readShort(); + adcsResetcause = StreamUtils.readUnsignedInt(dis); + adcsBootcause = StreamUtils.readUnsignedInt(dis); + adcsBootCnt = dis.readUnsignedShort(); + adcsClock = StreamUtils.readUnsignedInt(dis); + adcsUptime = StreamUtils.readUnsignedInt(dis); + } + + public BeaconElementHeader getHk4116() { + return hk4116; + } + + public void setHk4116(BeaconElementHeader hk4116) { + this.hk4116 = hk4116; + } + + public int getAdcsSwloadCnt1() { + return adcsSwloadCnt1; + } + + public void setAdcsSwloadCnt1(int adcsSwloadCnt1) { + this.adcsSwloadCnt1 = adcsSwloadCnt1; + } + + public BeaconElementHeader getHk4416() { + return hk4416; + } + + public void setHk4416(BeaconElementHeader hk4416) { + this.hk4416 = hk4416; + } + + public int getAdcsFsMounted() { + return adcsFsMounted; + } + + public void setAdcsFsMounted(int adcsFsMounted) { + this.adcsFsMounted = adcsFsMounted; + } + + public short getAdcsTempMcu() { + return adcsTempMcu; + } + + public void setAdcsTempMcu(short adcsTempMcu) { + this.adcsTempMcu = adcsTempMcu; + } + + public short getAdcsTempRam() { + return adcsTempRam; + } + + public void setAdcsTempRam(short adcsTempRam) { + this.adcsTempRam = adcsTempRam; + } + + public long getAdcsResetcause() { + return adcsResetcause; + } + + public void setAdcsResetcause(long adcsResetcause) { + this.adcsResetcause = adcsResetcause; + } + + public long getAdcsBootcause() { + return adcsBootcause; + } + + public void setAdcsBootcause(long adcsBootcause) { + this.adcsBootcause = adcsBootcause; + } + + public int getAdcsBootCnt() { + return adcsBootCnt; + } + + public void setAdcsBootCnt(int adcsBootCnt) { + this.adcsBootCnt = adcsBootCnt; + } + + public long getAdcsClock() { + return adcsClock; + } + + public void setAdcsClock(long adcsClock) { + this.adcsClock = adcsClock; + } + + public long getAdcsUptime() { + return adcsUptime; + } + + public void setAdcsUptime(long adcsUptime) { + this.adcsUptime = adcsUptime; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Adcs7.java b/src/main/java/ru/r2cloud/jradio/catsat/Adcs7.java new file mode 100644 index 00000000..39e809a8 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Adcs7.java @@ -0,0 +1,139 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Adcs7 { + + private BeaconElementHeader hk415417; + private float[] ctrlRefq; + private float[] ctrlErrq; + private float[] ctrlErrrate; + private float[] ctrlM; + private float[] ctrlMwtorque; + private float[] ctrlMwspeed; + private float[] ctrlMwmoment; + private float[] ctrlRefrate; + private float[] ctrlEuleroff; + private float[] ctrlBtorque; + private float[] ctrlBmoment; + + public Adcs7() { + // do nothing + } + + public Adcs7(DataInputStream dis) throws IOException { + hk415417 = new BeaconElementHeader(dis); + ctrlRefq = StreamUtils.readFloatArray(dis, 4); + ctrlErrq = StreamUtils.readFloatArray(dis, 4); + ctrlErrrate = StreamUtils.readFloatArray(dis, 3); + ctrlM = StreamUtils.readFloatArray(dis, 3); + ctrlMwtorque = StreamUtils.readFloatArray(dis, 4); + ctrlMwspeed = StreamUtils.readFloatArray(dis, 4); + ctrlMwmoment = StreamUtils.readFloatArray(dis, 4); + ctrlRefrate = StreamUtils.readFloatArray(dis, 3); + ctrlEuleroff = StreamUtils.readFloatArray(dis, 3); + ctrlBtorque = StreamUtils.readFloatArray(dis, 3); + ctrlBmoment = StreamUtils.readFloatArray(dis, 3); + } + + public BeaconElementHeader getHk415417() { + return hk415417; + } + + public void setHk415417(BeaconElementHeader hk415417) { + this.hk415417 = hk415417; + } + + public float[] getCtrlRefq() { + return ctrlRefq; + } + + public void setCtrlRefq(float[] ctrlRefq) { + this.ctrlRefq = ctrlRefq; + } + + public float[] getCtrlErrq() { + return ctrlErrq; + } + + public void setCtrlErrq(float[] ctrlErrq) { + this.ctrlErrq = ctrlErrq; + } + + public float[] getCtrlErrrate() { + return ctrlErrrate; + } + + public void setCtrlErrrate(float[] ctrlErrrate) { + this.ctrlErrrate = ctrlErrrate; + } + + public float[] getCtrlM() { + return ctrlM; + } + + public void setCtrlM(float[] ctrlM) { + this.ctrlM = ctrlM; + } + + public float[] getCtrlMwtorque() { + return ctrlMwtorque; + } + + public void setCtrlMwtorque(float[] ctrlMwtorque) { + this.ctrlMwtorque = ctrlMwtorque; + } + + public float[] getCtrlMwspeed() { + return ctrlMwspeed; + } + + public void setCtrlMwspeed(float[] ctrlMwspeed) { + this.ctrlMwspeed = ctrlMwspeed; + } + + public float[] getCtrlMwmoment() { + return ctrlMwmoment; + } + + public void setCtrlMwmoment(float[] ctrlMwmoment) { + this.ctrlMwmoment = ctrlMwmoment; + } + + public float[] getCtrlRefrate() { + return ctrlRefrate; + } + + public void setCtrlRefrate(float[] ctrlRefrate) { + this.ctrlRefrate = ctrlRefrate; + } + + public float[] getCtrlEuleroff() { + return ctrlEuleroff; + } + + public void setCtrlEuleroff(float[] ctrlEuleroff) { + this.ctrlEuleroff = ctrlEuleroff; + } + + public float[] getCtrlBtorque() { + return ctrlBtorque; + } + + public void setCtrlBtorque(float[] ctrlBtorque) { + this.ctrlBtorque = ctrlBtorque; + } + + public float[] getCtrlBmoment() { + return ctrlBmoment; + } + + public void setCtrlBmoment(float[] ctrlBmoment) { + this.ctrlBmoment = ctrlBmoment; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Asdr1.java b/src/main/java/ru/r2cloud/jradio/catsat/Asdr1.java new file mode 100644 index 00000000..d2a3f616 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Asdr1.java @@ -0,0 +1,199 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Asdr1 { + + private BeaconElementHeader hk14021; + private CoreType coreLoaded; + private BeaconElementHeader hk14121; + private int[] sectorHistory; + private int[] mbytesHistory; + private long exposure; + private float gain; + private BeaconElementHeader hk141221; + private int chanRefLock; + private BeaconElementHeader hk141321; + private float chanTemp; + private BeaconElementHeader hk141621; + private int chanInited; + private BeaconElementHeader hk141821; + private float chanWritten; + private int chanRecStatus; + private int chanReqMbytes; + private float chanTime; + + public Asdr1() { + // do nothing + } + + public Asdr1(DataInputStream dis) throws IOException { + hk14021 = new BeaconElementHeader(dis); + coreLoaded = CoreType.valueOfCode(dis.readUnsignedByte()); + hk14121 = new BeaconElementHeader(dis); + sectorHistory = StreamUtils.readUnsignedShortArray(dis, 16); + mbytesHistory = StreamUtils.readUnsignedShortArray(dis, 16); + exposure = StreamUtils.readUnsignedInt(dis); + gain = dis.readFloat(); + hk141221 = new BeaconElementHeader(dis); + chanRefLock = dis.readUnsignedByte(); + hk141321 = new BeaconElementHeader(dis); + chanTemp = dis.readFloat(); + hk141621 = new BeaconElementHeader(dis); + chanInited = dis.readUnsignedByte(); + hk141821 = new BeaconElementHeader(dis); + chanWritten = dis.readFloat(); + chanRecStatus = dis.readUnsignedByte(); + chanReqMbytes = dis.readInt(); + chanTime = dis.readFloat(); + } + + public BeaconElementHeader getHk14021() { + return hk14021; + } + + public void setHk14021(BeaconElementHeader hk14021) { + this.hk14021 = hk14021; + } + + public CoreType getCoreLoaded() { + return coreLoaded; + } + + public void setCoreLoaded(CoreType coreLoaded) { + this.coreLoaded = coreLoaded; + } + + public BeaconElementHeader getHk14121() { + return hk14121; + } + + public void setHk14121(BeaconElementHeader hk14121) { + this.hk14121 = hk14121; + } + + public int[] getSectorHistory() { + return sectorHistory; + } + + public void setSectorHistory(int[] sectorHistory) { + this.sectorHistory = sectorHistory; + } + + public int[] getMbytesHistory() { + return mbytesHistory; + } + + public void setMbytesHistory(int[] mbytesHistory) { + this.mbytesHistory = mbytesHistory; + } + + public long getExposure() { + return exposure; + } + + public void setExposure(long exposure) { + this.exposure = exposure; + } + + public float getGain() { + return gain; + } + + public void setGain(float gain) { + this.gain = gain; + } + + public BeaconElementHeader getHk141221() { + return hk141221; + } + + public void setHk141221(BeaconElementHeader hk141221) { + this.hk141221 = hk141221; + } + + public int getChanRefLock() { + return chanRefLock; + } + + public void setChanRefLock(int chanRefLock) { + this.chanRefLock = chanRefLock; + } + + public BeaconElementHeader getHk141321() { + return hk141321; + } + + public void setHk141321(BeaconElementHeader hk141321) { + this.hk141321 = hk141321; + } + + public float getChanTemp() { + return chanTemp; + } + + public void setChanTemp(float chanTemp) { + this.chanTemp = chanTemp; + } + + public BeaconElementHeader getHk141621() { + return hk141621; + } + + public void setHk141621(BeaconElementHeader hk141621) { + this.hk141621 = hk141621; + } + + public int getChanInited() { + return chanInited; + } + + public void setChanInited(int chanInited) { + this.chanInited = chanInited; + } + + public BeaconElementHeader getHk141821() { + return hk141821; + } + + public void setHk141821(BeaconElementHeader hk141821) { + this.hk141821 = hk141821; + } + + public float getChanWritten() { + return chanWritten; + } + + public void setChanWritten(float chanWritten) { + this.chanWritten = chanWritten; + } + + public int getChanRecStatus() { + return chanRecStatus; + } + + public void setChanRecStatus(int chanRecStatus) { + this.chanRecStatus = chanRecStatus; + } + + public int getChanReqMbytes() { + return chanReqMbytes; + } + + public void setChanReqMbytes(int chanReqMbytes) { + this.chanReqMbytes = chanReqMbytes; + } + + public float getChanTime() { + return chanTime; + } + + public void setChanTime(float chanTime) { + this.chanTime = chanTime; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Asdr2.java b/src/main/java/ru/r2cloud/jradio/catsat/Asdr2.java new file mode 100644 index 00000000..33df6a85 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Asdr2.java @@ -0,0 +1,248 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; + +public class Asdr2 { + + private BeaconElementHeader hk142922; + private int chanPpsPresent; + private int chanPpsCount; + private BeaconElementHeader hk143722; + private int recInited; + private BeaconElementHeader hk143822; + private float recWritten; + private int recRecStatus; + private int recReqMbytes; + private float recTime; + private BeaconElementHeader hk144322; + private float recTemp; + private BeaconElementHeader hk145222; + private int transInited; + private float transMbytesSent; + private BeaconElementHeader hk145322; + private long transSystemTime; + private BeaconElementHeader hk143322; + private float mis1Temp; + private BeaconElementHeader hk143422; + private int mis1FskIncr; + private BeaconElementHeader hk143522; + private long mis1SystemTime; + + public Asdr2() { + // do nothing + } + + public Asdr2(DataInputStream dis) throws IOException { + hk142922 = new BeaconElementHeader(dis); + chanPpsPresent = dis.readUnsignedByte(); + chanPpsCount = dis.readInt(); + hk143722 = new BeaconElementHeader(dis); + recInited = dis.readUnsignedByte(); + hk143822 = new BeaconElementHeader(dis); + recWritten = dis.readFloat(); + recRecStatus = dis.readUnsignedByte(); + recReqMbytes = dis.readInt(); + recTime = dis.readFloat(); + hk144322 = new BeaconElementHeader(dis); + recTemp = dis.readFloat(); + hk145222 = new BeaconElementHeader(dis); + transInited = dis.readUnsignedByte(); + transMbytesSent = dis.readFloat(); + hk145322 = new BeaconElementHeader(dis); + transSystemTime = dis.readLong(); + hk143322 = new BeaconElementHeader(dis); + mis1Temp = dis.readFloat(); + hk143422 = new BeaconElementHeader(dis); + mis1FskIncr = dis.readInt(); + hk143522 = new BeaconElementHeader(dis); + mis1SystemTime = dis.readLong(); + } + + public BeaconElementHeader getHk142922() { + return hk142922; + } + + public void setHk142922(BeaconElementHeader hk142922) { + this.hk142922 = hk142922; + } + + public int getChanPpsPresent() { + return chanPpsPresent; + } + + public void setChanPpsPresent(int chanPpsPresent) { + this.chanPpsPresent = chanPpsPresent; + } + + public int getChanPpsCount() { + return chanPpsCount; + } + + public void setChanPpsCount(int chanPpsCount) { + this.chanPpsCount = chanPpsCount; + } + + public BeaconElementHeader getHk143722() { + return hk143722; + } + + public void setHk143722(BeaconElementHeader hk143722) { + this.hk143722 = hk143722; + } + + public int getRecInited() { + return recInited; + } + + public void setRecInited(int recInited) { + this.recInited = recInited; + } + + public BeaconElementHeader getHk143822() { + return hk143822; + } + + public void setHk143822(BeaconElementHeader hk143822) { + this.hk143822 = hk143822; + } + + public float getRecWritten() { + return recWritten; + } + + public void setRecWritten(float recWritten) { + this.recWritten = recWritten; + } + + public int getRecRecStatus() { + return recRecStatus; + } + + public void setRecRecStatus(int recRecStatus) { + this.recRecStatus = recRecStatus; + } + + public int getRecReqMbytes() { + return recReqMbytes; + } + + public void setRecReqMbytes(int recReqMbytes) { + this.recReqMbytes = recReqMbytes; + } + + public float getRecTime() { + return recTime; + } + + public void setRecTime(float recTime) { + this.recTime = recTime; + } + + public BeaconElementHeader getHk144322() { + return hk144322; + } + + public void setHk144322(BeaconElementHeader hk144322) { + this.hk144322 = hk144322; + } + + public float getRecTemp() { + return recTemp; + } + + public void setRecTemp(float recTemp) { + this.recTemp = recTemp; + } + + public BeaconElementHeader getHk145222() { + return hk145222; + } + + public void setHk145222(BeaconElementHeader hk145222) { + this.hk145222 = hk145222; + } + + public int getTransInited() { + return transInited; + } + + public void setTransInited(int transInited) { + this.transInited = transInited; + } + + public float getTransMbytesSent() { + return transMbytesSent; + } + + public void setTransMbytesSent(float transMbytesSent) { + this.transMbytesSent = transMbytesSent; + } + + public BeaconElementHeader getHk145322() { + return hk145322; + } + + public void setHk145322(BeaconElementHeader hk145322) { + this.hk145322 = hk145322; + } + + public long getTransSystemTime() { + return transSystemTime; + } + + public void setTransSystemTime(long transSystemTime) { + this.transSystemTime = transSystemTime; + } + + public BeaconElementHeader getHk143322() { + return hk143322; + } + + public void setHk143322(BeaconElementHeader hk143322) { + this.hk143322 = hk143322; + } + + public float getMis1Temp() { + return mis1Temp; + } + + public void setMis1Temp(float mis1Temp) { + this.mis1Temp = mis1Temp; + } + + public BeaconElementHeader getHk143422() { + return hk143422; + } + + public void setHk143422(BeaconElementHeader hk143422) { + this.hk143422 = hk143422; + } + + public int getMis1FskIncr() { + return mis1FskIncr; + } + + public void setMis1FskIncr(int mis1FskIncr) { + this.mis1FskIncr = mis1FskIncr; + } + + public BeaconElementHeader getHk143522() { + return hk143522; + } + + public void setHk143522(BeaconElementHeader hk143522) { + this.hk143522 = hk143522; + } + + public long getMis1SystemTime() { + return mis1SystemTime; + } + + public void setMis1SystemTime(long mis1SystemTime) { + this.mis1SystemTime = mis1SystemTime; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Bcn.java b/src/main/java/ru/r2cloud/jradio/catsat/Bcn.java new file mode 100644 index 00000000..b5dec0f2 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Bcn.java @@ -0,0 +1,39 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Bcn { + + private BeaconElementHeader hk19393; + private int[] infBlob; + + public Bcn() { + // do nothing + } + + public Bcn(DataInputStream dis) throws IOException { + hk19393 = new BeaconElementHeader(dis); + infBlob = StreamUtils.readUnsignedByteArray(dis, 42); + } + + public BeaconElementHeader getHk19393() { + return hk19393; + } + + public void setHk19393(BeaconElementHeader hk19393) { + this.hk19393 = hk19393; + } + + public int[] getInfBlob() { + return infBlob; + } + + public void setInfBlob(int[] infBlob) { + this.infBlob = infBlob; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/BeaconHeader.java b/src/main/java/ru/r2cloud/jradio/catsat/BeaconHeader.java new file mode 100644 index 00000000..1ec47323 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/BeaconHeader.java @@ -0,0 +1,56 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +public class BeaconHeader { + + private int protocolVersion; + private int type; + private int version; + private int satid; + + public BeaconHeader() { + // do nothing + } + + public BeaconHeader(DataInputStream dis) throws IOException { + protocolVersion = dis.readUnsignedByte(); + type = dis.readUnsignedByte(); + version = dis.readUnsignedByte(); + satid = dis.readUnsignedShort(); + } + + public int getProtocolVersion() { + return protocolVersion; + } + + public void setProtocolVersion(int protocolVersion) { + this.protocolVersion = protocolVersion; + } + + public int getType() { + return type; + } + + public void setType(int type) { + this.type = type; + } + + public int getVersion() { + return version; + } + + public void setVersion(int version) { + this.version = version; + } + + public int getSatid() { + return satid; + } + + public void setSatid(int satid) { + this.satid = satid; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/CatsatBeacon.java b/src/main/java/ru/r2cloud/jradio/catsat/CatsatBeacon.java new file mode 100644 index 00000000..26a91238 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/CatsatBeacon.java @@ -0,0 +1,257 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.csp.CspBeacon; +import ru.r2cloud.jradio.fec.ccsds.UncorrectableException; + +public class CatsatBeacon extends CspBeacon { + + private BeaconHeader beaconHeader; + private Motd motd; + private Crit1 crit1; + private Crit2 crit2; + private Obc obc; + private Pdu1 pdu1; + private Pdu2 pdu2; + private Dep dep; + private Adcs0 adcs0; + private Adcs1 adcs1; + private Adcs2 adcs2; + private Adcs3 adcs3; + private Adcs4 adcs4; + private Adcs5 adcs5; + private Adcs6 adcs6; + private Adcs7 adcs7; + private Asdr1 asdr1; + private Asdr2 asdr2; + private Bcn bcn; + private byte[] unknownPayload; + + @Override + public void readBeacon(DataInputStream dis) throws IOException, UncorrectableException { + beaconHeader = new BeaconHeader(dis); + switch (beaconHeader.getType()) { + case 0: + motd = new Motd(dis); + break; + case 1: + crit1 = new Crit1(dis); + break; + case 2: + crit2 = new Crit2(dis); + break; + case 3: + obc = new Obc(dis); + break; + case 4: + pdu1 = new Pdu1(dis); + break; + case 5: + pdu2 = new Pdu2(dis); + break; + case 6: + dep = new Dep(dis); + break; + case 7: + adcs0 = new Adcs0(dis); + break; + case 11: + adcs1 = new Adcs1(dis); + break; + case 12: + adcs2 = new Adcs2(dis); + break; + case 13: + adcs3 = new Adcs3(dis); + break; + case 14: + adcs4 = new Adcs4(dis); + break; + case 15: + adcs5 = new Adcs5(dis); + break; + case 16: + adcs6 = new Adcs6(dis); + break; + case 17: + adcs7 = new Adcs7(dis); + break; + case 21: + asdr1 = new Asdr1(dis); + break; + case 22: + asdr2 = new Asdr2(dis); + break; + case 99: + bcn = new Bcn(dis); + break; + default: + unknownPayload = new byte[dis.available()]; + dis.readFully(unknownPayload); + break; + } + } + + public BeaconHeader getBeaconHeader() { + return beaconHeader; + } + + public void setBeaconHeader(BeaconHeader beaconHeader) { + this.beaconHeader = beaconHeader; + } + + public Motd getMotd() { + return motd; + } + + public void setMotd(Motd motd) { + this.motd = motd; + } + + public Crit1 getCrit1() { + return crit1; + } + + public void setCrit1(Crit1 crit1) { + this.crit1 = crit1; + } + + public Crit2 getCrit2() { + return crit2; + } + + public void setCrit2(Crit2 crit2) { + this.crit2 = crit2; + } + + public Obc getObc() { + return obc; + } + + public void setObc(Obc obc) { + this.obc = obc; + } + + public Pdu1 getPdu1() { + return pdu1; + } + + public void setPdu1(Pdu1 pdu1) { + this.pdu1 = pdu1; + } + + public Pdu2 getPdu2() { + return pdu2; + } + + public void setPdu2(Pdu2 pdu2) { + this.pdu2 = pdu2; + } + + public Dep getDep() { + return dep; + } + + public void setDep(Dep dep) { + this.dep = dep; + } + + public Adcs0 getAdcs0() { + return adcs0; + } + + public void setAdcs0(Adcs0 adcs0) { + this.adcs0 = adcs0; + } + + public Adcs1 getAdcs1() { + return adcs1; + } + + public void setAdcs1(Adcs1 adcs1) { + this.adcs1 = adcs1; + } + + public Adcs2 getAdcs2() { + return adcs2; + } + + public void setAdcs2(Adcs2 adcs2) { + this.adcs2 = adcs2; + } + + public Adcs3 getAdcs3() { + return adcs3; + } + + public void setAdcs3(Adcs3 adcs3) { + this.adcs3 = adcs3; + } + + public Adcs4 getAdcs4() { + return adcs4; + } + + public void setAdcs4(Adcs4 adcs4) { + this.adcs4 = adcs4; + } + + public Adcs5 getAdcs5() { + return adcs5; + } + + public void setAdcs5(Adcs5 adcs5) { + this.adcs5 = adcs5; + } + + public Adcs6 getAdcs6() { + return adcs6; + } + + public void setAdcs6(Adcs6 adcs6) { + this.adcs6 = adcs6; + } + + public Adcs7 getAdcs7() { + return adcs7; + } + + public void setAdcs7(Adcs7 adcs7) { + this.adcs7 = adcs7; + } + + public Asdr1 getAsdr1() { + return asdr1; + } + + public void setAsdr1(Asdr1 asdr1) { + this.asdr1 = asdr1; + } + + public Asdr2 getAsdr2() { + return asdr2; + } + + public void setAsdr2(Asdr2 asdr2) { + this.asdr2 = asdr2; + } + + public Bcn getBcn() { + return bcn; + } + + public void setBcn(Bcn bcn) { + this.bcn = bcn; + } + + public byte[] getUnknownPayload() { + return unknownPayload; + } + + public void setUnknownPayload(byte[] unknownPayload) { + this.unknownPayload = unknownPayload; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/CoreType.java b/src/main/java/ru/r2cloud/jradio/catsat/CoreType.java new file mode 100644 index 00000000..275bf3ee --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/CoreType.java @@ -0,0 +1,22 @@ +package ru.r2cloud.jradio.catsat; + +public enum CoreType { + + CHANNELIZER(0), MISSION1_FSK(1), RECORDER(2), TRANSMITTER(3), ASDR_BSP(4), FAILED(127), NONE(255); + + private final int code; + + private CoreType(int code) { + this.code = code; + } + + public static CoreType valueOfCode(int code) { + for (CoreType cur : values()) { + if (cur.code == code) { + return cur; + } + } + return NONE; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Crit1.java b/src/main/java/ru/r2cloud/jradio/catsat/Crit1.java new file mode 100644 index 00000000..f084e04d --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Crit1.java @@ -0,0 +1,209 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Crit1 { + + private BeaconElementHeader hk141; + private short obcTempMcu; + private int obcBootCnt; + private long obcClock; + private BeaconElementHeader hk191; + private int bpxVbatt; + private short bpxTemp; + private long bpxBootCnt; + private BeaconElementHeader hk541; + private short ax100TempBrd; + private int ax100BootCnt; + private long ax100LastContact; + private BeaconElementHeader hk841; + private long p60BootCnt; + private int p60BattMode; + private int p60BattVoltage; + private short p60BattCurrent; + private BeaconElementHeader hk94; + private short[] pduX2Cout; + + public Crit1() { + // do nothing + } + + public Crit1(DataInputStream dis) throws IOException { + hk141 = new BeaconElementHeader(dis); + obcTempMcu = dis.readShort(); + obcBootCnt = dis.readUnsignedShort(); + obcClock = StreamUtils.readUnsignedInt(dis); + hk191 = new BeaconElementHeader(dis); + bpxVbatt = dis.readUnsignedShort(); + bpxTemp = dis.readShort(); + bpxBootCnt = StreamUtils.readUnsignedInt(dis); + hk541 = new BeaconElementHeader(dis); + ax100TempBrd = dis.readShort(); + ax100BootCnt = dis.readUnsignedShort(); + ax100LastContact = StreamUtils.readUnsignedInt(dis); + hk841 = new BeaconElementHeader(dis); + p60BootCnt = StreamUtils.readUnsignedInt(dis); + p60BattMode = dis.readUnsignedByte(); + p60BattVoltage = dis.readUnsignedShort(); + p60BattCurrent = dis.readShort(); + hk94 = new BeaconElementHeader(dis); + pduX2Cout = StreamUtils.readShortArray(dis, 9); + } + + public BeaconElementHeader getHk141() { + return hk141; + } + + public void setHk141(BeaconElementHeader hk141) { + this.hk141 = hk141; + } + + public short getObcTempMcu() { + return obcTempMcu; + } + + public void setObcTempMcu(short obcTempMcu) { + this.obcTempMcu = obcTempMcu; + } + + public int getObcBootCnt() { + return obcBootCnt; + } + + public void setObcBootCnt(int obcBootCnt) { + this.obcBootCnt = obcBootCnt; + } + + public long getObcClock() { + return obcClock; + } + + public void setObcClock(long obcClock) { + this.obcClock = obcClock; + } + + public BeaconElementHeader getHk191() { + return hk191; + } + + public void setHk191(BeaconElementHeader hk191) { + this.hk191 = hk191; + } + + public int getBpxVbatt() { + return bpxVbatt; + } + + public void setBpxVbatt(int bpxVbatt) { + this.bpxVbatt = bpxVbatt; + } + + public short getBpxTemp() { + return bpxTemp; + } + + public void setBpxTemp(short bpxTemp) { + this.bpxTemp = bpxTemp; + } + + public long getBpxBootCnt() { + return bpxBootCnt; + } + + public void setBpxBootCnt(long bpxBootCnt) { + this.bpxBootCnt = bpxBootCnt; + } + + public BeaconElementHeader getHk541() { + return hk541; + } + + public void setHk541(BeaconElementHeader hk541) { + this.hk541 = hk541; + } + + public short getAx100TempBrd() { + return ax100TempBrd; + } + + public void setAx100TempBrd(short ax100TempBrd) { + this.ax100TempBrd = ax100TempBrd; + } + + public int getAx100BootCnt() { + return ax100BootCnt; + } + + public void setAx100BootCnt(int ax100BootCnt) { + this.ax100BootCnt = ax100BootCnt; + } + + public long getAx100LastContact() { + return ax100LastContact; + } + + public void setAx100LastContact(long ax100LastContact) { + this.ax100LastContact = ax100LastContact; + } + + public BeaconElementHeader getHk841() { + return hk841; + } + + public void setHk841(BeaconElementHeader hk841) { + this.hk841 = hk841; + } + + public long getP60BootCnt() { + return p60BootCnt; + } + + public void setP60BootCnt(long p60BootCnt) { + this.p60BootCnt = p60BootCnt; + } + + public int getP60BattMode() { + return p60BattMode; + } + + public void setP60BattMode(int p60BattMode) { + this.p60BattMode = p60BattMode; + } + + public int getP60BattVoltage() { + return p60BattVoltage; + } + + public void setP60BattVoltage(int p60BattVoltage) { + this.p60BattVoltage = p60BattVoltage; + } + + public short getP60BattCurrent() { + return p60BattCurrent; + } + + public void setP60BattCurrent(short p60BattCurrent) { + this.p60BattCurrent = p60BattCurrent; + } + + public BeaconElementHeader getHk94() { + return hk94; + } + + public void setHk94(BeaconElementHeader hk94) { + this.hk94 = hk94; + } + + public short[] getPduX2Cout() { + return pduX2Cout; + } + + public void setPduX2Cout(short[] pduX2Cout) { + this.pduX2Cout = pduX2Cout; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Crit2.java b/src/main/java/ru/r2cloud/jradio/catsat/Crit2.java new file mode 100644 index 00000000..ee4c9882 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Crit2.java @@ -0,0 +1,189 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Crit2 { + + private BeaconElementHeader hk1042; + private short[] pduX3Cout; + private BeaconElementHeader hk1142; + private int[] acuPower; + private BeaconElementHeader hk442; + private int adcsBootCnt; + private long adcsClock; + private BeaconElementHeader hk41502; + private float[] extgyro; + private float[] gpsPos; + private float[] gpsVel; + private BeaconElementHeader hk41512; + private int acsMode; + private int statusExtmag; + private int[] statusFss; + private int statusExtgyro; + private int statusGps; + + public Crit2() { + // do nothing + } + + public Crit2(DataInputStream dis) throws IOException { + hk1042 = new BeaconElementHeader(dis); + pduX3Cout = StreamUtils.readShortArray(dis, 9); + hk1142 = new BeaconElementHeader(dis); + acuPower = StreamUtils.readUnsignedShortArray(dis, 6); + hk442 = new BeaconElementHeader(dis); + adcsBootCnt = dis.readUnsignedShort(); + adcsClock = StreamUtils.readUnsignedInt(dis); + hk41502 = new BeaconElementHeader(dis); + extgyro = StreamUtils.readFloatArray(dis, 3); + gpsPos = StreamUtils.readFloatArray(dis, 3); + gpsVel = StreamUtils.readFloatArray(dis, 3); + hk41512 = new BeaconElementHeader(dis); + acsMode = dis.readUnsignedByte(); + statusExtmag = dis.readUnsignedByte(); + statusFss = StreamUtils.readUnsignedByteArray(dis, 5); + statusExtgyro = dis.readUnsignedByte(); + statusGps = dis.readUnsignedByte(); + } + + public BeaconElementHeader getHk1042() { + return hk1042; + } + + public void setHk1042(BeaconElementHeader hk1042) { + this.hk1042 = hk1042; + } + + public short[] getPduX3Cout() { + return pduX3Cout; + } + + public void setPduX3Cout(short[] pduX3Cout) { + this.pduX3Cout = pduX3Cout; + } + + public BeaconElementHeader getHk1142() { + return hk1142; + } + + public void setHk1142(BeaconElementHeader hk1142) { + this.hk1142 = hk1142; + } + + public int[] getAcuPower() { + return acuPower; + } + + public void setAcuPower(int[] acuPower) { + this.acuPower = acuPower; + } + + public BeaconElementHeader getHk442() { + return hk442; + } + + public void setHk442(BeaconElementHeader hk442) { + this.hk442 = hk442; + } + + public int getAdcsBootCnt() { + return adcsBootCnt; + } + + public void setAdcsBootCnt(int adcsBootCnt) { + this.adcsBootCnt = adcsBootCnt; + } + + public long getAdcsClock() { + return adcsClock; + } + + public void setAdcsClock(long adcsClock) { + this.adcsClock = adcsClock; + } + + public BeaconElementHeader getHk41502() { + return hk41502; + } + + public void setHk41502(BeaconElementHeader hk41502) { + this.hk41502 = hk41502; + } + + public float[] getExtgyro() { + return extgyro; + } + + public void setExtgyro(float[] extgyro) { + this.extgyro = extgyro; + } + + public float[] getGpsPos() { + return gpsPos; + } + + public void setGpsPos(float[] gpsPos) { + this.gpsPos = gpsPos; + } + + public float[] getGpsVel() { + return gpsVel; + } + + public void setGpsVel(float[] gpsVel) { + this.gpsVel = gpsVel; + } + + public BeaconElementHeader getHk41512() { + return hk41512; + } + + public void setHk41512(BeaconElementHeader hk41512) { + this.hk41512 = hk41512; + } + + public int getAcsMode() { + return acsMode; + } + + public void setAcsMode(int acsMode) { + this.acsMode = acsMode; + } + + public int getStatusExtmag() { + return statusExtmag; + } + + public void setStatusExtmag(int statusExtmag) { + this.statusExtmag = statusExtmag; + } + + public int[] getStatusFss() { + return statusFss; + } + + public void setStatusFss(int[] statusFss) { + this.statusFss = statusFss; + } + + public int getStatusExtgyro() { + return statusExtgyro; + } + + public void setStatusExtgyro(int statusExtgyro) { + this.statusExtgyro = statusExtgyro; + } + + public int getStatusGps() { + return statusGps; + } + + public void setStatusGps(int statusGps) { + this.statusGps = statusGps; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Dep.java b/src/main/java/ru/r2cloud/jradio/catsat/Dep.java new file mode 100644 index 00000000..9ce93abf --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Dep.java @@ -0,0 +1,71 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Dep { + + private BeaconElementHeader hk1966; + private short[] antBrn; + private byte[] antRel; + private short[] dspBrn; + private byte[] dspRel; + + public Dep() { + // do nothing + } + + public Dep(DataInputStream dis) throws IOException { + hk1966 = new BeaconElementHeader(dis); + antBrn = StreamUtils.readShortArray(dis, 4); + antRel = new byte[4]; + dis.readFully(antRel); + dspBrn = StreamUtils.readShortArray(dis, 2); + dspRel = new byte[2]; + dis.readFully(dspRel); + } + + public BeaconElementHeader getHk1966() { + return hk1966; + } + + public void setHk1966(BeaconElementHeader hk1966) { + this.hk1966 = hk1966; + } + + public short[] getAntBrn() { + return antBrn; + } + + public void setAntBrn(short[] antBrn) { + this.antBrn = antBrn; + } + + public byte[] getAntRel() { + return antRel; + } + + public void setAntRel(byte[] antRel) { + this.antRel = antRel; + } + + public short[] getDspBrn() { + return dspBrn; + } + + public void setDspBrn(short[] dspBrn) { + this.dspBrn = dspBrn; + } + + public byte[] getDspRel() { + return dspRel; + } + + public void setDspRel(byte[] dspRel) { + this.dspRel = dspRel; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Motd.java b/src/main/java/ru/r2cloud/jradio/catsat/Motd.java new file mode 100644 index 00000000..1ee8c776 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Motd.java @@ -0,0 +1,53 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; + +public class Motd { + + private BeaconElementHeader header; + private String callsign; + private String motd; + + public Motd() { + // do nothing + } + + public Motd(DataInputStream dis) throws IOException { + header = new BeaconElementHeader(dis); + byte[] callsignBytes = new byte[8]; + dis.readFully(callsignBytes); + callsign = new String(callsignBytes, StandardCharsets.US_ASCII); + byte[] motdBytes = new byte[80]; + dis.readFully(motdBytes); + motd = new String(motdBytes, StandardCharsets.US_ASCII); + } + + public BeaconElementHeader getHeader() { + return header; + } + + public void setHeader(BeaconElementHeader header) { + this.header = header; + } + + public String getCallsign() { + return callsign; + } + + public void setCallsign(String callsign) { + this.callsign = callsign; + } + + public String getMotd() { + return motd; + } + + public void setMotd(String motd) { + this.motd = motd; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/MpttMode.java b/src/main/java/ru/r2cloud/jradio/catsat/MpttMode.java new file mode 100644 index 00000000..2a30b578 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/MpttMode.java @@ -0,0 +1,22 @@ +package ru.r2cloud.jradio.catsat; + +public enum MpttMode { + + TRACKING(1), FIXED(2), UNKNOWN(255); + + private final int code; + + private MpttMode(int code) { + this.code = code; + } + + public static MpttMode valueOfCode(int code) { + for (MpttMode cur : values()) { + if (cur.code == code) { + return cur; + } + } + return UNKNOWN; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Obc.java b/src/main/java/ru/r2cloud/jradio/catsat/Obc.java new file mode 100644 index 00000000..8ebeb3ee --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Obc.java @@ -0,0 +1,349 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Obc { + + private BeaconElementHeader hk143; + private int obcFsMnted; + private short obcTempRam; + private long obcResetcause; + private long obcBootcause; + private long obcUptime; + private BeaconElementHeader hk1913; + private int battCharge; + private int battDcharge; + private int battHeater; + private short battTemp2; + private short battTemp3; + private short battTemp4; + private int battBootcause; + private BeaconElementHeader hk1943; + private float[] satTemps; + private BeaconElementHeader hk503; + private int ax100RebootIn; + private long ax100TxInhibit; + private BeaconElementHeader hk513; + private long ax100RxFreq; + private long ax100RxBaud; + private BeaconElementHeader hk543; + private short ax100TempPa; + private short ax100LastRssi; + private short ax100LastRferr; + private int ax100ActiveConf; + private int ax100Bootcause; + private short ax100BgndRssi; + private int ax100TxDuty; + private BeaconElementHeader hk553; + private long ax100TxFreq; + private long ax100TxBaud;; + + public Obc() { + // do nothing + } + + public Obc(DataInputStream dis) throws IOException { + hk143 = new BeaconElementHeader(dis); + obcFsMnted = dis.readUnsignedByte(); + obcTempRam = dis.readShort(); + obcResetcause = StreamUtils.readUnsignedInt(dis); + obcBootcause = StreamUtils.readUnsignedInt(dis); + obcUptime = StreamUtils.readUnsignedInt(dis); + hk1913 = new BeaconElementHeader(dis); + battCharge = dis.readUnsignedShort(); + battDcharge = dis.readUnsignedShort(); + battHeater = dis.readUnsignedShort(); + battTemp2 = dis.readShort(); + battTemp3 = dis.readShort(); + battTemp4 = dis.readShort(); + battBootcause = dis.readUnsignedByte(); + hk1943 = new BeaconElementHeader(dis); + satTemps = StreamUtils.readFloatArray(dis, 6); + hk503 = new BeaconElementHeader(dis); + ax100RebootIn = dis.readUnsignedShort(); + ax100TxInhibit = StreamUtils.readUnsignedInt(dis); + hk513 = new BeaconElementHeader(dis); + ax100RxFreq = StreamUtils.readUnsignedInt(dis); + ax100RxBaud = StreamUtils.readUnsignedInt(dis); + hk543 = new BeaconElementHeader(dis); + ax100TempPa = dis.readShort(); + ax100LastRssi = dis.readShort(); + ax100LastRferr = dis.readShort(); + ax100ActiveConf = dis.readUnsignedByte(); + ax100Bootcause = dis.readUnsignedShort(); + ax100BgndRssi = dis.readShort(); + ax100TxDuty = dis.readUnsignedByte(); + hk553 = new BeaconElementHeader(dis); + ax100TxFreq = StreamUtils.readUnsignedInt(dis); + ax100TxBaud = StreamUtils.readUnsignedInt(dis); + } + + public BeaconElementHeader getHk143() { + return hk143; + } + + public void setHk143(BeaconElementHeader hk143) { + this.hk143 = hk143; + } + + public int getObcFsMnted() { + return obcFsMnted; + } + + public void setObcFsMnted(int obcFsMnted) { + this.obcFsMnted = obcFsMnted; + } + + public short getObcTempRam() { + return obcTempRam; + } + + public void setObcTempRam(short obcTempRam) { + this.obcTempRam = obcTempRam; + } + + public long getObcResetcause() { + return obcResetcause; + } + + public void setObcResetcause(long obcResetcause) { + this.obcResetcause = obcResetcause; + } + + public long getObcBootcause() { + return obcBootcause; + } + + public void setObcBootcause(long obcBootcause) { + this.obcBootcause = obcBootcause; + } + + public long getObcUptime() { + return obcUptime; + } + + public void setObcUptime(long obcUptime) { + this.obcUptime = obcUptime; + } + + public BeaconElementHeader getHk1913() { + return hk1913; + } + + public void setHk1913(BeaconElementHeader hk1913) { + this.hk1913 = hk1913; + } + + public int getBattCharge() { + return battCharge; + } + + public void setBattCharge(int battCharge) { + this.battCharge = battCharge; + } + + public int getBattDcharge() { + return battDcharge; + } + + public void setBattDcharge(int battDcharge) { + this.battDcharge = battDcharge; + } + + public int getBattHeater() { + return battHeater; + } + + public void setBattHeater(int battHeater) { + this.battHeater = battHeater; + } + + public short getBattTemp2() { + return battTemp2; + } + + public void setBattTemp2(short battTemp2) { + this.battTemp2 = battTemp2; + } + + public short getBattTemp3() { + return battTemp3; + } + + public void setBattTemp3(short battTemp3) { + this.battTemp3 = battTemp3; + } + + public short getBattTemp4() { + return battTemp4; + } + + public void setBattTemp4(short battTemp4) { + this.battTemp4 = battTemp4; + } + + public int getBattBootcause() { + return battBootcause; + } + + public void setBattBootcause(int battBootcause) { + this.battBootcause = battBootcause; + } + + public BeaconElementHeader getHk1943() { + return hk1943; + } + + public void setHk1943(BeaconElementHeader hk1943) { + this.hk1943 = hk1943; + } + + public float[] getSatTemps() { + return satTemps; + } + + public void setSatTemps(float[] satTemps) { + this.satTemps = satTemps; + } + + public BeaconElementHeader getHk503() { + return hk503; + } + + public void setHk503(BeaconElementHeader hk503) { + this.hk503 = hk503; + } + + public int getAx100RebootIn() { + return ax100RebootIn; + } + + public void setAx100RebootIn(int ax100RebootIn) { + this.ax100RebootIn = ax100RebootIn; + } + + public long getAx100TxInhibit() { + return ax100TxInhibit; + } + + public void setAx100TxInhibit(long ax100TxInhibit) { + this.ax100TxInhibit = ax100TxInhibit; + } + + public BeaconElementHeader getHk513() { + return hk513; + } + + public void setHk513(BeaconElementHeader hk513) { + this.hk513 = hk513; + } + + public long getAx100RxFreq() { + return ax100RxFreq; + } + + public void setAx100RxFreq(long ax100RxFreq) { + this.ax100RxFreq = ax100RxFreq; + } + + public long getAx100RxBaud() { + return ax100RxBaud; + } + + public void setAx100RxBaud(long ax100RxBaud) { + this.ax100RxBaud = ax100RxBaud; + } + + public BeaconElementHeader getHk543() { + return hk543; + } + + public void setHk543(BeaconElementHeader hk543) { + this.hk543 = hk543; + } + + public short getAx100TempPa() { + return ax100TempPa; + } + + public void setAx100TempPa(short ax100TempPa) { + this.ax100TempPa = ax100TempPa; + } + + public short getAx100LastRssi() { + return ax100LastRssi; + } + + public void setAx100LastRssi(short ax100LastRssi) { + this.ax100LastRssi = ax100LastRssi; + } + + public short getAx100LastRferr() { + return ax100LastRferr; + } + + public void setAx100LastRferr(short ax100LastRferr) { + this.ax100LastRferr = ax100LastRferr; + } + + public int getAx100ActiveConf() { + return ax100ActiveConf; + } + + public void setAx100ActiveConf(int ax100ActiveConf) { + this.ax100ActiveConf = ax100ActiveConf; + } + + public int getAx100Bootcause() { + return ax100Bootcause; + } + + public void setAx100Bootcause(int ax100Bootcause) { + this.ax100Bootcause = ax100Bootcause; + } + + public short getAx100BgndRssi() { + return ax100BgndRssi; + } + + public void setAx100BgndRssi(short ax100BgndRssi) { + this.ax100BgndRssi = ax100BgndRssi; + } + + public int getAx100TxDuty() { + return ax100TxDuty; + } + + public void setAx100TxDuty(int ax100TxDuty) { + this.ax100TxDuty = ax100TxDuty; + } + + public BeaconElementHeader getHk553() { + return hk553; + } + + public void setHk553(BeaconElementHeader hk553) { + this.hk553 = hk553; + } + + public long getAx100TxFreq() { + return ax100TxFreq; + } + + public void setAx100TxFreq(long ax100TxFreq) { + this.ax100TxFreq = ax100TxFreq; + } + + public long getAx100TxBaud() { + return ax100TxBaud; + } + + public void setAx100TxBaud(long ax100TxBaud) { + this.ax100TxBaud = ax100TxBaud; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Pdu1.java b/src/main/java/ru/r2cloud/jradio/catsat/Pdu1.java new file mode 100644 index 00000000..fbb91f73 --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Pdu1.java @@ -0,0 +1,289 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Pdu1 { + + private BeaconElementHeader hk844; + private short[] p60Cout; + private int[] p60OutEn; + private short[] p60Temp; + private long p60Bootcause; + private long p60Uptime; + private int p60Resetcause; + private int[] p60Latchup; + private short p60VccC; + private int p60BattV; + private int p60DearmStatus; + private long p60WdtCntGnd; + private long p60WdtCntCan; + private long p60WdtCntLeft; + private short p60BattChrg; + private short p60BattDchrg; + private int ant6Depl; + private int ar6Depl; + private BeaconElementHeader hk944; + private short[] pduX2Vout; + private short pduX2Temp; + private int[] pduX2OutEn; + private long pduX2Bootcause; + private long pduX2BootCnt; + private long pduX2Uptime; + private int pduX2Resetcause; + private int[] pduX2Latchup; + + public Pdu1() { + // do nothing + } + + public Pdu1(DataInputStream dis) throws IOException { + hk844 = new BeaconElementHeader(dis); + p60Cout = StreamUtils.readShortArray(dis, 13); + p60OutEn = StreamUtils.readUnsignedByteArray(dis, 13); + p60Temp = StreamUtils.readShortArray(dis, 2); + p60Bootcause = StreamUtils.readUnsignedInt(dis); + p60Uptime = StreamUtils.readUnsignedInt(dis); + p60Resetcause = dis.readUnsignedShort(); + p60Latchup = StreamUtils.readUnsignedShortArray(dis, 13); + p60VccC = dis.readShort(); + p60BattV = dis.readUnsignedShort(); + p60DearmStatus = dis.readUnsignedByte(); + p60WdtCntGnd = StreamUtils.readUnsignedInt(dis); + p60WdtCntCan = StreamUtils.readUnsignedInt(dis); + p60WdtCntLeft = StreamUtils.readUnsignedInt(dis); + p60BattChrg = dis.readShort(); + p60BattDchrg = dis.readShort(); + ant6Depl = dis.readUnsignedByte(); + ar6Depl = dis.readUnsignedByte(); + hk944 = new BeaconElementHeader(dis); + pduX2Vout = StreamUtils.readShortArray(dis, 9); + pduX2Temp = dis.readShort(); + pduX2OutEn = StreamUtils.readUnsignedByteArray(dis, 9); + pduX2Bootcause = StreamUtils.readUnsignedInt(dis); + pduX2BootCnt = StreamUtils.readUnsignedInt(dis); + pduX2Uptime = StreamUtils.readUnsignedInt(dis); + pduX2Resetcause = dis.readUnsignedShort(); + pduX2Latchup = StreamUtils.readUnsignedShortArray(dis, 9); + } + + public BeaconElementHeader getHk844() { + return hk844; + } + + public void setHk844(BeaconElementHeader hk844) { + this.hk844 = hk844; + } + + public short[] getP60Cout() { + return p60Cout; + } + + public void setP60Cout(short[] p60Cout) { + this.p60Cout = p60Cout; + } + + public int[] getP60OutEn() { + return p60OutEn; + } + + public void setP60OutEn(int[] p60OutEn) { + this.p60OutEn = p60OutEn; + } + + public short[] getP60Temp() { + return p60Temp; + } + + public void setP60Temp(short[] p60Temp) { + this.p60Temp = p60Temp; + } + + public long getP60Bootcause() { + return p60Bootcause; + } + + public void setP60Bootcause(long p60Bootcause) { + this.p60Bootcause = p60Bootcause; + } + + public long getP60Uptime() { + return p60Uptime; + } + + public void setP60Uptime(long p60Uptime) { + this.p60Uptime = p60Uptime; + } + + public int getP60Resetcause() { + return p60Resetcause; + } + + public void setP60Resetcause(int p60Resetcause) { + this.p60Resetcause = p60Resetcause; + } + + public int[] getP60Latchup() { + return p60Latchup; + } + + public void setP60Latchup(int[] p60Latchup) { + this.p60Latchup = p60Latchup; + } + + public short getP60VccC() { + return p60VccC; + } + + public void setP60VccC(short p60VccC) { + this.p60VccC = p60VccC; + } + + public int getP60BattV() { + return p60BattV; + } + + public void setP60BattV(int p60BattV) { + this.p60BattV = p60BattV; + } + + public int getP60DearmStatus() { + return p60DearmStatus; + } + + public void setP60DearmStatus(int p60DearmStatus) { + this.p60DearmStatus = p60DearmStatus; + } + + public long getP60WdtCntGnd() { + return p60WdtCntGnd; + } + + public void setP60WdtCntGnd(long p60WdtCntGnd) { + this.p60WdtCntGnd = p60WdtCntGnd; + } + + public long getP60WdtCntCan() { + return p60WdtCntCan; + } + + public void setP60WdtCntCan(long p60WdtCntCan) { + this.p60WdtCntCan = p60WdtCntCan; + } + + public long getP60WdtCntLeft() { + return p60WdtCntLeft; + } + + public void setP60WdtCntLeft(long p60WdtCntLeft) { + this.p60WdtCntLeft = p60WdtCntLeft; + } + + public short getP60BattChrg() { + return p60BattChrg; + } + + public void setP60BattChrg(short p60BattChrg) { + this.p60BattChrg = p60BattChrg; + } + + public short getP60BattDchrg() { + return p60BattDchrg; + } + + public void setP60BattDchrg(short p60BattDchrg) { + this.p60BattDchrg = p60BattDchrg; + } + + public int getAnt6Depl() { + return ant6Depl; + } + + public void setAnt6Depl(int ant6Depl) { + this.ant6Depl = ant6Depl; + } + + public int getAr6Depl() { + return ar6Depl; + } + + public void setAr6Depl(int ar6Depl) { + this.ar6Depl = ar6Depl; + } + + public BeaconElementHeader getHk944() { + return hk944; + } + + public void setHk944(BeaconElementHeader hk944) { + this.hk944 = hk944; + } + + public short[] getPduX2Vout() { + return pduX2Vout; + } + + public void setPduX2Vout(short[] pduX2Vout) { + this.pduX2Vout = pduX2Vout; + } + + public short getPduX2Temp() { + return pduX2Temp; + } + + public void setPduX2Temp(short pduX2Temp) { + this.pduX2Temp = pduX2Temp; + } + + public int[] getPduX2OutEn() { + return pduX2OutEn; + } + + public void setPduX2OutEn(int[] pduX2OutEn) { + this.pduX2OutEn = pduX2OutEn; + } + + public long getPduX2Bootcause() { + return pduX2Bootcause; + } + + public void setPduX2Bootcause(long pduX2Bootcause) { + this.pduX2Bootcause = pduX2Bootcause; + } + + public long getPduX2BootCnt() { + return pduX2BootCnt; + } + + public void setPduX2BootCnt(long pduX2BootCnt) { + this.pduX2BootCnt = pduX2BootCnt; + } + + public long getPduX2Uptime() { + return pduX2Uptime; + } + + public void setPduX2Uptime(long pduX2Uptime) { + this.pduX2Uptime = pduX2Uptime; + } + + public int getPduX2Resetcause() { + return pduX2Resetcause; + } + + public void setPduX2Resetcause(int pduX2Resetcause) { + this.pduX2Resetcause = pduX2Resetcause; + } + + public int[] getPduX2Latchup() { + return pduX2Latchup; + } + + public void setPduX2Latchup(int[] pduX2Latchup) { + this.pduX2Latchup = pduX2Latchup; + } + +} diff --git a/src/main/java/ru/r2cloud/jradio/catsat/Pdu2.java b/src/main/java/ru/r2cloud/jradio/catsat/Pdu2.java new file mode 100644 index 00000000..594195bf --- /dev/null +++ b/src/main/java/ru/r2cloud/jradio/catsat/Pdu2.java @@ -0,0 +1,219 @@ +package ru.r2cloud.jradio.catsat; + +import java.io.DataInputStream; +import java.io.IOException; + +import ru.r2cloud.jradio.bobcat1.BeaconElementHeader; +import ru.r2cloud.jradio.util.StreamUtils; + +public class Pdu2 { + + private BeaconElementHeader hk1045; + private short[] pduX3Vout; + private short pduX3Temp; + private int[] pduX3OutEn; + private long pduX3Bootcause; + private long pduX3BootCnt; + private long pduX3Uptime; + private int pduX3Resetcause; + private int[] pduX3Latchup; + private BeaconElementHeader hk1145; + private short[] acuCin; + private int[] acuVin; + private int acuVbatt; + private short[] acuTemp; + private MpttMode acuMpptMode; + private int[] acuVboost; + private long acuBootcause; + private long acuBootCnt; + private long acuUptime; + private int acuResetcause; + + public Pdu2() { + // do nothing + } + + public Pdu2(DataInputStream dis) throws IOException { + hk1045 = new BeaconElementHeader(dis); + pduX3Vout = StreamUtils.readShortArray(dis, 9); + pduX3Temp = dis.readShort(); + pduX3OutEn = StreamUtils.readUnsignedByteArray(dis, 9); + pduX3Bootcause = StreamUtils.readUnsignedInt(dis); + pduX3BootCnt = StreamUtils.readUnsignedInt(dis); + pduX3Uptime = StreamUtils.readUnsignedInt(dis); + pduX3Resetcause = dis.readUnsignedShort(); + pduX3Latchup = StreamUtils.readUnsignedShortArray(dis, 9); + hk1145 = new BeaconElementHeader(dis); + acuCin = StreamUtils.readShortArray(dis, 6); + acuVin = StreamUtils.readUnsignedShortArray(dis, 6); + acuVbatt = dis.readUnsignedShort(); + acuTemp = StreamUtils.readShortArray(dis, 3); + acuMpptMode = MpttMode.valueOfCode(dis.readUnsignedByte()); + acuVboost = StreamUtils.readUnsignedShortArray(dis, 6); + acuBootcause = StreamUtils.readUnsignedInt(dis); + acuBootCnt = StreamUtils.readUnsignedInt(dis); + acuUptime = StreamUtils.readUnsignedInt(dis); + acuResetcause = dis.readUnsignedShort(); + } + + public BeaconElementHeader getHk1045() { + return hk1045; + } + + public void setHk1045(BeaconElementHeader hk1045) { + this.hk1045 = hk1045; + } + + public short[] getPduX3Vout() { + return pduX3Vout; + } + + public void setPduX3Vout(short[] pduX3Vout) { + this.pduX3Vout = pduX3Vout; + } + + public short getPduX3Temp() { + return pduX3Temp; + } + + public void setPduX3Temp(short pduX3Temp) { + this.pduX3Temp = pduX3Temp; + } + + public int[] getPduX3OutEn() { + return pduX3OutEn; + } + + public void setPduX3OutEn(int[] pduX3OutEn) { + this.pduX3OutEn = pduX3OutEn; + } + + public long getPduX3Bootcause() { + return pduX3Bootcause; + } + + public void setPduX3Bootcause(long pduX3Bootcause) { + this.pduX3Bootcause = pduX3Bootcause; + } + + public long getPduX3BootCnt() { + return pduX3BootCnt; + } + + public void setPduX3BootCnt(long pduX3BootCnt) { + this.pduX3BootCnt = pduX3BootCnt; + } + + public long getPduX3Uptime() { + return pduX3Uptime; + } + + public void setPduX3Uptime(long pduX3Uptime) { + this.pduX3Uptime = pduX3Uptime; + } + + public int getPduX3Resetcause() { + return pduX3Resetcause; + } + + public void setPduX3Resetcause(int pduX3Resetcause) { + this.pduX3Resetcause = pduX3Resetcause; + } + + public int[] getPduX3Latchup() { + return pduX3Latchup; + } + + public void setPduX3Latchup(int[] pduX3Latchup) { + this.pduX3Latchup = pduX3Latchup; + } + + public BeaconElementHeader getHk1145() { + return hk1145; + } + + public void setHk1145(BeaconElementHeader hk1145) { + this.hk1145 = hk1145; + } + + public short[] getAcuCin() { + return acuCin; + } + + public void setAcuCin(short[] acuCin) { + this.acuCin = acuCin; + } + + public int[] getAcuVin() { + return acuVin; + } + + public void setAcuVin(int[] acuVin) { + this.acuVin = acuVin; + } + + public int getAcuVbatt() { + return acuVbatt; + } + + public void setAcuVbatt(int acuVbatt) { + this.acuVbatt = acuVbatt; + } + + public short[] getAcuTemp() { + return acuTemp; + } + + public void setAcuTemp(short[] acuTemp) { + this.acuTemp = acuTemp; + } + + public MpttMode getAcuMpptMode() { + return acuMpptMode; + } + + public void setAcuMpptMode(MpttMode acuMpptMode) { + this.acuMpptMode = acuMpptMode; + } + + public int[] getAcuVboost() { + return acuVboost; + } + + public void setAcuVboost(int[] acuVboost) { + this.acuVboost = acuVboost; + } + + public long getAcuBootcause() { + return acuBootcause; + } + + public void setAcuBootcause(long acuBootcause) { + this.acuBootcause = acuBootcause; + } + + public long getAcuBootCnt() { + return acuBootCnt; + } + + public void setAcuBootCnt(long acuBootCnt) { + this.acuBootCnt = acuBootCnt; + } + + public long getAcuUptime() { + return acuUptime; + } + + public void setAcuUptime(long acuUptime) { + this.acuUptime = acuUptime; + } + + public int getAcuResetcause() { + return acuResetcause; + } + + public void setAcuResetcause(int acuResetcause) { + this.acuResetcause = acuResetcause; + } + +} diff --git a/src/test/java/ru/r2cloud/jradio/catsat/CatsatBeaconTest.java b/src/test/java/ru/r2cloud/jradio/catsat/CatsatBeaconTest.java new file mode 100644 index 00000000..97d7e7e9 --- /dev/null +++ b/src/test/java/ru/r2cloud/jradio/catsat/CatsatBeaconTest.java @@ -0,0 +1,151 @@ +package ru.r2cloud.jradio.catsat; + +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 CatsatBeaconTest { + + @Test + public void testPdu1() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "83E78001010401029AFBC366B7CC9C0008002900310031FFEE000F00B200FB0003FFF800050007000400070101010001010100000000010101A601A0000000010000112F00010000000000000000000000000000000000000000000000000000FFF43FB601000000060000000000025C8901AC01F902024F0566B7CC9C00090D33016E0000022800000000008A0D22000001AB01000000000000010000000001000005950000112D00010000000000000000000000000000000000005E2076213CBE5F4C"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-pdu1.json", result); + } + + @Test + public void testObc() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "83E78001010301029A76EE66B7CC9C00010101AB0000000000000002000010F5AA6B66B7CC9C00010000000000000018001700180582C766B7CC9C000141E8000041860000416C0000418A000041740000414E00007EBD66B7CC9C0005000000000000E08966B7CC9C00051A0EE9E800002580F20766B7CC9C000501B400000000020001FF860BDB6C66B7CC9C00051A0EE9E80000096003EDF40FB3E7EAF1"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-obc.json", result); + } + + @Test + public void testCrit2() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "83E78001010202029A4F0566B7CC7E000A0004000301B400A00104000C00030007000696F766B7CC7E000B042308410029043E0867043D76EE66B7CC7E000408AE66B7CC7E606C66B7CC7E00043F06A0003ED5E8003F06E8004A136FB948D9BC1F4AC2F5C245DDC35CC4CB7CF4C51F16EC937666B7CC7E00040600FDFD01FDFD0001B0221FE2ED9F2971"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-crit2.json", result); + } + + @Test + public void testCrit1() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray("83E78001010102029A76EE66B7CC7E000101A705B766B7CC7DAA6B66B7CC7E00013FC100180000132FF20766B7CC7E000501B7000100000000FBC366B7CC7E000800003D4E033FBE00454F0566B7CC7E00090071000A0004000300050003000E00520003C4A485F9893005A9"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-crit1.json", result); + } + + @Test + public void testAdcs7() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "89E78001011101029A9B8566B7CC6000043EDAF81FBF64E921BDF4A34A3D6A03983D61D778BCE38B5ABBA700563F7F8223B90CA5C0B965734039E5F2A0C1077C45C1BC9B5A402133FD362109103708480EB7326A21B70485FAC3FB199A4440E666C42AA666442C0CCDBACECB173B1EDCDBBB0C89EB3B0DB1150000000000000000000000003FC90FD800000000BFC90FD8B73D5F063768C8F3B68665C9BA039E7D397C786C39E06050CC8EBF3D317FECB4"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs7.json", result); + } + + @Test + public void testAdcs1() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "89E78001010B01029A606C66B7CC600004C305576542BF8F6F43C1DB57419880000100000000440880000000000041C8000000000000440BC0003BFFFE00330000000AFFFF002C3EFA40003ED270003F01EC0041DD380001000000000000000000000000000000000000000000000000BD0E1DE83F7F7318BD63BFF80000000000000000000000000000000000000000000000000000000041CB800000000100004A065B2B48F13B1E4AC52E8E45E0A669C4C56B41C5102B1D66B7CC5E010A0A66B7CC6018DEB0AA80858A6C"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs1.json", result); + } + + @Test + public void testAdcs6() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray("89E78001011001029A37AC66B7CC600004006176EE66B7CC60000401019D01A2000000000000000208AE66B7CC60000010D05813276D296BE33A"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs6.json", result); + } + + @Test + public void testAdcs5() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "89E78001010F01029A3B1A66B7CC6000044142C5BAACCCA0F548A0E9B2CA0897494AC51E58C5036284C5DC5A36C5109E95D1CE15DA51A6278751100D2D0000000000000000BF3B870C3F2E44ADBF1907103F48C1C93E1569153DA3F26CBF18FA3A3F48BAB63E163ADD3DA618E600000000BA90EFF10000000000000000BA90EFF1000000000000271030E066B7CC6000040000003A00000040000000040000004291073E53C7172C68"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs5.json", result); + } + + @Test + public void testAdcs4() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "89E78001010E01029AED9366B7CC600004000000003F8C083100000000C2FEE4B742B3DA8743BED385BD1096243F7F729ABD62BCB800000000000000000000000000010001010101010100000043FA000043FA000043FA000043FA000043FA000043FA00000000000000000000000000000000000000000000000000000000000000000000000000000000250F975C51B4A388"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs4.json", result); + } + + @Test + public void testAdcs3() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "89E78001010D01029AED9366B7CC6000043EDCC747BF660255BDA832A73BFFDB28BA337160B97E9CE0391E3F400000000000000000000000003C16FB2C3BF304813C0EA6CA3EDCC747BF660255BDA832A73BFFDB28BA337160B97E9CE0391E3F403EDCBF21BF66041BBDA843583BFF56BE3C16FB2B3BF304803C0EA6CA000000000000000000000000000000000000000000000000000000003F7E689D00000000C306F5FF42C0EC8F43CC4A63BC56D7A73F7E689DBDE0E4FE000000000000000000000000336FC770342D682F"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs3.json", result); + } + + @Test + public void testPdu2() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "83E78001010501029A4F0566B7CC25000A000000000D1913A313AC000001700000000001A10000010101000000000000000100000541000010B6000100000000000000010000000000000000000096F766B7CC25000B02190433001B0220042E02240840082B082C0855087508493FA901BA01B401B90208B708B708B708B708B708B70000000100000BEB000010B60001B7998E42BC7FEE3B"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-pdu2.json", result); + } + + @Test + public void testDep() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray("83E78001010601029AFB7F66B7CC250001FFFBFFFB00550068FBFB0100000500030101126725019E18F39F"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-dep.json", result); + } + + @Test + public void testAdcs2() throws Exception { + byte[] data = ViterbiTest.hexStringToByteArray( + "89E78001010C01029A606C66B84F29000437388CA437048A3E34D6BF943696FEB5BB0E93B93B364AEFBB0FDA813B2E4DE5C42D2000445D599AC42E999A4453A66601010101000400250019001100F8010901410139C152D9A5C1D7C134408F29BE3F8000003F8000003F800000937666B84F29000406060303010200000000FDFD01FDFD000001000000000200B500E93F2446993F5199413E9F329ABDA06D89BCFEF6A9C2A000000000000042A00000019F68B99C698C967B"); + CatsatBeacon result = new CatsatBeacon(); + result.readBeacon(data); + AssertJson.assertObjectsEqual("CatsatBeacon-adcs2.json", result); + } + + @Test + public void testPojo() { + assertThat(CatsatBeacon.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Motd.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Crit1.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Crit2.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Obc.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Pdu1.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Pdu2.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Dep.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs0.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs1.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs2.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs3.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs4.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs5.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs6.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Adcs7.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Asdr1.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Asdr2.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + assertThat(Bcn.class, allOf(hasValidBeanConstructor(), hasValidGettersAndSetters())); + } +} diff --git a/src/test/resources/expected/CatsatBeacon-adcs1.json b/src/test/resources/expected/CatsatBeacon-adcs1.json new file mode 100644 index 00000000..1d19ee64 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs1.json @@ -0,0 +1,102 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 11, + "version": 1, + "satid": 666 + }, + "adcs1": { + "hk415011": { + "checksum": 24684, + "timestamp": 1723321440, + "source": 4 + }, + "extmag": [ + -133.34138, + 95.78014, + 387.7136 + ], + "extmagTemp": 19.0625, + "extmagValid": 1, + "suns": [ + 0.0, + 546.0, + 0.0, + 25.0, + 0.0, + 559.0 + ], + "sunsValid": 59, + "sunsTemp": [ + -2, + 51, + 0, + 10, + -1, + 44 + ], + "extgyro": [ + 0.48876953, + 0.41101074, + 0.5075073 + ], + "extgyroTemp": 27.652344, + "extgyroValid": 1, + "fss": [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + -0.03469649, + 0.99784994, + -0.055602998, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + "fssTemp": 25.4375, + "fssValid": [ + 0, + 0, + 1, + 0, + 0 + ], + "gpsPos": [ + 2201290.8, + 494040.94, + 6461255.0 + ], + "gpsVel": [ + 7188.8013, + -1579.3517, + -2306.6946 + ], + "gpsEpoch": 1723321438, + "gpsValid": 1, + "gpsSat": 10, + "gpsSatsol": 10, + "ppsUnix": 1723321440 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-adcs2.json b/src/test/resources/expected/CatsatBeacon-adcs2.json new file mode 100644 index 00000000..83780a8a --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs2.json @@ -0,0 +1,123 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 12, + "version": 1, + "satid": 666 + }, + "adcs2": { + "hk415012": { + "checksum": 24684, + "timestamp": 1723354921, + "source": 4 + }, + "wheelTorque": [ + 1.1E-5, + 7.9E-6, + 3.9999998E-7, + 4.5E-6 + ], + "wheelMomentum": [ + -0.002175553, + 0.002781566, + -0.0021950307, + 0.0026596722 + ], + "wheelSpeed": [ + -692.5, + 885.4, + -698.4, + 846.6 + ], + "wheelEnable": [ + 1, + 1, + 1, + 1 + ], + "wheelCurrent": [ + 4, + 37, + 25, + 17 + ], + "wheelTemp": [ + 248, + 265, + 321, + 313 + ], + "torquerDuty": [ + -13.178136, + -26.969337, + 4.4738455 + ], + "torquerCalib": [ + 1.0, + 1.0, + 1.0 + ], + "hk415112": { + "checksum": 37750, + "timestamp": 1723354921, + "source": 4 + }, + "acsMode": 6, + "acsDmode": 6, + "adsMode": 3, + "adsDmode": 3, + "ephemMode": 1, + "ephemDmode": 2, + "spinMode": 0, + "statusMag": 0, + "statusExtmag": 0, + "statusCss": 0, + "statusFss": [ + -3, + -3, + 1, + -3, + -3 + ], + "statusGyro": 0, + "statusExtgyro": 0, + "statusGps": 1, + "statusBdot": 0, + "statusUkf": 0, + "statusEtime": 0, + "statusEphem": 0, + "statusRun": 2, + "looptime": 181, + "maxLooptime": 233, + "bdotRate": [ + 0.64170223, + 0.8187447 + ], + "bdotDmag": [ + 0.31093293, + -0.07833392, + -0.031123476 + ], + "bdotTorquer": [ + -80.0, + 0.0, + 80.0 + ], + "bdotDetumble": 1 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-adcs3.json b/src/test/resources/expected/CatsatBeacon-adcs3.json new file mode 100644 index 00000000..20ea2d95 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs3.json @@ -0,0 +1,85 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 13, + "version": 1, + "satid": 666 + }, + "adcs3": { + "hk415213": { + "checksum": 60819, + "timestamp": 1723321440, + "source": 4 + }, + "ukfX": [ + 0.43120787, + -0.8984731, + -0.08212786, + 0.007808108, + -6.8452023E-4, + -2.4281768E-4, + 1.5091617E-4, + 0.0, + 0.0, + 0.0, + 0.0092151575, + 0.0074163084, + 0.008706758 + ], + "ukfQ": [ + 0.43120787, + -0.8984731, + -0.08212786, + 0.007808108 + ], + "ukfW": [ + -6.8452023E-4, + -2.4281768E-4, + 1.5091617E-4 + ], + "ukfXpred": [ + 0.4311457, + -0.89850014, + -0.0821597, + 0.007792323, + 0.009215157, + 0.007416308, + 0.008706758, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + "ukfZpred": [ + 0.0, + 0.9937838, + 0.0, + -134.96092, + 96.46203, + 408.58115, + -0.013112939, + 0.9937838, + -0.10981177, + 0.0, + 0.0, + 0.0 + ] + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-adcs4.json b/src/test/resources/expected/CatsatBeacon-adcs4.json new file mode 100644 index 00000000..13150b76 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs4.json @@ -0,0 +1,83 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 14, + "version": 1, + "satid": 666 + }, + "adcs4": { + "hk415214": { + "checksum": 60819, + "timestamp": 1723321440, + "source": 4 + }, + "ukfZ": [ + 0.0, + 1.094, + 0.0, + -127.44671, + 89.92681, + 381.6525, + -0.035299435, + 0.99784243, + -0.055355757, + 0.0, + 0.0, + 0.0 + ], + "ukfEnable": [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "ukfSunmax": [ + 500.0, + 500.0, + 500.0, + 500.0, + 500.0, + 500.0 + ], + "ukfInEclipse": 0, + "ukfChoice": 0, + "ukfCtrlT": [ + 0.0, + 0.0, + 0.0 + ], + "ukfCtrlM": [ + 0.0, + 0.0, + 0.0 + ], + "ukfRate": [ + 0.0, + 0.0, + 0.0 + ] + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-adcs5.json b/src/test/resources/expected/CatsatBeacon-adcs5.json new file mode 100644 index 00000000..71e8f29b --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs5.json @@ -0,0 +1,84 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 15, + "version": 1, + "satid": 666 + }, + "adcs5": { + "hk415315": { + "checksum": 15130, + "timestamp": 1723321440, + "source": 4 + }, + "ephemJdat": 2460533.3499947735, + "ephemReci": [ + 329549.56, + -2237906.2, + 6459180.0 + ], + "ephemVeci": [ + -2102.1572, + -7051.2764, + -2313.9114 + ], + "ephemSunEci": [ + -1.10641234E11, + 8.9203466E10, + 3.8668521E10 + ], + "ephemQuatIe": [ + 0.0, + 0.0, + -0.7325294, + 0.6807354 + ], + "ephemQuatIo": [ + -0.597764, + 0.7842069, + 0.14590867, + 0.08005223 + ], + "ephemQuatIl": [ + -0.59756815, + 0.784099, + 0.14670892, + 0.08110218 + ], + "ephemRateIo": [ + 0.0, + -0.0011057836, + 0.0 + ], + "ephemRateIl": [ + 0.0, + -0.0011057836, + 0.0 + ], + "ephemTEclipse": 10000, + "hk415615": { + "checksum": 12512, + "timestamp": 1723321440, + "source": 4 + }, + "ephemTime": 58, + "adsTime": 64, + "acsTime": 4, + "sensTime": 66 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-adcs6.json b/src/test/resources/expected/CatsatBeacon-adcs6.json new file mode 100644 index 00000000..1264354e --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs6.json @@ -0,0 +1,44 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 16, + "version": 1, + "satid": 666 + }, + "adcs6": { + "hk4116": { + "checksum": 14252, + "timestamp": 1723321440, + "source": 4 + }, + "adcsSwloadCnt1": 97, + "hk4416": { + "checksum": 30446, + "timestamp": 1723321440, + "source": 4 + }, + "adcsFsMounted": 1, + "adcsTempMcu": 413, + "adcsTempRam": 418, + "adcsResetcause": 0, + "adcsBootcause": 2, + "adcsBootCnt": 2222, + "adcsClock": 1723321440, + "adcsUptime": 4304 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-adcs7.json b/src/test/resources/expected/CatsatBeacon-adcs7.json new file mode 100644 index 00000000..38925e15 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-adcs7.json @@ -0,0 +1,90 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 17, + "version": 1, + "satid": 666 + }, + "adcs7": { + "hk415417": { + "checksum": 39813, + "timestamp": 1723321440, + "source": 4 + }, + "ctrlRefq": [ + 0.42767426, + -0.89418226, + -0.119452074, + 0.057132334 + ], + "ctrlErrq": [ + 0.055137128, + -0.027776409, + -0.0050964756, + 0.9980795 + ], + "ctrlErrrate": [ + -1.3413187E-4, + -2.1882076E-4, + 4.3859053E-4 + ], + "ctrlM": [ + -8.467839, + -23.575855, + 2.518798 + ], + "ctrlMwtorque": [ + 2.3996145E-6, + 8.123008E-6, + -1.0634337E-5, + -7.899007E-6 + ], + "ctrlMwspeed": [ + -502.2, + 771.6, + -682.6, + 688.2 + ], + "ctrlMwmoment": [ + -0.0015777078, + 0.0024240527, + -0.002144451, + 0.0021620442 + ], + "ctrlRefrate": [ + 0.0, + 0.0, + 0.0 + ], + "ctrlEuleroff": [ + 1.570796, + 0.0, + -1.570796 + ], + "ctrlBtorque": [ + -1.1287402E-5, + 1.3875065E-5, + -4.0053606E-6 + ], + "ctrlBmoment": [ + -5.02087E-4, + 2.4077453E-4, + 4.2796368E-4 + ] + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 4, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-crit1.json b/src/test/resources/expected/CatsatBeacon-crit1.json new file mode 100644 index 00000000..e2372f62 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-crit1.json @@ -0,0 +1,74 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 1, + "version": 2, + "satid": 666 + }, + "crit1": { + "hk141": { + "checksum": 30446, + "timestamp": 1723321470, + "source": 1 + }, + "obcTempMcu": 423, + "obcBootCnt": 1463, + "obcClock": 1723321469, + "hk191": { + "checksum": 43627, + "timestamp": 1723321470, + "source": 1 + }, + "bpxVbatt": 16321, + "bpxTemp": 24, + "bpxBootCnt": 4911, + "hk541": { + "checksum": 61959, + "timestamp": 1723321470, + "source": 5 + }, + "ax100TempBrd": 439, + "ax100BootCnt": 1, + "ax100LastContact": 0, + "hk841": { + "checksum": 64451, + "timestamp": 1723321470, + "source": 8 + }, + "p60BootCnt": 15694, + "p60BattMode": 3, + "p60BattVoltage": 16318, + "p60BattCurrent": 69, + "hk94": { + "checksum": 20229, + "timestamp": 1723321470, + "source": 9 + }, + "pduX2Cout": [ + 113, + 10, + 4, + 3, + 5, + 3, + 14, + 82, + 3 + ] + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 1, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-crit2.json b/src/test/resources/expected/CatsatBeacon-crit2.json new file mode 100644 index 00000000..d05754b5 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-crit2.json @@ -0,0 +1,97 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 2, + "version": 2, + "satid": 666 + }, + "crit2": { + "hk1042": { + "checksum": 20229, + "timestamp": 1723321470, + "source": 10 + }, + "pduX3Cout": [ + 4, + 3, + 436, + 160, + 260, + 12, + 3, + 7, + 6 + ], + "hk1142": { + "checksum": 38647, + "timestamp": 1723321470, + "source": 11 + }, + "acuPower": [ + 1059, + 2113, + 41, + 1086, + 2151, + 1085 + ], + "hk442": { + "checksum": 30446, + "timestamp": 1723321470, + "source": 4 + }, + "adcsBootCnt": 2222, + "adcsClock": 1723321470, + "hk41502": { + "checksum": 24684, + "timestamp": 1723321470, + "source": 4 + }, + "extgyro": [ + 0.5258789, + 0.41778564, + 0.52697754 + ], + "gpsPos": [ + 2415598.2, + 445920.97, + 6388449.0 + ], + "gpsVel": [ + 7096.42, + -1627.9048, + -2545.4326 + ], + "hk41512": { + "checksum": 37750, + "timestamp": 1723321470, + "source": 4 + }, + "acsMode": 6, + "statusExtmag": 0, + "statusFss": [ + 253, + 253, + 1, + 253, + 253 + ], + "statusExtgyro": 0, + "statusGps": 1 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 1, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-dep.json b/src/test/resources/expected/CatsatBeacon-dep.json new file mode 100644 index 00000000..5c15840c --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-dep.json @@ -0,0 +1,50 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 6, + "version": 1, + "satid": 666 + }, + "dep": { + "hk1966": { + "checksum": 64383, + "timestamp": 1723321381, + "source": 1 + }, + "antBrn": [ + -5, + -5, + 85, + 104 + ], + "antRel": [ + -5, + -5, + 1, + 0 + ], + "dspBrn": [ + 5, + 3 + ], + "dspRel": [ + 1, + 1 + ] + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 1, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-obc.json b/src/test/resources/expected/CatsatBeacon-obc.json new file mode 100644 index 00000000..bae7df1a --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-obc.json @@ -0,0 +1,93 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 3, + "version": 1, + "satid": 666 + }, + "obc": { + "hk143": { + "checksum": 30446, + "timestamp": 1723321500, + "source": 1 + }, + "obcFsMnted": 1, + "obcTempRam": 427, + "obcResetcause": 0, + "obcBootcause": 2, + "obcUptime": 4341, + "hk1913": { + "checksum": 43627, + "timestamp": 1723321500, + "source": 1 + }, + "battCharge": 0, + "battDcharge": 0, + "battHeater": 0, + "battTemp2": 24, + "battTemp3": 23, + "battTemp4": 24, + "battBootcause": 5, + "hk1943": { + "checksum": 33479, + "timestamp": 1723321500, + "source": 1 + }, + "satTemps": [ + 29.0, + 16.75, + 14.75, + 17.25, + 15.25, + 12.875 + ], + "hk503": { + "checksum": 32445, + "timestamp": 1723321500, + "source": 5 + }, + "ax100RebootIn": 0, + "ax100TxInhibit": 0, + "hk513": { + "checksum": 57481, + "timestamp": 1723321500, + "source": 5 + }, + "ax100RxFreq": 437185000, + "ax100RxBaud": 9600, + "hk543": { + "checksum": 61959, + "timestamp": 1723321500, + "source": 5 + }, + "ax100TempPa": 436, + "ax100LastRssi": 0, + "ax100LastRferr": 0, + "ax100ActiveConf": 2, + "ax100Bootcause": 1, + "ax100BgndRssi": -122, + "ax100TxDuty": 11, + "hk553": { + "checksum": 56172, + "timestamp": 1723321500, + "source": 5 + }, + "ax100TxFreq": 437185000, + "ax100TxBaud": 2400 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 1, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-pdu1.json b/src/test/resources/expected/CatsatBeacon-pdu1.json new file mode 100644 index 00000000..3e0bd8c3 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-pdu1.json @@ -0,0 +1,135 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 4, + "version": 1, + "satid": 666 + }, + "pdu1": { + "hk844": { + "checksum": 64451, + "timestamp": 1723321500, + "source": 8 + }, + "p60Cout": [ + 41, + 49, + 49, + -18, + 15, + 178, + 251, + 3, + -8, + 5, + 7, + 4, + 7 + ], + "p60OutEn": [ + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1 + ], + "p60Temp": [ + 422, + 416 + ], + "p60Bootcause": 1, + "p60Uptime": 4399, + "p60Resetcause": 1, + "p60Latchup": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "p60VccC": -12, + "p60BattV": 16310, + "p60DearmStatus": 1, + "p60WdtCntGnd": 6, + "p60WdtCntCan": 0, + "p60WdtCntLeft": 154761, + "p60BattChrg": 428, + "p60BattDchrg": 505, + "ant6Depl": 2, + "ar6Depl": 2, + "hk944": { + "checksum": 20229, + "timestamp": 1723321500, + "source": 9 + }, + "pduX2Vout": [ + 3379, + 366, + 0, + 552, + 0, + 0, + 138, + 3362, + 0 + ], + "pduX2Temp": 427, + "pduX2OutEn": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + "pduX2Bootcause": 1, + "pduX2BootCnt": 1429, + "pduX2Uptime": 4397, + "pduX2Resetcause": 1, + "pduX2Latchup": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 1, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file diff --git a/src/test/resources/expected/CatsatBeacon-pdu2.json b/src/test/resources/expected/CatsatBeacon-pdu2.json new file mode 100644 index 00000000..722fc6c7 --- /dev/null +++ b/src/test/resources/expected/CatsatBeacon-pdu2.json @@ -0,0 +1,108 @@ +{ + "beaconHeader": { + "protocolVersion": 1, + "type": 5, + "version": 1, + "satid": 666 + }, + "pdu2": { + "hk1045": { + "checksum": 20229, + "timestamp": 1723321381, + "source": 10 + }, + "pduX3Vout": [ + 0, + 0, + 3353, + 5027, + 5036, + 0, + 368, + 0, + 0 + ], + "pduX3Temp": 417, + "pduX3OutEn": [ + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + "pduX3Bootcause": 1, + "pduX3BootCnt": 1345, + "pduX3Uptime": 4278, + "pduX3Resetcause": 1, + "pduX3Latchup": [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "hk1145": { + "checksum": 38647, + "timestamp": 1723321381, + "source": 11 + }, + "acuCin": [ + 537, + 1075, + 27, + 544, + 1070, + 548 + ], + "acuVin": [ + 2112, + 2091, + 2092, + 2133, + 2165, + 2121 + ], + "acuVbatt": 16297, + "acuTemp": [ + 442, + 436, + 441 + ], + "acuMpptMode": "FIXED", + "acuVboost": [ + 2231, + 2231, + 2231, + 2231, + 2231, + 2231 + ], + "acuBootcause": 1, + "acuBootCnt": 3051, + "acuUptime": 4278, + "acuResetcause": 1 + }, + "header": { + "priority": "CSP_PRIO_NORM", + "source": 1, + "destination": 30, + "sourcePort": 0, + "destinationPort": 30, + "ffrag": false, + "fhmac": false, + "fxtea": false, + "frdp": false, + "fcrc32": true + }, + "beginSample": 0, + "beginMillis": 0, + "endSample": 0 +} \ No newline at end of file