#include <RecordAndDetailsParser.hh>

Inheritance diagram for RecordAndDetailsParser:

Collaboration diagram for RecordAndDetailsParser:

[legend]

Public Member Functions
	RecordAndDetailsParser ()

virtual	~RecordAndDetailsParser ()

int	parseJPEGRecord (u_int8_t const &ptr, u_int8_t const limit)

Static Public Member Functions
static DJITxtParser *	createNew ()

Private Member Functions
virtual void	parseDetailsArea (u_int8_t const &ptr, u_int8_t const limit)

virtual int	parseRecord (u_int8_t const &ptr, u_int8_t const limit, int isScrambled)

virtual void	summarizeRecordParsing ()

virtual void	outputOneRow (int outputColumnLabels)

void	parseRecord_OSD (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_HOME (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_GIMBAL (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_RC (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_CUSTOM (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_DEFORM (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_CENTER_BATTERY (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_SMART_BATTERY (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_APP_TIP (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_APP_WARN (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_RECOVER (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_APP_GPS (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_FIRMWARE (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_APP_SER_WARN (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecord_COMPONENT (u_int8_t const &ptr, u_int8_t const limit)

int	parseRecord_JPEG (u_int8_t const &ptr, u_int8_t const limit)

void	parseRecordUnknownFormat (char const recordTypeName, u_int8_t const &ptr, u_int8_t const *limit)

void	enterSubByteField (char const *label, u_int8_t byte, u_int8_t mask)

void	noteByteField (char const label, u_int8_t const &ptr, u_int8_t const *limit, float divisor=0.0, int isSigned=0)

void	note2ByteField (char const label, u_int8_t const &ptr, u_int8_t const *limit, float divisor=0.0, int16_t offset=0, int isSigned=0)

void	noteSigned2ByteField (char const label, u_int8_t const &ptr, u_int8_t const *limit, float divisor=0.0, int16_t offset=0)

void	noteUnsigned2ByteField (char const label, u_int8_t const &ptr, u_int8_t const *limit, float divisor=0.0, int16_t offset=0)

void	note4ByteField (char const label, u_int8_t const &ptr, u_int8_t const *limit, float divisor=0.0, int isSigned=0)

void	note4ByteFloatField (char const label, u_int8_t const &ptr, u_int8_t const *limit, float divisor=0.0)

void	note8ByteDoubleField (char const label, u_int8_t const &ptr, u_int8_t const *limit)

void	note8ByteLatitudeOrLongitudeFieldInRadians (char const label, u_int8_t const &ptr, u_int8_t const *limit)

void	note8ByteLatitudeOrLongitudeFieldInDegrees (char const label, u_int8_t const &ptr, u_int8_t const *limit)

void	note2ByteDateField (char const label, u_int8_t const &ptr, u_int8_t const *limit)

void	note8ByteTimestampField (char const label, u_int8_t const &ptr, u_int8_t const *limit, int isInMilliseconds=0)

void	noteStringField (char const label, u_int8_t const &ptr, unsigned stringLength, u_int8_t const *limit)

void	note3ByteVersionField (char const label, u_int8_t const &ptr, u_int8_t const *limit)

Private Attributes
unsigned	fNumRecords

RecordTypeStat	fRecordTypeStats [256]

char const *	fRecordTypeName [256]

unsigned	fMaxNumRecordsForOneType

FieldDatabase *	fFieldDatabase

Detailed Description

Definition at line 45 of file RecordAndDetailsParser.hh.

Constructor & Destructor Documentation

◆ RecordAndDetailsParser()

RecordAndDetailsParser::RecordAndDetailsParser ( )

Definition at line 41 of file RecordAndDetailsParser.cpp.

   : fNumRecords(0), fMaxNumRecordsForOneType(0), fFieldDatabase(new FieldDatabase) {
 #ifdef DEBUG_RECORD_PARSING
   // Initialize "fRecordTypeName":
   for (unsigned i = 0; i < 256; ++i) {
     fRecordTypeName[i] = NULL;
   }
   fRecordTypeName[0x01] = "OSD";
   fRecordTypeName[0x02] = "HOME";
   fRecordTypeName[0x03] = "GIMBAL";
   fRecordTypeName[0x04] = "RC";
   fRecordTypeName[0x05] = "CUSTOM";
   fRecordTypeName[0x06] = "DEFORM";
   fRecordTypeName[0x07] = "CENTER_BATTERY";
   fRecordTypeName[0x08] = "SMART_BATTERY";
   fRecordTypeName[0x09] = "APP_TIP";
   fRecordTypeName[0x0A] = "APP_WARN";
   fRecordTypeName[0x0B] = "RC_GPS";
   fRecordTypeName[0x0C] = "RC_DEBUG";
   fRecordTypeName[0x0D] = "RECOVER";
   fRecordTypeName[0x0E] = "APP_GPS";
   fRecordTypeName[0x0F] = "FIRMWARE";
   fRecordTypeName[0x10] = "OFDM_DEBUG";
   fRecordTypeName[0x11] = "VISION_GROUP";
   fRecordTypeName[0x12] = "VISION_WARN";
   fRecordTypeName[0x13] = "MC_PARAM";
   fRecordTypeName[0x14] = "APP_OPERATION";
   // What is record type 0x16? #####
   fRecordTypeName[0x18] = "APP_SER_WARN";
   // What is record type 0x19? #####
   // What is record type 0x1a? #####
   // What is record type 0x1e? #####
   // What is record type 0x28? #####
   fRecordTypeName[0x39] = "JPEG";
   fRecordTypeName[0xFE] = "OTHER";
 #endif
 }

References fRecordTypeName.

◆ ~RecordAndDetailsParser()

RecordAndDetailsParser::~RecordAndDetailsParser ( )

virtual

Definition at line 79 of file RecordAndDetailsParser.cpp.

                                                 {
   delete fFieldDatabase;
 }

References fFieldDatabase.

Member Function Documentation

◆ createNew()

DJITxtParser * DJITxtParser::createNew ( )

staticinherited

Definition at line 29 of file RecordAndDetailsParser.cpp.

                                       {
   return new RecordAndDetailsParser;
 }

Referenced by main().

◆ enterSubByteField()

void RecordAndDetailsParser::enterSubByteField	(	char const *	label,
		u_int8_t	byte,
		u_int8_t	mask
	)

private

Definition at line 29 of file parseFieldWithinRecord.cpp.

                                                                    {
   // First, use "mask" to select the bits that we want, and move them to the low-order part of the byte:
   byte &= mask;
   while (mask != 0x00 && (mask&0x01) == 0) {
     byte >>= 1;
     mask >>= 1;
   }
 
   fFieldDatabase->addByteField(label, byte, 0);
 }

Referenced by parseRecord_DEFORM(), parseRecord_GIMBAL(), parseRecord_HOME(), parseRecord_OSD(), parseRecord_RC(), and parseRecord_SMART_BATTERY().

◆ note2ByteDateField()

void RecordAndDetailsParser::note2ByteDateField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 123 of file parseFieldWithinRecord.cpp.

                                                                                    {
   u_int16_t bytes = get2BytesLE(ptr, limit);
   fFieldDatabase->add2ByteDateField(label, bytes);
 }

References get2BytesLE().

Referenced by parseRecord_CENTER_BATTERY().

◆ note2ByteField()

void RecordAndDetailsParser::note2ByteField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		float	divisor = `0.0`,
		int16_t	offset = `0`,
		int	isSigned = `0`
	)

private

Definition at line 56 of file parseFieldWithinRecord.cpp.

                                                                {
   u_int16_t bytes = get2BytesLE(ptr, limit);
   bytes -= offset;
 
   if (divisor != 0.0) {
     // Divide by this, and store the resulting value as a 'float' instead:
     float value = isSigned ? (int16_t)bytes/divisor : bytes/divisor;
     fFieldDatabase->addFloatField(label, value);
   } else {
     // Normal case:
     fFieldDatabase->add2ByteField(label, bytes, isSigned);
   }
 }

References get2BytesLE().

Referenced by noteSigned2ByteField(), and noteUnsigned2ByteField().

◆ note3ByteVersionField()

void RecordAndDetailsParser::note3ByteVersionField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 148 of file parseFieldWithinRecord.cpp.

                                                                                       {
   u_int8_t v1 = getByte(ptr, limit);
   u_int8_t v2 = getByte(ptr, limit);
   u_int8_t v3 = getByte(ptr, limit);
 
   // Pack these three bytes into a 4-byte value (big-endian), and store this:
   u_int32_t value = (v1<<24)|(v2<<16)|(v3<<8);
   fFieldDatabase->add4ByteVersionField(label, value);
 }

References getByte().

Referenced by parseDetailsArea(), parseRecord_FIRMWARE(), and parseRecord_RECOVER().

◆ note4ByteField()

void RecordAndDetailsParser::note4ByteField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		float	divisor = `0.0`,
		int	isSigned = `0`
	)

private

Definition at line 72 of file parseFieldWithinRecord.cpp.

                                               {
   u_int32_t bytes = getWord32LE(ptr, limit);
 
   if (divisor != 0.0) {
     // Divide by this, and store the resulting value as a 'float' instead:
     float value = isSigned ? (int32_t)bytes/divisor : bytes/divisor;
     fFieldDatabase->addFloatField(label, value);
   } else {
     // Normal case:
     fFieldDatabase->add4ByteField(label, bytes, isSigned);
   }
 }

References getWord32LE().

Referenced by parseDetailsArea(), parseRecord_CENTER_BATTERY(), and parseRecord_SMART_BATTERY().

◆ note4ByteFloatField()

void RecordAndDetailsParser::note4ByteFloatField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		float	divisor = `0.0`
	)

private

Definition at line 87 of file parseFieldWithinRecord.cpp.

                                      {
   u_int32_t bytes = getWord32LE(ptr, limit);
   float value = *(float*)&bytes;
   if (divisor != 0.0) value /= divisor;
   fFieldDatabase->addFloatField(label, value);
 }

References getWord32LE().

Referenced by parseDetailsArea(), parseRecord_APP_GPS(), parseRecord_CUSTOM(), parseRecord_HOME(), and parseRecord_SMART_BATTERY().

◆ note8ByteDoubleField()

void RecordAndDetailsParser::note8ByteDoubleField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 96 of file parseFieldWithinRecord.cpp.

                                                                                      {
   u_int64_t bytes = getWord64LE(ptr, limit);
   fFieldDatabase->addDoubleField(label, *(double*)&bytes);
 }

References getWord64LE().

Referenced by parseDetailsArea().

◆ note8ByteLatitudeOrLongitudeFieldInDegrees()

void RecordAndDetailsParser::note8ByteLatitudeOrLongitudeFieldInDegrees	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 115 of file parseFieldWithinRecord.cpp.

                                                                                                            {
   u_int64_t bytes = getWord64LE(ptr, limit);
   double* value = (double*)&bytes;
   
   fFieldDatabase->addDoubleField(label, *value);
 }

References getWord64LE().

Referenced by parseRecord_APP_GPS().

◆ note8ByteLatitudeOrLongitudeFieldInRadians()

void RecordAndDetailsParser::note8ByteLatitudeOrLongitudeFieldInRadians	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 106 of file parseFieldWithinRecord.cpp.

                                                                                                            {
   u_int64_t bytes = getWord64LE(ptr, limit);
   double* value = (double*)&bytes;
   
   // This value is in radians.  Convert it to degrees before storing it as a 'double':
   fFieldDatabase->addDoubleField(label, (*value)*(180/PI));
 }

References getWord64LE(), and PI.

Referenced by parseRecord_HOME(), and parseRecord_OSD().

◆ note8ByteTimestampField()

void RecordAndDetailsParser::note8ByteTimestampField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		int	isInMilliseconds = `0`
	)

private

Definition at line 129 of file parseFieldWithinRecord.cpp.

                                                 {
   u_int64_t value = getWord64LE(ptr, limit);
   fFieldDatabase->add8ByteTimestampField(label, value, isInMilliseconds);
 }

References getWord64LE().

Referenced by parseDetailsArea(), parseRecord_CUSTOM(), and parseRecord_RECOVER().

◆ noteByteField()

void RecordAndDetailsParser::noteByteField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		float	divisor = `0.0`,
		int	isSigned = `0`
	)

private

Definition at line 41 of file parseFieldWithinRecord.cpp.

                                              {
   u_int8_t byte = getByte(ptr, limit);
 
   if (divisor != 0.0) {
     // Divide by this, and store the resulting value as a 'float' instead:
     float value = isSigned ? (int8_t)byte/divisor : byte/divisor;
     fFieldDatabase->addFloatField(label, value);
   } else {
     // Normal case:
     fFieldDatabase->addByteField(label, byte, isSigned);
   }
 }

References getByte().

Referenced by parseDetailsArea(), parseRecord_CENTER_BATTERY(), parseRecord_GIMBAL(), parseRecord_HOME(), parseRecord_OSD(), parseRecord_RECOVER(), and parseRecord_SMART_BATTERY().

◆ noteSigned2ByteField()

void RecordAndDetailsParser::noteSigned2ByteField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		float	divisor = `0.0`,
		int16_t	offset = `0`
	)

inlineprivate

Definition at line 87 of file RecordAndDetailsParser.hh.

                                                                      {
     note2ByteField(label, ptr, limit, divisor, offset, 1);
   }

References note2ByteField().

Referenced by parseRecord_GIMBAL(), parseRecord_HOME(), parseRecord_OSD(), and parseRecord_RC().

◆ noteStringField()

void RecordAndDetailsParser::noteStringField	(	char const *	label,
		u_int8_t const *&	ptr,
		unsigned	stringLength,
		u_int8_t const *	limit
	)

private

Definition at line 136 of file parseFieldWithinRecord.cpp.

                                                                                                        {
   if (limit != NULL && ptr > limit - stringLength) throw END_OF_DATA;
 
   char str[stringLength+1];
   unsigned i;
   for (i = 0; i < stringLength; ++i) str[i] = *ptr++;
   str[i] = '\0';
 
   fFieldDatabase->addStringField(label, str);
 }

References END_OF_DATA.

Referenced by parseDetailsArea(), parseRecord_APP_SER_WARN(), parseRecord_APP_TIP(), parseRecord_APP_WARN(), parseRecord_COMPONENT(), and parseRecord_RECOVER().

◆ noteUnsigned2ByteField()

void RecordAndDetailsParser::noteUnsigned2ByteField	(	char const *	label,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		float	divisor = `0.0`,
		int16_t	offset = `0`
	)

inlineprivate

Definition at line 91 of file RecordAndDetailsParser.hh.

                                                                        {
     note2ByteField(label, ptr, limit, divisor, offset, 0);
   }

References note2ByteField().

Referenced by parseRecord_CENTER_BATTERY(), parseRecord_HOME(), parseRecord_OSD(), and parseRecord_SMART_BATTERY().

◆ outputOneRow()

void RecordAndDetailsParser::outputOneRow ( int outputColumnLabels )

privatevirtual

Implements DJITxtParser.

Definition at line 39 of file rowOutput.cpp.

                                                                 {
   oFirst("CUSTOM.updateTime");
   oFrac("CUSTOM.hSpeed", 2);
   oFrac("CUSTOM.distance", 2);
   oFrac("OSD.latitude", 6);
   oFrac("OSD.longitude", 6);
   oFrac("OSD.height", 1);
   oFrac("OSD.xSpeed", 1);
   oFrac("OSD.ySpeed", 1);
   oFrac("OSD.zSpeed", 1);
   oFrac("OSD.pitch", 1);
   oFrac("OSD.roll", 1);
   oFrac("OSD.yaw", 1);
   oInterpreted("OSD.flycState.RAW", "OSD.flycState");
   oInterpreted("OSD.flycCommand.RAW", "OSD.flycCommand");
   oBoolean("OSD.canIOCWork");
   oInterpreted("OSD.groundOrSky.RAW", "OSD.groundOrSky");
   oBoolean("OSD.isMotorUp");
   oBoolean("OSD.isSwaveWork");
   oInterpreted("OSD.goHomeStatus.RAW", "OSD.goHomeStatus");
   oBoolean("OSD.isImuPreheated");
   oBoolean("OSD.isVisionUsed");
   o("OSD.voltageWarning");
   o("OSD.modeChannel");
   oBoolean("OSD.compassError");
   oBoolean("OSD.waveError");
   o("OSD.gpsLevel");
   oInterpreted("OSD.batteryType.RAW", "OSD.batteryType");
   oBoolean("OSD.isAcceletorOverRange");
   oBoolean("OSD.isVibrating");
   oBoolean("OSD.isBarometerDeadInAir");
   oBoolean("OSD.isMotorBlocked");
   oBoolean("OSD.isNotEnoughForce");
   oBoolean("OSD.isPropellerCatapult");
   oBoolean("OSD.isGoHomeHeightModified");
   oBoolean("OSD.isOutOfLimit");
   o("OSD.gpsNum");
   o("OSD.flightAction");
   oInterpreted("OSD.flightAction.RAW", "OSD.flightAction");
   oInterpreted("OSD.motorStartFailedCause.RAW", "OSD.motorStartFailedCause");
   oInterpreted("OSD.nonGPSCause.RAW", "OSD.nonGPSCause");
   oBoolean("OSD.isQuickSpin");
   o("OSD.battery");
   oFrac("OSD.sWaveHeight", 1);
   oFrac("OSD.flyTime", 1);
   o("OSD.motorRevolution");
   o("OSD.flycVersion");
   oInterpreted("OSD.droneType.RAW", "OSD.droneType");
   oInterpreted("OSD.imuInitFailReason.RAW", "OSD.imuInitFailReason");
   oInterpreted("OSD.motorFailReason.RAW", "OSD.motorFailReason");
   oInterpreted("OSD.ctrlDevice.RAW", "OSD.ctrlDevice");
   oFrac("GIMBAL.pitch", 1);
   oFrac("GIMBAL.roll", 1);
   oFrac("GIMBAL.yaw", 1);
   oInterpreted("GIMBAL.mode.RAW", "GIMBAL.mode");
   oFrac("GIMBAL.rollAdjust", 1);
   oFrac("GIMBAL.yawAngle", 1);
   oBoolean("GIMBAL.isAutoCalibration");
   o("GIMBAL.autoCalibrationResult");
   oBoolean("GIMBAL.isPitchInLimit");
   oBoolean("GIMBAL.isRollInLimit");
   oBoolean("GIMBAL.isYawInLimit");
   oBoolean("GIMBAL.isStuck");
   o("GIMBAL.version");
   oBoolean("GIMBAL.isSingleClick");
   oBoolean("GIMBAL.isDoubleClick");
   oBoolean("GIMBAL.isTripleClick");
   o("RC.aileron");
   o("RC.elevator");
   o("RC.throttle");
   o("RC.rudder");
   o("RC.gimbal");
   o("RC.goHome");
   o("RC.mode");
   o("RC.wheelOffset");
   o("RC.record");
   o("RC.shutter");
   o("RC.playback");
   o("RC.custom1");
   o("RC.custom2");
   o("CENTER_BATTERY.relativeCapacity");
   o("CENTER_BATTERY.currentPV");
   o("CENTER_BATTERY.currentCapacity");
   o("CENTER_BATTERY.fullCapacity");
   o("CENTER_BATTERY.life");
   o("CENTER_BATTERY.loopNum");
   o("CENTER_BATTERY.errorType");
   o("CENTER_BATTERY.current");
   o("CENTER_BATTERY.voltageCell1");
   o("CENTER_BATTERY.voltageCell2");
   o("CENTER_BATTERY.voltageCell3");
   o("CENTER_BATTERY.voltageCell4");
   o("CENTER_BATTERY.voltageCell5");
   o("CENTER_BATTERY.voltageCell6");
   o("CENTER_BATTERY.serialNo");
   o("CENTER_BATTERY.productDate");
   o("CENTER_BATTERY.temperature");
   o("CENTER_BATTERY.connStatus");
   o("CENTER_BATTERY.totalStudyCycle");
   o("CENTER_BATTERY.lastStudyCycle");
   o("CENTER_BATTERY.isNeedStudy");
   o("CENTER_BATTERY.isBatteryOnCharge");
   o("SMART_BATTERY.usefulTime");
   o("SMART_BATTERY.goHomeTime");
   o("SMART_BATTERY.landTime");
   o("SMART_BATTERY.goHomeBattery");
   o("SMART_BATTERY.landBattery");
   o("SMART_BATTERY.safeFlyRadius");
   o("SMART_BATTERY.volumeConsume");
   oInterpreted("SMART_BATTERY.status.RAW", "SMART_BATTERY.status");
   oInterpreted("SMART_BATTERY.goHomeStatus.RAW", "SMART_BATTERY.goHomeStatus");
   o("SMART_BATTERY.goHomeCountdown");
   o("SMART_BATTERY.voltage");
   o("SMART_BATTERY.battery");
   o("SMART_BATTERY.lowWarning");
   o("SMART_BATTERY.lowWarningGoHome");
   o("SMART_BATTERY.seriousLowWarning");
   o("SMART_BATTERY.seriousLowWarningLanding");
   o("SMART_BATTERY.voltagePercent");
   o("DEFORM.isDeformProtected");
   oInterpreted("DEFORM.deformStatus.RAW", "DEFORM.deformStatus");
   oInterpreted("DEFORM.deformMode.RAW","DEFORM.deformMode");
   oFrac("HOME.latitude", 6);
   oFrac("HOME.longitude", 6);
   oFrac("HOME.height", 2);
   oBoolean("HOME.isHomeRecord");
   o("HOME.goHomeMode");
   o("HOME.aircraftHeadDirection");
   oBoolean("HOME.isDynamicHomePointEnabled");
   o("HOME.goHomeStatus");
   oBoolean("HOME.hasGoHome");
   o("HOME.compassCeleStatus");
   oBoolean("HOME.isCompassCeleing");
   oBoolean("HOME.isBeginnerMode");
   oBoolean("HOME.isIOCEnabled");
   oInterpreted("HOME.iocMode.RAW", "HOME.iocMode");
   o("HOME.goHomeHeight");
   oFrac("HOME.courseLockAngle", 1);
   o("HOME.dataRecorderStatus");
   o("HOME.dataRecorderRemainCapacity");
   o("HOME.dataRecorderRemainTime");
   o("HOME.dataRecorderFileIndex");
   o("HOME.maxAllowedHeight");
   oInterpreted("RECOVER.droneType.RAW", "RECOVER.droneType");
   oInterpreted("RECOVER.appType.RAW", "RECOVER.appType");
   o("RECOVER.appVersion");
   o("RECOVER.aircraftSn");
   o("RECOVER.aircraftName");
   o("RECOVER.activeTimestamp");
   o("RECOVER.cameraSn");
   o("RECOVER.rcSn");
   o("RECOVER.batterySn");
   o("FIRMWARE.version");
   o("COMPONENT.cameraSn");
   o("COMPONENT.aircraftSn");
   o("COMPONENT.rcSn");
   o("COMPONENT.batterySn");
   o("DETAILS.street");
   o("DETAILS.citypart");
   o("DETAILS.city");
   o("DETAILS.area");
   o("DETAILS.isFavorite");
   o("DETAILS.isNew");
   o("DETAILS.needUpload");
   o("DETAILS.recordLineCount");
   o("DETAILS.timestamp");
   oFrac("DETAILS.latitude", 6);
   oFrac("DETAILS.longitude", 6);
   oFrac("DETAILS.totalDistance", 2);
   oFrac("DETAILS.totalTime", 1);
   oFrac("DETAILS.maxHeight", 1);
   oFrac("DETAILS.maxHorizontalSpeed", 2);
   oFrac("DETAILS.maxVerticalSpeed", 1);
   o("DETAILS.photoNum");
   o("DETAILS.videoTime");
   o("DETAILS.activeTimestamp");
   o("DETAILS.aircraftName");
   o("DETAILS.aircraftSn");
   o("DETAILS.cameraSn");
   o("DETAILS.rcSn");
   o("DETAILS.batterySn");
   oInterpreted("DETAILS.appType.RAW", "DETAILS.appType");
   o("DETAILS.appVersion");
   oFrac("APP_GPS.latitude", 6);
   oFrac("APP_GPS.longitude", 6);
   o("APP_GPS.accuracy");
   o("APP_TIP.tip");
   o("APP_WARN.warn");
   o("APP_SER_WARN.warn");
   printf("\n");
 }

References o, oBoolean, oFirst, oFrac, and oInterpreted.

Referenced by parseRecord().

◆ parseDetailsArea()

void RecordAndDetailsParser::parseDetailsArea	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

privatevirtual

Implements DJITxtParser.

Definition at line 28 of file parseDetails.cpp.

                                                                                          {
   // DETAILS.cityPart: string (length 20):
   noteStringField("DETAILS.cityPart", ptr, 20, limit);
 
   // DETAILS.street: string (length 20):
   noteStringField("DETAILS.street", ptr, 20, limit);
 
   // DETAILS.city: string (length 20):
   noteStringField("DETAILS.city", ptr, 20, limit);
 
   // DETAILS.area: string (length 20):
   noteStringField("DETAILS.area", ptr, 20, limit);
 
   // DETAILS.isFavorite: 1 byte unsigned:
   noteByteField("DETAILS.isFavorite", ptr, limit);
 
   // DETAILS.isNew: 1 byte unsigned:
   noteByteField("DETAILS.isNew", ptr, limit);
 
   // DETAILS.needsUpload: 1 byte unsigned:
   noteByteField("DETAILS.needUpload", ptr, limit);
 
   // DETAILS.recordLineCount: 4 bytes little-endian unsigned::
   note4ByteField("DETAILS.recordLineCount", ptr, limit);
 
   // unknown (4 bytes):
   ptr += 4;
 
   // DETAILS.timestamp: 8 bytes little-endian, multiple of 0.001 seconds, in Unix time format:
   note8ByteTimestampField("DETAILS.timestamp", ptr, limit, 1/*is in ms*/);
 
   // DETAILS.longitude: 8 bytes little-endian double, in degrees:
   note8ByteDoubleField("DETAILS.longitude", ptr, limit);
 
   // DETAILS.latitude: 8 bytes little-endian double, in degrees:
   note8ByteDoubleField("DETAILS.latitude", ptr, limit);
 
   // DETAILS.totalDistance: 4 bytes little-endian float:
   note4ByteFloatField("DETAILS.totalDistance", ptr, limit);
 
   // DETAILS.totalTime: 4 bytes little-endian unsigned, multiple of 0.001m; convert to meters:
   note4ByteField("DETAILS.totalTime", ptr, limit, 1000.0);
 
   // DETAILS.maxHeight: 4 bytes little-endian float:
   note4ByteFloatField("DETAILS.maxHeight", ptr, limit);
 
   // DETAILS.maxHorizontalSpeed: 4 bytes little-endian float:
   note4ByteFloatField("DETAILS.maxHorizontalSpeed", ptr, limit);
 
   // DETAILS.maxVerticalSpeed: 4 bytes little-endian float:                                         
   note4ByteFloatField("DETAILS.maxVerticalSpeed", ptr, limit);
 
   // DETAILS.photoNum: 4 bytes little-endian unsigned:
   note4ByteField("DETAILS.photoNum", ptr, limit);
 
   // DETAILS.videoTime: 4 bytes little-endian unsigned:
   note4ByteField("DETAILS.videoTime", ptr, limit);
 
   // The format from here on depends upon the file version:
   extern u_int8_t fileVersionNumber;
   if (fileVersionNumber < 0x06) {
     // unknown (124 bytes)
     ptr += 124;
 
     // DETAILS.aircraftSnBytes: string (length 10):
     noteStringField("DETAILS.aircraftSn", ptr, 10, limit);
 
     // unknown (1 byte)
     ++ptr;
 
     // DETAILS.aircraftName: string (length 25):
     noteStringField("DETAILS.aircraftName", ptr, 25, limit);
 
     // unknown (7 bytes)
     ptr += 7;
 
     // DETAILS.activeTimestamp: 8 bytes little-endian, in Unix time format:
     note8ByteTimestampField("DETAILS.activeTimestamp", ptr, limit);
 
     // DETAILS.cameraSn: string (length 10):
     noteStringField("DETAILS.cameraSn", ptr, 10, limit);
 
     // DETAILS.rcSn: string (length 10):
     noteStringField("DETAILS.rcSn", ptr, 10, limit);
 
     // DETAILS.batterySn: string (length 10):
     noteStringField("DETAILS.batterySn", ptr, 10, limit);
   } else {
     // Where is "DETAILS.activeTimestamp", and how is it formatted? #####
     // unknown (137 bytes)
     ptr += 137;
 
     // DETAILS.aircraftName: string (length 32):
     noteStringField("DETAILS.aircraftName", ptr, 32, limit);
 
     // DETAILS.aircraftSnBytes: string (length 16):
     noteStringField("DETAILS.aircraftSn", ptr, 16, limit);
 
     // DETAILS.cameraSn: string (length 16):
     noteStringField("DETAILS.cameraSn", ptr, 16, limit);
 
     // DETAILS.rcSn: string (length 16):
     noteStringField("DETAILS.rcSn", ptr, 16, limit);
 
     // DETAILS.batterySn: string (length 16):
     noteStringField("DETAILS.batterySn", ptr, 16, limit);
   }
 
   // DETAILS.appType.RAW: 1 byte unsigned:
   noteByteField("DETAILS.appType.RAW", ptr, limit);
 
   // DETAILS.appVersion: 3 bytes:
   note3ByteVersionField("DETAILS.appVersion", ptr, limit);
 }

References fileVersionNumber, note3ByteVersionField(), note4ByteField(), note4ByteFloatField(), note8ByteDoubleField(), note8ByteTimestampField(), noteByteField(), and noteStringField().

◆ parseJPEGRecord()

int RecordAndDetailsParser::parseJPEGRecord	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

◆ parseRecord()

int RecordAndDetailsParser::parseRecord	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit,
		int	isScrambled
	)

privatevirtual

Implements DJITxtParser.

Definition at line 62 of file parseRecord.cpp.

                                                                                                     {
   // Attempt to parse a record; Returns 1 iff it succeeds.
   try {
     // The first two bytes are the 'record type' and the 'record length':
     u_int8_t recordType = getByte(ptr, limit);
     unsigned recordLength = getByte(ptr, limit);
 
     // Record statistics about the record type and length:
     ++fNumRecords;
     RecordTypeStat& stat = fRecordTypeStats[recordType]; // alias
     ++stat.count;
     if (stat.count > fMaxNumRecordsForOneType) fMaxNumRecordsForOneType = stat.count;
     if (recordLength < stat.minLength) stat.minLength = recordLength;
     if (recordLength > stat.maxLength) stat.maxLength = recordLength;
 #ifdef DEBUG_RECORD_PARSING
     char const* recordTypeName = fRecordTypeName[recordType];
     if (recordTypeName == NULL) recordTypeName = "???";
     fprintf(stderr, "[%d]\trecordType %d[%s], recordLength %d\n", fRecordTypeStats[RECORD_TYPE_OSD].count, recordType, recordTypeName, recordLength);
 #endif
 
     if (recordType == RECORD_TYPE_JPEG) {
       u_int16_t next2Bytes = get2BytesBE(ptr, limit); ptr -= 2; // back up over those two bytes
       if (next2Bytes == 0x0000) {
         // This record contains one or more JPEG images, and needs to be handled especially.
         // (In particular, the 'recordLength' seems to be irrelevant in this case)
         return parseRecord_JPEG(ptr, limit);
       }
     } else if (recordType == 0xFF && recordLength == JPEG_SOI_BYTE) {
       // Some old log formats start JPEG images this way.  Back up 4 bytes; handle them the same way:
       ptr -=4;
       return parseRecord_JPEG(ptr, limit);
     }
 
     // Check the record length, and whether there's a 0xFF byte at the end:
     if (ptr + recordLength + 1 >= limit) throw END_OF_DATA;
     if (ptr[recordLength] != 0xFF) {
       // In newer versions of the format, some records have an extra byte before the 0xFF.  Check:
       if (ptr + recordLength + 2 < limit && ptr[recordLength+1] == 0xFF) {
         fprintf(stderr, "Extra byte 0x%02x seen in record (type 0x%x)\n", ptr[recordLength], recordType);
         ++recordLength;
       } else {
         fprintf(stderr, "'End of record' byte (0xFF) not seen; advancing to the next 0xFF\n");
         do {
           ++recordLength;
         } while (ptr + recordLength + 1 < limit && ptr[recordLength+1] != 0xFF);
         if (ptr + recordLength + 1 >= limit) throw END_OF_DATA;
       }
     }
     u_int8_t const* recordStart = ptr;
     u_int8_t const* recordLimit = ptr + recordLength; // position of the 0xFF 'End of record' byte
     ptr += recordLength + 1; // advance to the next record, if any
 
     u_int8_t unscrambledRecord[recordLength-1]; // used only if "isScrambled"
     if (isScrambled) {
       // We need to unscramble the record data before we can parse it.
 
       // The next byte (along with the 'record type') is used as a key to unscramble the data:
       u_int8_t keyByte = getByte(recordStart, limit);
       --recordLength;
 
       // Get an array of 8 bytes - used to unscramble the data:
       u_int8_t scrambleBytes[8];
       getScrambleBytes(recordType, keyByte, scrambleBytes);
 
       // Unscramble each byte in the record by XORing it with the 'scrambleBytes':
       for (unsigned i = 0; i < recordLength; ++i) {
         unscrambledRecord[i] = recordStart[i] ^ scrambleBytes[i%8];
       }
 
       recordStart = unscrambledRecord;
       recordLimit = unscrambledRecord + recordLength;
     }
 
     switch (recordType) {
       case RECORD_TYPE_OSD: {
         // Because an 'OSD' record effectively starts a new row of data, output a row of data
         // before we parse it (except for the very first 'OSD' record, where we output
         // the column labels instead):
         outputOneRow(fRecordTypeStats[RECORD_TYPE_OSD].count == 1);
         parseRecord_OSD(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_HOME: {
         parseRecord_HOME(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_GIMBAL: {
         parseRecord_GIMBAL(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_RC: {
         parseRecord_RC(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_CUSTOM: {
         parseRecord_CUSTOM(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_DEFORM: {
         parseRecord_DEFORM(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_CENTER_BATTERY: {
         parseRecord_CENTER_BATTERY(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_SMART_BATTERY: {
         parseRecord_SMART_BATTERY(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_APP_TIP: {
         parseRecord_APP_TIP(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_APP_WARN: {
         parseRecord_APP_WARN(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_RC_GPS: {
         parseRecordUnknownFormat("RC_GPS", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_RC_DEBUG: {
         parseRecordUnknownFormat("RC_DEBUG", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_RECOVER: {
         parseRecord_RECOVER(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_APP_GPS: {
         parseRecord_APP_GPS(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_FIRMWARE: {
         parseRecord_FIRMWARE(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_OFDM_DEBUG: {
         parseRecordUnknownFormat("OFDM_DEBUG", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_VISION_GROUP: {
         parseRecordUnknownFormat("VISION_GROUP", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_VISION_WARN: {
         parseRecordUnknownFormat("VISION_WARN", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_MC_PARAM: {
         parseRecordUnknownFormat("MC_PARAM", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_APP_OPERATION: {
         parseRecordUnknownFormat("APP_OPERATION", recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_APP_SER_WARN: {
         parseRecord_APP_SER_WARN(recordStart, recordLimit);
         break;
       }
       case RECORD_TYPE_COMPONENT: {
         parseRecord_COMPONENT(recordStart, recordLimit);
         break;
       }
       default: {
 #ifdef DEBUG_RECORD_PARSING
         char const* recordTypeName = fRecordTypeName[recordType];
         if (recordTypeName == NULL) {
           fprintf(stderr, "Unknown record type 0x%02x\n", recordType);
         } else {
           fprintf(stderr, "Unhandled record type 0x%02x [%s]\n", recordType, recordTypeName);
         }
 #else
         fprintf(stderr, "Unhandled record type 0x%02x\n", recordType);
 #endif
       }
     }
   } catch (int /*e*/) {
     fprintf(stderr, "Unexpected error in parsing\n");
     return 0;
   }
 
   return 1;
 }

References RecordTypeStat::count, END_OF_DATA, fMaxNumRecordsForOneType, fNumRecords, fRecordTypeName, fRecordTypeStats, get2BytesBE(), getByte(), getScrambleBytes(), JPEG_SOI_BYTE, RecordTypeStat::maxLength, RecordTypeStat::minLength, outputOneRow(), parseRecord_APP_GPS(), parseRecord_APP_SER_WARN(), parseRecord_APP_TIP(), parseRecord_APP_WARN(), parseRecord_CENTER_BATTERY(), parseRecord_COMPONENT(), parseRecord_CUSTOM(), parseRecord_DEFORM(), parseRecord_FIRMWARE(), parseRecord_GIMBAL(), parseRecord_HOME(), parseRecord_JPEG(), parseRecord_OSD(), parseRecord_RC(), parseRecord_RECOVER(), parseRecord_SMART_BATTERY(), parseRecordUnknownFormat(), RECORD_TYPE_APP_GPS, RECORD_TYPE_APP_OPERATION, RECORD_TYPE_APP_SER_WARN, RECORD_TYPE_APP_TIP, RECORD_TYPE_APP_WARN, RECORD_TYPE_CENTER_BATTERY, RECORD_TYPE_COMPONENT, RECORD_TYPE_CUSTOM, RECORD_TYPE_DEFORM, RECORD_TYPE_FIRMWARE, RECORD_TYPE_GIMBAL, RECORD_TYPE_HOME, RECORD_TYPE_JPEG, RECORD_TYPE_MC_PARAM, RECORD_TYPE_OFDM_DEBUG, RECORD_TYPE_OSD, RECORD_TYPE_RC, RECORD_TYPE_RC_DEBUG, RECORD_TYPE_RC_GPS, RECORD_TYPE_RECOVER, RECORD_TYPE_SMART_BATTERY, RECORD_TYPE_VISION_GROUP, and RECORD_TYPE_VISION_WARN.

◆ parseRecord_APP_GPS()

void RecordAndDetailsParser::parseRecord_APP_GPS	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_APP_GPS.cpp.

                                                                                             {
   // APP_GPS.latitude: 8 bytes little-endian double, in degrees:
   note8ByteLatitudeOrLongitudeFieldInDegrees("APP_GPS.latitude", ptr, limit);
 
   // APP_GPS.longitude: 8 bytes little-endian double, in degrees:
   note8ByteLatitudeOrLongitudeFieldInDegrees("APP_GPS.longitude", ptr, limit);
 
   // APP_GPS.accuracy: 4 bytes little-endian float:
   note4ByteFloatField("APP_GPS.accuracy", ptr, limit);
 }

References note4ByteFloatField(), and note8ByteLatitudeOrLongitudeFieldInDegrees().

Referenced by parseRecord().

◆ parseRecord_APP_SER_WARN()

void RecordAndDetailsParser::parseRecord_APP_SER_WARN	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_APP_SER_WARN.cpp.

                                                                                                  {
   // APP_SER_WARN.warn: string (length of the entire record):
   noteStringField("APP_SER_WARN.warn", ptr, limit-ptr, limit);
 }

References noteStringField().

Referenced by parseRecord().

◆ parseRecord_APP_TIP()

void RecordAndDetailsParser::parseRecord_APP_TIP	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_APP_TIP.cpp.

                                                                                             {
   // APP_TIP.tip: string (length of the entire record):
   noteStringField("APP_TIP.tip", ptr, limit-ptr, limit);
 }

References noteStringField().

Referenced by parseRecord().

◆ parseRecord_APP_WARN()

void RecordAndDetailsParser::parseRecord_APP_WARN	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_APP_WARN.cpp.

                                                                                              {
   // APP_WARN.warn: string (length of the entire record):
   noteStringField("APP_WARN.warn", ptr, limit-ptr, limit);
 }

References noteStringField().

Referenced by parseRecord().

◆ parseRecord_CENTER_BATTERY()

void RecordAndDetailsParser::parseRecord_CENTER_BATTERY	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_CENTER_BATTERY.cpp.

                                                                                                    {
   // CENTER_BATTERY.relativeCapacity: 1 byte unsigned:
   noteByteField("CENTER_BATTERY.relativeCapacity", ptr, limit);
 
   // CENTER_BATTERY.currentPV: 2 bytes unsigned little-endian; multiple of 0.001 volts; convert to volts:
   noteUnsigned2ByteField("CENTER_BATTERY.currentPV", ptr, limit, 1000.0);
 
   // CENTER_BATTERY.currentCapacity: 2 bytes unsigned little-endian:
   noteUnsigned2ByteField("CENTER_BATTERY.currentCapacity", ptr, limit);
 
   // CENTER_BATTERY.fullCapacity: 2 bytes unsigned little-endian:
   noteUnsigned2ByteField("CENTER_BATTERY.fullCapacity", ptr, limit);
 
   // CENTER_BATTERY.life: 1 byte unsigned:
   noteByteField("CENTER_BATTERY.life", ptr, limit);
 
   // CENTER_BATTERY.loopNum: 2 bytes unsigned little-endian:
   noteUnsigned2ByteField("CENTER_BATTERY.loopNum", ptr, limit);
 
   // CENTER_BATTERY.errorType: 4 bytes unsigned little-endian:
   note4ByteField("CENTER_BATTERY.errorType", ptr, limit);
 
   // CENTER_BATTERY.current: 2 bytes unsigned little-endian, multiple of 0.001 amps; convert to amps:
   noteUnsigned2ByteField("CENTER_BATTERY.current", ptr, limit, 1000.0);
   // CHECK VALUE! #####
 
   // CENTER_BATTERY.voltageCell(1 through 6): 2 bytes unsigned little-endian, multiple of 0.001 volts; convert to volts:
   noteUnsigned2ByteField("CENTER_BATTERY.voltageCell1", ptr, limit, 1000.0);
   noteUnsigned2ByteField("CENTER_BATTERY.voltageCell2", ptr, limit, 1000.0);
   noteUnsigned2ByteField("CENTER_BATTERY.voltageCell3", ptr, limit, 1000.0);
   noteUnsigned2ByteField("CENTER_BATTERY.voltageCell4", ptr, limit, 1000.0);
   noteUnsigned2ByteField("CENTER_BATTERY.voltageCell5", ptr, limit, 1000.0);
   noteUnsigned2ByteField("CENTER_BATTERY.voltageCell6", ptr, limit, 1000.0);
 
   // CENTER_BATTERY.serialNo: 2 bytes unsigned little-endian:
   noteUnsigned2ByteField("CENTER_BATTERY.serialNo", ptr, limit);
 
   // CENTER_BATTERY.productDate: 2 bytes little-endian: 7 bits (years since 1980) + 4 bits (month) + 5 bits (day of month):
   note2ByteDateField("CENTER_BATTERY.productDate", ptr, limit);
 
   // CENTER_BATTERY.temperature: 2 bytes unsigned little-endian, multiple of 0.01 C; convert to C:
   noteUnsigned2ByteField("CENTER_BATTERY.temperature", ptr, limit, 100.0);
   // CHECK VALUE #####
 
   // CENTER_BATTERY.connStatus.RAW: 1 byte unsigned:
   noteByteField("CENTER_BATTERY.connStatus.RAW", ptr, limit);
 }

References note2ByteDateField(), note4ByteField(), noteByteField(), and noteUnsigned2ByteField().

Referenced by parseRecord().

◆ parseRecord_COMPONENT()

void RecordAndDetailsParser::parseRecord_COMPONENT	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_COMPONENT.cpp.

                                                                                               {
   // Because these records always seem to appear at the beginning of the file, before the
   // first OSD record, treat each (known) component type as a separate column in the output:
 
   // COMPONENT.type: 2 bytes little-endian unsigned
   u_int16_t componentType = get2BytesLE(ptr, limit);
 
   // Length of the following serial number: 1 byte
   unsigned serialNumberLength = getByte(ptr, limit);
 
   // COMPONENT.<type>Sn: string (length "serialNumberLength"):
   noteStringField(componentType == 1 ? "COMPONENT.cameraSn":
                   componentType == 2 ? "COMPONENT.aircraftSn":
                   componentType == 3 ? "COMPONENT.rcSn":
                   componentType == 4 ? "COMPONENT.batterySn":
                   "COMPONENT.unknownSn",
                   ptr, serialNumberLength, limit);
 }

References get2BytesLE(), getByte(), and noteStringField().

Referenced by parseRecord().

◆ parseRecord_CUSTOM()

void RecordAndDetailsParser::parseRecord_CUSTOM	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_CUSTOM.cpp.

                                                                                            {
   // unknown (2 bytes):
   ptr += 2;
 
   // CUSTOM.hSpeed: 4 bytes little-endian float:
   note4ByteFloatField("CUSTOM.hSpeed", ptr, limit);
 
   // CUSTOM.distance: 4 bytes little-endian float:
   note4ByteFloatField("CUSTOM.distance", ptr, limit);
 
   // CUSTOM.updateTime: 8 bytes little-endian, multiple of 0.001 seconds, in Unix time format:
   note8ByteTimestampField("CUSTOM.updateTime", ptr, limit, 1/*is in ms*/);
 }

References note4ByteFloatField(), and note8ByteTimestampField().

Referenced by parseRecord().

◆ parseRecord_DEFORM()

void RecordAndDetailsParser::parseRecord_DEFORM	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_DEFORM.cpp.

                                                                                            {
   // unknown (2 bits) + DEFORM.deformMode.RAW (2 bits) + DEFORM.deformStatus.RAW (3 bits) + DEFORM.isDeformProtected (1 bit):
   u_int8_t byte = getByte(ptr, limit);
   enterSubByteField("DEFORM.deformMode.RAW", byte, 0x30);
   enterSubByteField("DEFORM.deformStatus.RAW", byte, 0x0E);
   enterSubByteField("DEFORM.isDeformProtected", byte, 0x01);
 }

References enterSubByteField(), and getByte().

Referenced by parseRecord().

◆ parseRecord_FIRMWARE()

void RecordAndDetailsParser::parseRecord_FIRMWARE	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_FIRMWARE.cpp.

                                                                                              {
   // unknown (2 bytes)
   ptr += 2;
 
   // FIRMWARE.version: 3 bytes:
   note3ByteVersionField("FIRMWARE.version", ptr, limit);
 
   // unknown (109 bytes)
 }

References note3ByteVersionField().

Referenced by parseRecord().

◆ parseRecord_GIMBAL()

void RecordAndDetailsParser::parseRecord_GIMBAL	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_GIMBAL.cpp.

                                                                                            {
   // GIMBAL.pitch: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("GIMBAL.pitch", ptr, limit, 10.0);
 
   // GIMBAL.roll: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("GIMBAL.roll", ptr, limit, 10.0);
 
   // GIMBAL.yaw: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("GIMBAL.yaw", ptr, limit, 10.0);
 
   // GIMBAL.mode.RAW(2 bits) + unknown(6 bits):
   u_int8_t byte = getByte(ptr, limit);
   enterSubByteField("GIMBAL.mode.RAW", byte, 0xC0);
 
   // GIMBAL.rollAdjust: 1 byte signed, multiple of 0.1:
   noteByteField("GIMBAL.rollAdjust", ptr, limit, 10.0, 1/*isSigned*/);
 
   // GIMBAL.yawAngle: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("GIMBAL.yawAngle", ptr, limit, 10.0);
 
   // 8 bits (Boolean flags); from high to low:
   //  unknown
   //  GIMBAL.isStuck
   //  unknown
   //  GIMBAL.autoCalibrationResult
   //  GIMBAL.isAutoCalibration
   //  GIMBAL.isYawInLimit
   //  GIMBAL.isRollInLimit
   //  GIMBAL.isPitchInLimit
   byte = getByte(ptr, limit);
   enterSubByteField("GIMBAL.isStuck", byte, 0x40);
   enterSubByteField("GIMBAL.autoCalibrationResult", byte, 0x10);
   enterSubByteField("GIMBAL.isAutoCalibration", byte, 0x08);
   enterSubByteField("GIMBAL.isYawInLimit", byte, 0x04);
   enterSubByteField("GIMBAL.isRollInLimit", byte, 0x02);
   enterSubByteField("GIMBAL.isPitchInLimit", byte, 0x01);
 
   // GIMBAL.isSingleClick (1 bit) + GIMBAL.isTripleClick (1 bit) + GIMBAL.isDoubleClick (1 bit) + unknown (1 bit) + GIMBAL.version (4 bits):
   byte = getByte(ptr, limit);
   enterSubByteField("GIMBAL.isSingleClick", byte, 0x80);
   enterSubByteField("GIMBAL.isTripleClick", byte, 0x40);
   enterSubByteField("GIMBAL.isDoubleClick", byte, 0x20);
   enterSubByteField("GIMBAL.version", byte, 0x0F);
 }

References enterSubByteField(), getByte(), noteByteField(), and noteSigned2ByteField().

Referenced by parseRecord().

◆ parseRecord_HOME()

void RecordAndDetailsParser::parseRecord_HOME	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_HOME.cpp.

                                                                                          {
   // HOME.longitude: 8 bytes little-endian double, in radians; convert to degrees:
   note8ByteLatitudeOrLongitudeFieldInRadians("HOME.longitude", ptr, limit);
 
   // HOME.latitude: 8 bytes little-endian double, in radians; convert to degrees:
   note8ByteLatitudeOrLongitudeFieldInRadians("HOME.latitude", ptr, limit);
 
   // HOME.height: 4 bytes little-endian float, multiple of 0.1 meters; convert to meters:
   note4ByteFloatField("HOME.height", ptr, limit, 10.0);
 
   // HOME.hasGoHome (1 bit) + HOME.goHomeStatus (3 bits) + HOME.isDynamicHomePointEnabled (1 bit) + HOME.aircraftHeadDirection (1 bit) + HOME.goHomeMode (1 bit) + HOME.isHomeRecord (1 bit):
   u_int8_t byte = getByte(ptr, limit);
   enterSubByteField("HOME.hasGoHome", byte, 0x80);
   enterSubByteField("HOME.goHomeStatus", byte, 0x70);
   enterSubByteField("HOME.isDynamicHomePointEnabled", byte, 0x08);
   enterSubByteField("HOME.aircraftHeadDirection", byte, 0x04);
   enterSubByteField("HOME.goHomeMode", byte, 0x02);
   enterSubByteField("HOME.isHomeRecord", byte, 0x01);
 
   // HOME.iocMode.RAW (3 bits) + HOME.isIOCEnabled (1 bit) + HOME.isBeginnerMode (1 bit) + HOME.isCompassCeleing (1 bit) + HOME.compassCeleStatus (2 bits):
   byte = getByte(ptr, limit);
   enterSubByteField("HOME.iocMode.RAW", byte, 0xE0);
   enterSubByteField("HOME.isIOCEnabled", byte, 0x10);
   enterSubByteField("HOME.isBeginnerMode", byte, 0x08);
   enterSubByteField("HOME.isCompassCeleing", byte, 0x04);
   enterSubByteField("HOME.compassCeleStatus", byte, 0x03);
 
   // HOME.goHomeHeight: 2 bytes little-endian unsigned, meters:
   noteUnsigned2ByteField("HOME.goHomeHeight", ptr, limit);
 
   // HOME.courseLockAngle: 2 bytes little-endian signed, multiple of 0.1 degrees, convert to degrees:
   noteSigned2ByteField("HOME.courseLockAngle", ptr, limit, 10.0);
 
   // HOME.dataRecorderStatus: 1 byte unsigned:
   noteByteField("HOME.dataRecorderStatus", ptr, limit);
 
   // HOME.dataRecorderRemainCapacity: 1 byte unsigned:
   noteByteField("HOME.dataRecorderRemainCapacity", ptr, limit);
 
   // HOME.dataRecorderRemainTime: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("HOME.dataRecorderRemainTime", ptr, limit);
 
   // HOME.dataRecorderFileIndex: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("HOME.dataRecorderFileIndex", ptr, limit);
 
   // unknown (5 bytes)
   ptr += 5;
 
   // HOME.maxAllowedHeight: 4 bytes little-endian float:
   note4ByteFloatField("HOME.maxAllowedHeight", ptr, limit);
 }

References enterSubByteField(), getByte(), note4ByteFloatField(), note8ByteLatitudeOrLongitudeFieldInRadians(), noteByteField(), noteSigned2ByteField(), and noteUnsigned2ByteField().

Referenced by parseRecord().

◆ parseRecord_JPEG()

int RecordAndDetailsParser::parseRecord_JPEG	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 56 of file parseRecord_JPEG.cpp.

                                                                                         {
   // Skip the first two bytes (both zero) in the record:
   (void)get2BytesBE(ptr, limit);
 
   if (ptr == limit) return 1; // We're done; there are no JPEG images in the record
 
   // The next two bytes should be the JPEG 'start of image' code:
   if (get2BytesBE(ptr, limit) != JPEG_SOI) {
     // Unknown contents. Skip all bytes up to and including the next 0xFF (or until "limit"):
     while (ptr < limit && *ptr++ != 0xFF) {}
     return 1;
   }
   
   // The JPEG data is all following data, up to (and including) the next JPEG 'end of image' code,
   // that's not then immediately followed by a JPEG 'start of image' code:
   FILE* outputFid = NULL;
   if (outputJPGFiles) {
     outputFid = openOutputJPGFile();
     if (outputFid == NULL) return 0;
   }
     
   while (1) {
     u_int16_t next2Bytes = get2BytesBE(ptr, limit);
     if (next2Bytes == JPEG_EOI) {
       if (outputJPGFiles) {
         // We've finished writing the JPG file:
         fputc(JPEG_EOI>>8, outputFid); fputc(JPEG_EOI, outputFid);
         fclose(outputFid);
       }
 
       // Look for an immediately following JPEG 'start of image' code (if there's more data left):
       if (ptr == limit) return 1; // we're done
       next2Bytes = get2BytesBE(ptr, limit);
       if (next2Bytes == JPEG_SOI) {
         if (outputJPGFiles) {
           outputFid = openOutputJPGFile();
           if (outputFid == NULL) return 0;
         }
       } else {
         ptr -= 2;
         return 1;
       }
     } else {
       // Output the first byte, then continue:
       if (outputJPGFiles) {
         u_int8_t firstByte = next2Bytes >> 8;
         fputc(firstByte, outputFid);
       }
       --ptr;
     }
   }
 
   return 0; // never reached
 }

References get2BytesBE(), JPEG_EOI, JPEG_SOI, openOutputJPGFile(), and outputJPGFiles.

Referenced by parseRecord().

◆ parseRecord_OSD()

void RecordAndDetailsParser::parseRecord_OSD	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_OSD.cpp.

                                                                                         {
   // OSD.longitude: 8 bytes little-endian double, in radians; convert to degrees:
   note8ByteLatitudeOrLongitudeFieldInRadians("OSD.longitude", ptr, limit);
 
   // OSD.latitude: 8 bytes little-endian double, in radians; convert to degrees:
   note8ByteLatitudeOrLongitudeFieldInRadians("OSD.latitude", ptr, limit);
 
   // OSD.height: 2 bytes signed(?) little-endian, multiple of 0.1 meters; convert to meters:
   noteSigned2ByteField("OSD.height", ptr, limit, 10.0);
   
   // OSD.xSpeed: 2 bytes signed little-endian, multiple of 0.1 m/s; convert to m/s:
   noteSigned2ByteField("OSD.xSpeed", ptr, limit, 10.0);
 
   // OSD.ySpeed: 2 bytes signed little-endian, multiple of 0.1 m/s; convert to m/s:
   noteSigned2ByteField("OSD.ySpeed", ptr, limit, 10.0);
 
   // OSD.zSpeed: 2 bytes signed little-endian, multiple of 0.1 m/s; convert to m/s:
   noteSigned2ByteField("OSD.zSpeed", ptr, limit, 10.0);
 
   // OSD.pitch: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("OSD.pitch", ptr, limit, 10.0);
 
   // OSD.roll: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("OSD.roll", ptr, limit, 10.0);
 
   // OSD.yaw: 2 bytes signed little-endian, multiple of 0.1 degrees; convert to degrees:
   noteSigned2ByteField("OSD.yaw", ptr, limit, 10.0);
 
   // OSD.rcState(1 bit) + OSD.flycState.RAW (7 bits):
   u_int8_t byte = getByte(ptr, limit);
   enterSubByteField("OSD.rcState", byte, 0x80);
   enterSubByteField("OSD.flycState.RAW", byte, 0x7F);
 
   // OSD.flycCommand.RAW: 1 byte unsigned:
   noteByteField("OSD.flycCommand.RAW", ptr, limit);
 
   // OSD.goHomeStatus.RAW(3 bits) + OSD.isSwaveWork(1 bit) + OSD.isMotorUp(1 bit) + OSD.groundOrSky.RAW(2 bits) + OSD.canIOCWork(1 bit)
   byte = getByte(ptr, limit);
   enterSubByteField("OSD.goHomeStatus.RAW", byte, 0xE0);
   enterSubByteField("OSD.isSwaveWork", byte, 0x10);
   enterSubByteField("OSD.isMotorUp", byte, 0x08);
   enterSubByteField("OSD.groundOrSky.RAW", byte, 0x06); // only the high bit is used?
   enterSubByteField("OSD.canIOCWork", byte, 0x01);
 
   // unknown(1 bit) + OSD.modeChannel(2 bits) + OSD.isImuPreheated(1 bit) + unknown(1 bit) + OSD.voltageWarning(2 bits) + OSD.isVisionUsed(1 bit)
   byte = getByte(ptr, limit);
   enterSubByteField("OSD.modeChannel", byte, 0x60);
   enterSubByteField("OSD.isImuPreheated", byte, 0x10);
   enterSubByteField("OSD.voltageWarning", byte, 0x06);
   enterSubByteField("OSD.isVisionUsed", byte, 0x01);
 
   // OSD.batteryType.RAW(2 bits) + OSD.gpsLevel(4 bits) + OSD.waveError(1 bit) + OSD.compassError(1 bit)
   byte = getByte(ptr, limit);
   enterSubByteField("OSD.batteryType.RAW", byte, 0xC0);
   enterSubByteField("OSD.gpsLevel", byte, 0x3C);
   enterSubByteField("OSD.waveError", byte, 0x02);
   enterSubByteField("OSD.compassError", byte, 0x01);
 
   // 8 bits (Boolean flags); from high to low:
   //  OSD.isAcceletorOverRange (sic)
   //  OSD.isVibrating
   //  OSD.isBarometerDeadInAir
   //  OSD.isMotorBlocked
   //  OSD.isNotEnoughForce
   //  OSD.isPropellerCatapult
   //  OSD.isGoHomeHeightModified
   //  OSD.isOutOfLimit
   byte = getByte(ptr, limit);
   enterSubByteField("OSD.isAcceletorOverRange", byte, 0x80);
   enterSubByteField("OSD.isVibrating", byte, 0x40);
   enterSubByteField("OSD.isBarometerDeadInAir", byte, 0x20);
   enterSubByteField("OSD.isNotEnoughForce", byte, 0x10);
   enterSubByteField("OSD.isMotorBlocked", byte, 0x08);
   enterSubByteField("OSD.isPropellerCatapult", byte, 0x04);
   enterSubByteField("OSD.isGoHomeHeightModified", byte, 0x02);
   enterSubByteField("OSD.isOutOfLimit", byte, 0x01);
 
   // OSD.gpsNum: 1 byte unsigned:
   noteByteField("OSD.gpsNum", ptr, limit);
 
   // OSD.flightAction.RAW: 1 byte unsigned:
   noteByteField("OSD.flightAction.RAW", ptr, limit);
 
   // OSD.motorStartFailedCause.RAW: 1 byte unsigned:
   noteByteField("OSD.motorStartFailedCause.RAW", ptr, limit);
 
   // unknown (3 bits) + OSD.waypointLimitMode (1 bit) + OSD.nonGPSCause.RAW (4 bits):
   byte = getByte(ptr, limit);
   enterSubByteField("OSD.waypointLimitMode", byte, 0x10);
   enterSubByteField("OSD.nonGPSCause.RAW", byte, 0x0F);
 
   // OSD.battery: 1 byte unsigned:
   noteByteField("OSD.battery", ptr, limit);
 
   // OSD.sWaveHeight: 1 byte unsigned, multiple of 0.1 meters; convert to meters:
   noteByteField("OSD.sWaveHeight", ptr, limit, 10.0);
 
   // OSD.flyTime: 2 bytes unsigned little-endian, multiple of 0.1 seconds; convert to seconds:
   noteUnsigned2ByteField("OSD.flyTime", ptr, limit, 10.0);
 
   // OSD.motorRevolution: 1 byte unsigned:
   noteByteField("OSD.motorRevolution", ptr, limit);
 
   // unknown (2 bytes):
   ptr += 2;
 
   // OSD.flycVersion: 1 byte unsigned:
   noteByteField("OSD.flycVersion", ptr, limit);
 
   // OSD.droneType.RAW: 1 byte unsigned:
   noteByteField("OSD.droneType.RAW", ptr, limit);
 
   // OSD.imuInitFailReason.RAW: 1 byte unsigned:
   noteByteField("OSD.imuInitFailReason.RAW", ptr, limit);
 
   // The following fields are not present in some versions of .txt files:
   if (limit - ptr > 3) {
     // OSD.motorFailReason.RAW: 1 byte unsigned:
     noteByteField("OSD.motorFailReason.RAW", ptr, limit);
 
     // unknown (1 byte):
     ++ptr;
 
     // OSD.ctrlDevice.RAW: 1 byte unsigned:
     noteByteField("OSD.ctrlDevice.RAW", ptr, limit);
 
     // unknown (1 byte):
     ++ptr;
   }
 }

References enterSubByteField(), getByte(), note8ByteLatitudeOrLongitudeFieldInRadians(), noteByteField(), noteSigned2ByteField(), and noteUnsigned2ByteField().

Referenced by parseRecord().

◆ parseRecord_RC()

void RecordAndDetailsParser::parseRecord_RC	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_RC.cpp.

                                                                                        {
   // RC.aileron: 2 bytes little-endian, signed: subtract 1024, and divide by 0.066(?):
   noteSigned2ByteField("RC.aileron", ptr, limit, 0.066, 1024);
 
   // RC.elevator: 2 bytes little-endian, signed: subtract 1024, and divide by 0.066(?):
   noteSigned2ByteField("RC.elevator", ptr, limit, 0.066, 1024);
 
   // RC.throttle: 2 bytes little-endian, signed: subtract 1024, and divide by 0.066(?):
   noteSigned2ByteField("RC.throttle", ptr, limit, 0.066, 1024);
 
   // RC.rudder: 2 bytes little-endian, signed: subtract 1024, and divide by 0.066(?):
   noteSigned2ByteField("RC.rudder", ptr, limit, 0.066, 1024);
 
   // RC.gimbal: 2 bytes little-endian, signed: subtract 1024, and divide by 0.066(?):
   noteSigned2ByteField("RC.gimbal", ptr, limit, 0.066, 1024);
 
   // unknown(2 bits) + RC.wheelOffset(5 bits) + unknown(1 bit):
   u_int8_t byte = getByte(ptr, limit);
   enterSubByteField("RC.wheelOffset", byte, 0x3E);
 
   // unknown(2 bits) + RC.mode(2 bits) + RC.goHome(1 bit) + unknown(3 bits):
   byte = getByte(ptr, limit);
   enterSubByteField("RC.mode", byte, 0x30);
   enterSubByteField("RC.goHome", byte, 0x08);
 
   // 8 bits (Boolean flags); from high to low:
   //  RC.record
   //  RC.shutter
   //  RC.playback
   //  RC.custom1
   //  RC.custom2
   //  unknown(3 bits)
   byte = getByte(ptr, limit);
   enterSubByteField("RC.record", byte, 0x80);
   enterSubByteField("RC.shutter", byte, 0x40);
   enterSubByteField("RC.playback", byte, 0x20);
   enterSubByteField("RC.custom1", byte, 0x10);
   enterSubByteField("RC.custom2", byte, 0x08);
 }

References enterSubByteField(), getByte(), and noteSigned2ByteField().

Referenced by parseRecord().

◆ parseRecord_RECOVER()

void RecordAndDetailsParser::parseRecord_RECOVER	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_RECOVER.cpp.

                                                                                             {
   // Note: Some of the field lengths here may have been different in older ".txt" versions
 
   if (limit-ptr < 109) return; // This record is smaller than we expect; we can't handle it
 
   // RECOVER.droneType.RAW: 1 byte unsigned:
   noteByteField("RECOVER.droneType.RAW", ptr, limit);
 
   // RECOVER.appType.RAW: 1 byte unsigned:
   noteByteField("RECOVER.appType.RAW", ptr, limit);
 
   // RECOVER.appVersion: 3 bytes;
   note3ByteVersionField("RECOVER.appVersion", ptr, limit);
 
   // RECOVER.aircraftSn: string (length 16):
   noteStringField("RECOVER.aircraftSn", ptr, 16, limit);
 
   // RECOVER.aircraftName: string (length 32):
   noteStringField("RECOVER.aircraftName", ptr, 32, limit);
 
   // RECOVER.activeTimestamp: 8 bytes little-endian, in Unix time format:
   note8ByteTimestampField("RECOVER.activeTimestamp", ptr, limit);
 
   // RECOVER.cameraSn: string (length 16):
   noteStringField("RECOVER.cameraSn", ptr, 16, limit);
 
   // RECOVER.rcSn: string (length 16):
   noteStringField("RECOVER.rcSn", ptr, 16, limit);
 
   // RECOVER.batterySn: string (length 16):
   noteStringField("RECOVER.batterySn", ptr, 16, limit);
 }

References note3ByteVersionField(), note8ByteTimestampField(), noteByteField(), and noteStringField().

Referenced by parseRecord().

◆ parseRecord_SMART_BATTERY()

void RecordAndDetailsParser::parseRecord_SMART_BATTERY	(	u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 28 of file parseRecord_SMART_BATTERY.cpp.

                                                                                                   {
   // SMART_BATTERY.usefulTime: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("SMART_BATTERY.usefulTime", ptr, limit);
 
   // SMART_BATTERY.goHomeTime: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("SMART_BATTERY.goHomeTime", ptr, limit);
 
   // SMART_BATTERY.landTime: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("SMART_BATTERY.landTime", ptr, limit);
 
   // SMART_BATTERY.goHomeBattery: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("SMART_BATTERY.goHomeBattery", ptr, limit);
 
   // SMART_BATTERY.landBattery: 2 bytes little-endian unsigned:
   noteUnsigned2ByteField("SMART_BATTERY.landBattery", ptr, limit);
 
   // SMART_BATTERY.safeFlyRadius: 4 bytes little-endian unsigned:
   note4ByteField("SMART_BATTERY.safeFlyRadius", ptr, limit);
 
   // SMART_BATTERY.volumeConsume: 4 bytes little-endian float:
   note4ByteFloatField("SMART_BATTERY.volumeConsume", ptr, limit);
 
   // SMART_BATTERY.status.RAW: 4 bytes little-endian unsigned:
   note4ByteField("SMART_BATTERY.status.RAW", ptr, limit);
 
   // SMART_BATTERY.goHomeStatus.RAW: 1 byte unsigned:
   noteByteField("SMART_BATTERY.goHomeStatus.RAW", ptr, limit);
 
   // SMART_BATTERY.goHomeCountdown: 1 byte unsigned:
   noteByteField("SMART_BATTERY.goHomeCountdown", ptr, limit);
 
   // SMART_BATTERY.voltage: 2 bytes little-endian unsigned; multiple of 0.001 volts; convert to volts:
   noteUnsigned2ByteField("SMART_BATTERY.voltage", ptr, limit, 1000.0);
 
   // SMART_BATTERY.battery: 1 byte unsigned:
   noteByteField("SMART_BATTERY.battery", ptr, limit);
 
   // SMART_BATTERY.lowWarningGoHome (1 bit) + SMART_BATTERY.lowWarning (7 bits):
   u_int8_t byte = getByte(ptr, limit);
   enterSubByteField("SMART_BATTERY.lowWarningGoHome", byte, 0x80);
   enterSubByteField("SMART_BATTERY.lowWarning", byte, 0x7F);
 
   // SMART_BATTERY.seriousLowWarningLanding (1 bit) + SMART_BATTERY.seriousLowWarning (7 bits):
   byte = getByte(ptr, limit);
   enterSubByteField("SMART_BATTERY.seriousLowWarningLanding", byte, 0x80);
   enterSubByteField("SMART_BATTERY.seriousLowWarning", byte, 0x7F);
 
   // SMART_BATTERY.voltagePercent: 1 byte unsigned:
   noteByteField("SMART_BATTERY.voltagePercent", ptr, limit);
 }

References enterSubByteField(), getByte(), note4ByteField(), note4ByteFloatField(), noteByteField(), and noteUnsigned2ByteField().

Referenced by parseRecord().

◆ parseRecordUnknownFormat()

void RecordAndDetailsParser::parseRecordUnknownFormat	(	char const *	recordTypeName,
		u_int8_t const *&	ptr,
		u_int8_t const *	limit
	)

private

Definition at line 32 of file parseRecordUnknownFormat.cpp.

                                                                                         {
   fprintf(stderr, "%s (unknown format), %ld bytes: ", recordTypeName, (long)(limit-ptr));
   printHex(NULL, ptr, limit);
 }

References printHex().

Referenced by parseRecord().

◆ summarizeRecordParsing()

void RecordAndDetailsParser::summarizeRecordParsing ( )

privatevirtual

Implements DJITxtParser.

Definition at line 249 of file parseRecord.cpp.

                                                     {
 #ifdef DEBUG_RECORD_PARSING
   fprintf(stderr, "%d records parsed; max num records for one type: %d\n", fNumRecords, fMaxNumRecordsForOneType);
   unsigned maxRecordTypeFieldLen = 0;
   for (unsigned i = 0; i < 256; ++i) {
     char const* recordTypeName = fRecordTypeName[i];
     unsigned recordTypeNameLen = recordTypeName == NULL ? 3 : strlen(recordTypeName);
     unsigned iLog10 = i<10 ? 0 : i<100 ? 1 : 2;
     unsigned recordTypeFieldLen = iLog10 + 2 + recordTypeNameLen + 2;
     if (recordTypeFieldLen > maxRecordTypeFieldLen) maxRecordTypeFieldLen = recordTypeFieldLen;
   }
   unsigned maxNumTabs = maxRecordTypeFieldLen/8 + 1;
 
   for (unsigned i = 0; i < 255; ++i) {
     if (fRecordTypeStats[i].count > 0) {
       char const* recordTypeName = fRecordTypeName[i];
       if (recordTypeName == NULL) recordTypeName = "???";
       unsigned iLog10 = i<10 ? 0 : i<100 ? 1 : 2;
       unsigned recordTypeFieldLen = iLog10 + 2 + strlen(recordTypeName) + 2;
       unsigned numTabs = maxNumTabs - recordTypeFieldLen/8; // >0
 
       fprintf(stderr, "%d[%s]:", i, recordTypeName);
       for (unsigned j = 0; j < numTabs; ++j) fprintf(stderr, "\t");
       fprintf(stderr, "%d\t", fRecordTypeStats[i].count);
       if (fRecordTypeStats[i].minLength == fRecordTypeStats[i].maxLength) {
         fprintf(stderr, "length:\t\t%d\n", fRecordTypeStats[i].minLength);
       } else {
         fprintf(stderr, "lengths:\t%d-%d\n", fRecordTypeStats[i].minLength, fRecordTypeStats[i].maxLength);
       }
     }
   }
 #endif
 }

References fMaxNumRecordsForOneType, fNumRecords, fRecordTypeName, and fRecordTypeStats.

Field Documentation

◆ fFieldDatabase

FieldDatabase* RecordAndDetailsParser::fFieldDatabase

private

Definition at line 116 of file RecordAndDetailsParser.hh.

Referenced by ~RecordAndDetailsParser().

◆ fMaxNumRecordsForOneType

unsigned RecordAndDetailsParser::fMaxNumRecordsForOneType

private

Definition at line 114 of file RecordAndDetailsParser.hh.

Referenced by parseRecord(), and summarizeRecordParsing().

◆ fNumRecords

unsigned RecordAndDetailsParser::fNumRecords

private

Definition at line 111 of file RecordAndDetailsParser.hh.

Referenced by parseRecord(), and summarizeRecordParsing().

◆ fRecordTypeName

char const* RecordAndDetailsParser::fRecordTypeName[256]

private

Definition at line 113 of file RecordAndDetailsParser.hh.

Referenced by parseRecord(), RecordAndDetailsParser(), and summarizeRecordParsing().

◆ fRecordTypeStats

RecordTypeStat RecordAndDetailsParser::fRecordTypeStats[256]

private

Definition at line 112 of file RecordAndDetailsParser.hh.

Referenced by parseRecord(), and summarizeRecordParsing().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RecordAndDetailsParser()

◆ ~RecordAndDetailsParser()

Member Function Documentation

◆ createNew()

◆ enterSubByteField()

◆ note2ByteDateField()

◆ note2ByteField()

◆ note3ByteVersionField()

◆ note4ByteField()

◆ note4ByteFloatField()

◆ note8ByteDoubleField()

◆ note8ByteLatitudeOrLongitudeFieldInDegrees()

◆ note8ByteLatitudeOrLongitudeFieldInRadians()

◆ note8ByteTimestampField()

◆ noteByteField()

◆ noteSigned2ByteField()

◆ noteStringField()

◆ noteUnsigned2ByteField()

◆ outputOneRow()

◆ parseDetailsArea()

◆ parseJPEGRecord()

◆ parseRecord()

◆ parseRecord_APP_GPS()

◆ parseRecord_APP_SER_WARN()

◆ parseRecord_APP_TIP()

◆ parseRecord_APP_WARN()

◆ parseRecord_CENTER_BATTERY()

◆ parseRecord_COMPONENT()

◆ parseRecord_CUSTOM()

◆ parseRecord_DEFORM()

◆ parseRecord_FIRMWARE()

◆ parseRecord_GIMBAL()

◆ parseRecord_HOME()

◆ parseRecord_JPEG()

◆ parseRecord_OSD()

◆ parseRecord_RC()

◆ parseRecord_RECOVER()

◆ parseRecord_SMART_BATTERY()

◆ parseRecordUnknownFormat()

◆ summarizeRecordParsing()

Field Documentation

◆ fFieldDatabase

◆ fMaxNumRecordsForOneType

◆ fNumRecords

◆ fRecordTypeName

◆ fRecordTypeStats