static void
Run(IGCWriter &writer)
{
static const GeoPoint home(Angle::Degrees(fixed(7.7061111111111114)),
Angle::Degrees(fixed(51.051944444444445)));
static const GeoPoint tp(Angle::Degrees(fixed(10.726111111111111)),
Angle::Degrees(fixed(50.6322)));
static NMEAInfo i;
i.clock = fixed_one;
i.time = fixed(1);
i.time_available.Update(i.clock);
i.date_time_utc.year = 2010;
i.date_time_utc.month = 9;
i.date_time_utc.day = 4;
i.date_time_utc.hour = 11;
i.date_time_utc.minute = 22;
i.date_time_utc.second = 33;
i.location = home;
i.location_available.Update(i.clock);
i.gps_altitude = fixed(487);
i.gps_altitude_available.Update(i.clock);
i.ProvidePressureAltitude(fixed(490));
i.ProvideBaroAltitudeTrue(fixed(400));
writer.WriteHeader(i.date_time_utc, _T("Pilot Name"), _T("ASK-21"),
_T("D-1234"), _T("34"), "FOO", _T("bar"), false);
writer.StartDeclaration(i.date_time_utc, 3);
writer.AddDeclaration(home, _T("Bergneustadt"));
writer.AddDeclaration(tp, _T("Suhl"));
writer.AddDeclaration(home, _T("Bergneustadt"));
writer.EndDeclaration();
writer.LogEmptyFRecord(i.date_time_utc);
i.date_time_utc.second += 5;
writer.LogPoint(i);
i.date_time_utc.second += 5;
writer.LogEvent(i, "my_event");
i.date_time_utc.second += 5;
writer.LoggerNote(_T("my_note"));
int satellites[GPSState::MAXSATELLITES];
for (unsigned i = 0; i < GPSState::MAXSATELLITES; ++i)
satellites[i] = 0;
satellites[2] = 12;
satellites[4] = 17;
satellites[7] = 1;
i.date_time_utc.second += 5;
writer.LogFRecord(i.date_time_utc, satellites);
i.location = GeoPoint(Angle::Degrees(fixed(-7.7061111111111114)),
Angle::Degrees(fixed(-51.051944444444445)));
writer.LogPoint(i);
writer.Flush();
writer.Sign();
}
bool
EWMicroRecorderDevice::ParseNMEA(const char *String, NMEAInfo &info)
{
if (!VerifyNMEAChecksum(String))
return false;
NMEAInputLine line(String);
char type[16];
line.Read(type, 16);
if (StringIsEqual(type, "$PGRMZ")) {
fixed value;
/* The normal Garmin $PGRMZ line contains the "true" barometric
altitude above MSL (corrected with QNH), but EWMicroRecorder
differs here slightly: it emits the uncorrected barometric
altitude. That is the only reason why we catch this sentence
in the driver instead of letting the generic class NMEAParser
do it. */
if (ReadAltitude(line, value))
info.ProvidePressureAltitude(value);
return true;
} else
return false;
}
// RMN: Volkslogger
// Source data:
// $PGCS,1,0EC0,FFF9,0C6E,02*61
// $PGCS,1,0EC0,FFFA,0C6E,03*18
static bool
vl_PGCS1(NMEAInputLine &line, NMEAInfo &info)
{
if (line.Read(1) != 1)
return false;
/* pressure sensor */
line.Skip();
// four characers, hex, barometric altitude
unsigned u_altitude;
if (line.ReadHexChecked(u_altitude)) {
int altitude(u_altitude);
if (altitude > 60000)
/* Assuming that altitude has wrapped around. 60 000 m occurs
at QNH ~2000 hPa */
altitude -= 65535;
info.ProvidePressureAltitude(fixed(altitude));
}
// ExtractParameter(String,ctemp,3);
// four characters, hex, constant. Value 1371 (dec)
// nSatellites = (int)(min(12,HexStrToDouble(ctemp, NULL)));
return false;
}
static bool
ParseAPENV1(NMEAInputLine &line, NMEAInfo &info)
{
// $APENV1,IAS,Altitude,0,0,0,VerticalSpeed,
int ias;
if (!line.ReadChecked(ias)) return false;
int altitude;
if (!line.ReadChecked(altitude)) return false;
line.Skip();
line.Skip();
line.Skip();
// In ft/min, quality of this is limited, do not use for the time being
int vs;
if (!line.ReadChecked(vs)) return false;
auto sys_alt = Units::ToSysUnit(fixed(altitude), Unit::FEET);
info.ProvidePressureAltitude(sys_alt);
info.ProvideIndicatedAirspeedWithAltitude(Units::ToSysUnit(fixed(ias), Unit::KNOTS), sys_alt);
return true;
}
static bool
GPWIN(NMEAInputLine &line, NMEAInfo &info)
{
line.skip(2);
fixed value;
if (line.read_checked(value))
info.ProvidePressureAltitude(value / 10);
return false;
}
/**
* $PWES0,DD,VVVV,MMMM,NNNN,BBBB,SSSS,AAAAA,QQQQQ,IIII,TTTT,UUU,CCCC*CS<CR><LF>
*/
static bool
PWES0(NMEAInputLine &line, NMEAInfo &info)
{
int i;
line.Skip(); /* device */
if (line.ReadChecked(i) && i >= -999 && i <= 999)
info.ProvideTotalEnergyVario(fixed(i) / 10);
line.Skip(); /* average vario */
if (line.ReadChecked(i) && i >= -999 && i <= 999)
info.ProvideNettoVario(fixed(i) / 10);
line.Skip(); /* average netto vario */
line.Skip(); /* speed to fly */
unsigned altitude;
if (line.ReadChecked(altitude) && altitude <= 99999)
info.ProvidePressureAltitude(fixed(altitude));
if (line.ReadChecked(altitude) && altitude <= 99999)
info.ProvideBaroAltitudeTrue(fixed(altitude));
unsigned ias, tas;
bool have_ias = line.ReadChecked(ias) && ias <= 9999;
bool have_tas = line.ReadChecked(tas) && tas <= 9999;
if (have_ias && have_tas)
info.ProvideBothAirspeeds(Units::ToSysUnit(fixed(ias) / 10,
Unit::KILOMETER_PER_HOUR),
Units::ToSysUnit(fixed(tas) / 10,
Unit::KILOMETER_PER_HOUR));
else if (!have_ias && have_tas)
info.ProvideTrueAirspeed(Units::ToSysUnit(fixed(tas) / 10,
Unit::KILOMETER_PER_HOUR));
unsigned voltage;
if (line.ReadChecked(voltage) && voltage <= 999) {
info.voltage = fixed(voltage) / 10;
info.voltage_available.Update(info.clock);
}
if (line.ReadChecked(i) && i >= -999 && i <= 999) {
info.temperature = CelsiusToKelvin(fixed(i) / 10);
info.temperature_available = true;
}
return true;
}
/**
* $PWES0,DD,VVVV,MMMM,NNNN,BBBB,SSSS,AAAAA,QQQQQ,IIII,TTTT,UUU,CCCC*CS<CR><LF>
*/
static bool
PWES0(NMEAInputLine &line, NMEAInfo &info)
{
int i, k;
line.skip(); /* device */
if (line.read_checked(i))
info.ProvideTotalEnergyVario(fixed(i) / 10);
line.skip(); /* average vario */
if (line.read_checked(i))
info.ProvideNettoVario(fixed(i) / 10);
line.skip(); /* average netto vario */
line.skip(); /* speed to fly */
if (line.read_checked(i))
info.ProvidePressureAltitude(fixed(i));
if (line.read_checked(i))
info.ProvideBaroAltitudeTrue(fixed(i));
bool have_ias = line.read_checked(i);
bool have_tas = line.read_checked(k);
if (have_ias && have_tas)
info.ProvideBothAirspeeds(Units::ToSysUnit(fixed(i) / 10,
Unit::KILOMETER_PER_HOUR),
Units::ToSysUnit(fixed(k) / 10,
Unit::KILOMETER_PER_HOUR));
else if (!have_ias && have_tas)
info.ProvideTrueAirspeed(Units::ToSysUnit(fixed(k) / 10,
Unit::KILOMETER_PER_HOUR));
if (line.read_checked(i)) {
info.voltage = fixed(i) / 10;
info.voltage_available.Update(info.clock);
}
if (line.read_checked(i)) {
info.temperature = CelsiusToKelvin(fixed(i) / 10);
info.temperature_available = true;
}
return true;
}
static bool
LXWP0(NMEAInputLine &line, NMEAInfo &info)
{
/*
$LXWP0,Y,222.3,1665.5,1.71,,,,,,239,174,10.1
0 loger_stored (Y/N)
1 IAS (kph) ----> Condor uses TAS!
2 baroaltitude (m)
3-8 vario (m/s) (last 6 measurements in last second)
9 heading of plane
10 windcourse (deg)
11 windspeed (kph)
*/
line.Skip();
fixed airspeed;
bool tas_available = line.ReadChecked(airspeed);
if (tas_available && (airspeed < fixed(-50) || airspeed > fixed(250)))
/* implausible */
return false;
fixed value;
if (line.ReadChecked(value))
/* a dump on a LX7007 has confirmed that the LX sends uncorrected
altitude above 1013.25hPa here */
info.ProvidePressureAltitude(value);
if (tas_available)
/*
* Call ProvideTrueAirspeed() after ProvidePressureAltitude() to use
* the provided altitude (if available)
*/
info.ProvideTrueAirspeed(Units::ToSysUnit(airspeed, Unit::KILOMETER_PER_HOUR));
if (line.ReadChecked(value))
info.ProvideTotalEnergyVario(value);
line.Skip(6);
SpeedVector wind;
if (ReadSpeedVector(line, wind))
info.ProvideExternalWind(wind);
return true;
}
/*
$PCAID,<1>,<2>,<3>,<4>*hh<CR><LF>
<1> Logged 'L' Last point Logged 'N' Last Point not logged
<2> Barometer Altitude in meters (Leading zeros will be transmitted)
<3> Engine Noise Level
<4> Log Flags
*hh Checksum, XOR of all bytes of the sentence after the $ and before the *
*/
static bool
cai_PCAID(NMEAInputLine &line, NMEAInfo &data)
{
line.skip();
fixed value;
if (line.read_checked(value))
data.ProvidePressureAltitude(value);
unsigned enl;
if (line.read_checked(enl)) {
data.engine_noise_level = enl;
data.engine_noise_level_available.Update(data.clock);
}
return true;
}
bool
NMEAParser::PTAS1(NMEAInputLine &line, NMEAInfo &info)
{
/*
* $PTAS1,xxx,yyy,zzzzz,aaa*CS<CR><LF>
*
* xxx
* CV or current vario. =vario*10+200 range 0-400(display +/-20.0 knots)
*
* yyy
* AV or average vario. =vario*10+200 range 0-400(display +/-20.0 knots)
*
* zzzzz
* Barometric altitude in feet +2000
*
* aaa
* TAS knots 0-200
*/
// Parse current vario data
fixed vario;
if (line.ReadChecked(vario)) {
// Properly convert to m/s
vario = Units::ToSysUnit((vario - fixed(200)) / 10, Unit::KNOTS);
info.ProvideTotalEnergyVario(vario);
}
// Skip average vario data
line.Skip();
// Parse barometric altitude
fixed baro_altitude;
if (line.ReadChecked(baro_altitude)) {
// Properly convert to meter
baro_altitude = Units::ToSysUnit(baro_altitude - fixed(2000), Unit::FEET);
info.ProvidePressureAltitude(baro_altitude);
}
// Parse true airspeed
fixed vtas;
if (line.ReadChecked(vtas))
info.ProvideTrueAirspeed(Units::ToSysUnit(vtas, Unit::KNOTS));
return true;
}
/**
* $PWES0,DD,VVVV,MMMM,NNNN,BBBB,SSSS,AAAAA,QQQQQ,IIII,TTTT,UUU,CCC*CS<CR><LF>
*/
static bool
PWES0(NMEAInputLine &line, NMEAInfo &info)
{
int i, k;
line.skip(); /* device */
if (line.read_checked(i))
info.ProvideTotalEnergyVario(fixed(i) / 10);
line.skip(); /* average vario */
if (line.read_checked(i))
info.ProvideNettoVario(fixed(i) / 10);
line.skip(); /* average netto vario */
line.skip(); /* speed to fly */
if (line.read_checked(i))
info.ProvidePressureAltitude(fixed(i));
if (line.read_checked(i))
info.ProvideBaroAltitudeTrue(fixed(i));
bool have_ias = line.read_checked(i);
bool have_tas = line.read_checked(k);
if (have_ias && have_tas)
info.ProvideBothAirspeeds(Units::ToSysUnit(fixed(i) / 10,
unKiloMeterPerHour),
Units::ToSysUnit(fixed(k) / 10,
unKiloMeterPerHour));
if (line.read_checked(i)) {
info.voltage = fixed(i) / 10;
info.voltage_available.Update(info.clock);
}
if (line.read_checked(i)) {
info.temperature = Units::ToSysUnit(fixed(i) / 10, unGradCelcius);
info.temperature_available = true;
}
return true;
}
/**
* Parse a "$PDGFTL1" sentence.
*
* Example: "$PDGFTL1,2025,2000,250,-14,45,134,28,65,382,153*3D"
*/
static bool
PDGFTL1(NMEAInputLine &line, NMEAInfo &info)
{
double value;
// Baro Altitude QNE(1013.25) 2025 meter 2025 mt
if (line.ReadChecked(value))
info.ProvidePressureAltitude(value);
// Baro Altitude QNH 2000 meter 2000 mt
if (line.ReadChecked(value))
info.ProvideBaroAltitudeTrue(value);
// Vario 250 cm/sec +2,50 m/s
if (line.ReadChecked(value))
info.ProvideTotalEnergyVario(value / 100);
// Netto Vario -14 dm/sec -1,40 m/s
if (line.ReadChecked(value))
info.ProvideNettoVario(value / 10);
// Indicated Air Speed 45 km/h 45 km/h
if (line.ReadChecked(value))
info.ProvideIndicatedAirspeed(Units::ToSysUnit(value, Unit::KILOMETER_PER_HOUR));
// Ground Efficiency 134 ratio 13,4 : 1
line.Skip();
// Wind Speed 28 km/h 28 km/h
// Wind Direction 65 degree 65 degree
SpeedVector wind;
if (ReadSpeedVector(line, wind))
info.ProvideExternalWind(wind);
// Main Lithium Battery Voltage 382 0.01 volts 3,82 volts
if (line.ReadChecked(value)) {
info.voltage = value / 100;
info.voltage_available.Update(info.clock);
}
// Backup AA Battery Voltage 153 0.01 volts 1,53 volts
return true;
}
bool
AltairProDevice::ParseNMEA(const char *String, NMEAInfo &info)
{
NMEAInputLine line(String);
char type[16];
line.read(type, 16);
// no propriatary sentence
if (strcmp(type, "$PGRMZ") == 0) {
fixed value;
if (ReadAltitude(line, value))
info.ProvidePressureAltitude(value);
return true;
}
return false;
}
static bool
PDVDV(NMEAInputLine &line, NMEAInfo &info)
{
fixed value;
if (line.read_checked(value))
info.ProvideTotalEnergyVario(value / 10);
bool ias_available = line.read_checked(value);
fixed tas_ratio = line.read(fixed(1024)) / 1024;
if (ias_available)
info.ProvideBothAirspeeds(value / 10, value / 10 * tas_ratio);
//hasVega = true;
if (line.read_checked(value))
info.ProvidePressureAltitude(value);
return true;
}
bool
DemoReplayGlue::Update(NMEAInfo &data, fixed time_scale)
{
if (!UpdateTime())
return true;
fixed floor_alt = fixed_300;
if (device_blackboard->Calculated().terrain_valid) {
floor_alt += device_blackboard->Calculated().terrain_altitude;
}
bool retval;
{
ProtectedTaskManager::ExclusiveLease protected_task_manager(*task_manager);
TaskAccessor ta(protected_task_manager, floor_alt);
retval = DemoReplay::Update(time_scale, ta);
}
const AircraftState &s = aircraft.GetState();
data.clock = s.time;
data.alive.Update(data.clock);
data.ProvideTime(s.time);
data.location = s.location;
data.location_available.Update(data.clock);
data.ground_speed = s.ground_speed;
data.ground_speed_available.Update(data.clock);
data.track = s.track;
data.track_available.Update(data.clock);
data.gps_altitude = s.altitude;
data.gps_altitude_available.Update(data.clock);
data.ProvidePressureAltitude(s.altitude);
data.ProvideBaroAltitudeTrue(s.altitude);
data.gps.real = false;
data.gps.replay = true;
data.gps.simulator = false;
return retval;
}
static bool
PDVDV(NMEAInputLine &line, NMEAInfo &info)
{
int value;
if (line.ReadChecked(value))
info.ProvideTotalEnergyVario(fixed(value) / 10);
bool ias_available = line.ReadChecked(value);
int tas_ratio = line.Read(1024);
if (ias_available) {
const fixed ias = fixed(value) / 10;
info.ProvideBothAirspeeds(ias, ias * tas_ratio / 1024);
}
//hasVega = true;
if (line.ReadChecked(value))
info.ProvidePressureAltitude(fixed(value));
return true;
}
/**
* Parse the $PLXVF sentence (LXNav V7).
*
* $PLXVF,time ,AccX,AccY,AccZ,Vario,IAS,PressAlt*CS<CR><LF>
*
* Example: $PLXVF,1.00,0.87,-0.12,-0.25,90.2,244.3,*CS<CR><LF>
*
* @see http://www.xcsoar.org/trac/raw-attachment/ticket/1666/V7%20dataport%20specification%201.97.pdf
*/
static bool
PLXVF(NMEAInputLine &line, NMEAInfo &info)
{
line.Skip(4);
fixed vario;
if (line.ReadChecked(vario))
info.ProvideNettoVario(vario);
fixed ias;
bool have_ias = line.ReadChecked(ias);
fixed altitude;
if (line.ReadChecked(altitude)) {
info.ProvidePressureAltitude(altitude);
if (have_ias)
info.ProvideIndicatedAirspeedWithAltitude(ias, altitude);
}
return true;
}
static bool
LK8EX1(NMEAInputLine &line, NMEAInfo &info)
{
unsigned pressure;
bool pressure_available = (line.ReadChecked(pressure) && pressure != 999999);
if (pressure_available)
info.ProvideStaticPressure(AtmosphericPressure::Pascal(fixed(pressure)));
unsigned altitude;
bool altitude_available = (line.ReadChecked(altitude) && altitude != 99999);
if (altitude_available && !pressure_available)
info.ProvidePressureAltitude(fixed(altitude));
int vario;
if (line.ReadChecked(vario) && vario != 9999)
info.ProvideNoncompVario(fixed(vario) / 100);
int temperature;
if (line.ReadChecked(temperature) && temperature != 99) {
info.temperature = fixed(temperature);
info.temperature_available = true;
}
fixed battery_value;
if (line.ReadChecked(battery_value) &&
(unsigned)(battery_value + fixed(0.5)) != 999) {
if (battery_value > fixed(1000)) {
info.battery_level = battery_value - fixed(1000);
info.battery_level_available.Update(info.clock);
} else {
info.voltage = battery_value;
info.voltage_available.Update(info.clock);
}
}
return true;
}
/**
* Parses a PTAS1 sentence (Tasman Instruments proprietary).
*
* @param String Input string
* @param params Parameter array
* @param nparams Number of parameters
* @param info NMEA_INFO struct to parse into
* @return Parsing success
*/
bool
NMEAParser::PTAS1(NMEAInputLine &line, NMEAInfo &info)
{
fixed wnet;
if (line.read_checked(wnet))
info.ProvideTotalEnergyVario(Units::ToSysUnit((wnet - fixed(200)) / 10,
unKnots));
line.skip(); // average vario +200
fixed baralt;
if (line.read_checked(baralt)) {
baralt = max(fixed_zero, Units::ToSysUnit(baralt - fixed(2000), unFeet));
info.ProvidePressureAltitude(baralt);
}
fixed vtas;
if (line.read_checked(vtas))
info.ProvideTrueAirspeed(Units::ToSysUnit(vtas, unKnots));
return true;
}
bool
AltairProDevice::ParseNMEA(const char *String, NMEAInfo &info)
{
if (!VerifyNMEAChecksum(String))
return false;
NMEAInputLine line(String);
char type[16];
line.Read(type, 16);
// no propriatary sentence
if (StringIsEqual(type, "$PGRMZ")) {
fixed value;
if (ReadAltitude(line, value))
info.ProvidePressureAltitude(value);
return true;
} else if (StringIsEqual(type, "$PTFRS")) {
return PTFRS(line, info);
}
return false;
}
/**
* Parse a "$FLYSEN" sentence.
*
* @see http://www.flytec.ch/public/Special%20NMEA%20sentence.pdf
*/
bool
FlytecDevice::ParseFLYSEN(NMEAInputLine &line, NMEAInfo &info)
{
// Detect firmware/sentence version
//
// V or A in field 9 -> 3.31-
// V or A in field 10 -> 3.32+
NMEAInputLine line_copy(line);
line_copy.Skip(8);
bool has_date_field = false;
char validity = line_copy.ReadFirstChar();
if (validity != 'A' && validity != 'V') {
validity = line_copy.ReadFirstChar();
if (validity != 'A' && validity != 'V')
return false;
has_date_field = true;
}
// Date(ddmmyy), 6 Digits (only in firmware version 3.32+)
if (has_date_field)
NMEAParser::ReadDate(line, info.date_time_utc);
// Time(hhmmss), 6 Digits
fixed time;
if (NMEAParser::ReadTime(line, info.date_time_utc, time) &&
!NMEAParser::TimeHasAdvanced(time, last_time, info))
return true;
if (validity == 'V') {
// In case of V (void=not valid) GPS data should not be used.
// GPS altitude, position and speed should be ignored.
line.Skip(7);
} else {
// Latitude(ddmm.mmm), 8 Digits incl. decimal
// N (or S), 1 Digit
// Longitude(dddmm.mmm), 9 Digits inc. decimal
// E (or W), 1 Digit
GeoPoint location;
if (NMEAParser::ReadGeoPoint(line, location)) {
info.location = location;
info.location_available.Update(info.clock);
}
// Track (xxx Deg), 3 Digits
fixed track;
if (line.ReadChecked(track)) {
info.track = Angle::Degrees(track);
info.track_available.Update(info.clock);
}
// Speed over Ground (xxxxx dm/s), 5 Digits
fixed ground_speed;
if (line.ReadChecked(ground_speed)) {
info.ground_speed = ground_speed / 10;
info.ground_speed_available.Update(info.clock);
}
// GPS altitude (xxxxx meter), 5 Digits
fixed gps_altitude;
if (line.ReadChecked(gps_altitude)) {
info.gps_altitude = gps_altitude;
info.gps_altitude_available.Update(info.clock);
}
}
// Validity of 3 D fix A or V, 1 Digit
line.Skip();
// Satellites in Use (0 to 12), 2 Digits
unsigned satellites_used;
if (line.ReadChecked(satellites_used)) {
info.gps.satellites_used = satellites_used;
info.gps.satellites_used_available.Update(info.clock);
}
// Raw pressure (xxxxxx Pa), 6 Digits
fixed pressure;
if (line.ReadChecked(pressure))
info.ProvideStaticPressure(AtmosphericPressure::Pascal(pressure));
// Baro Altitude (xxxxx meter), 5 Digits (-xxxx to xxxxx) (Based on 1013.25hPa)
fixed baro_altitude;
if (line.ReadChecked(baro_altitude))
info.ProvidePressureAltitude(baro_altitude);
// Variometer (xxxx cm/s), 4 or 5 Digits (-9999 to 9999)
fixed vario;
if (line.ReadChecked(vario))
info.ProvideTotalEnergyVario(vario / 100);
// True airspeed (xxxxx dm/s), 5 Digits
fixed tas;
if (line.ReadChecked(tas))
info.ProvideTrueAirspeed(tas / 10);
// Airspeed source P or V, 1 Digit P= pitot, V = Vane wheel
line.Skip();
// Temp. PCB (xxx °C), 3 Digits
fixed pcb_temperature;
bool pcb_temperature_available = line.ReadChecked(pcb_temperature);
// Temp. Balloon Envelope (xxx °C), 3 Digits
fixed balloon_temperature;
bool balloon_temperature_available = line.ReadChecked(balloon_temperature);
if (balloon_temperature_available) {
info.temperature = CelsiusToKelvin(balloon_temperature);
info.temperature_available = true;
} else if (pcb_temperature_available) {
info.temperature = CelsiusToKelvin(pcb_temperature);
info.temperature_available = true;
}
// Battery Capacity Bank 1 (0 to 100%) 3 Digits
fixed battery_level_1;
bool battery_level_1_available = line.ReadChecked(battery_level_1);
// Battery Capacity Bank 2 (0 to 100%) 3 Digits
fixed battery_level_2;
bool battery_level_2_available = line.ReadChecked(battery_level_2);
if (battery_level_1_available) {
if (battery_level_2_available)
info.battery_level = (battery_level_1 + battery_level_2) / 2;
else
info.battery_level = battery_level_1;
info.battery_level_available.Update(info.clock);
} else if (battery_level_2_available) {
info.battery_level = battery_level_2;
info.battery_level_available.Update(info.clock);
}
// Dist. to WP (xxxxxx m), 6 Digits (Max 200000m)
// Bearing (xxx Deg), 3 Digits
// Speed to fly1 (MC0 xxxxx cm/s), 5 Digits
// Speed to fly2 (McC. xxxxx cm/s) 5 Digits
// Keypress Code (Experimental empty to 99) 2 Digits
return true;
}
bool
IgcReplay::Update(NMEAInfo &basic)
{
IGCFix fix;
while (true) {
if (!ReadPoint(fix, basic))
return false;
if (fix.time.IsPlausible())
break;
}
basic.clock = fixed(fix.time.GetSecondOfDay());
basic.alive.Update(basic.clock);
basic.ProvideTime(basic.clock);
basic.location = fix.location;
basic.location_available.Update(basic.clock);
if (fix.gps_altitude != 0) {
basic.gps_altitude = fixed(fix.gps_altitude);
basic.gps_altitude_available.Update(basic.clock);
} else
basic.gps_altitude_available.Clear();
if (fix.pressure_altitude != 0) {
basic.ProvidePressureAltitude(fixed(fix.pressure_altitude));
basic.ProvideBaroAltitudeTrue(fixed(fix.pressure_altitude));
} else {
basic.pressure_altitude_available.Clear();
basic.baro_altitude_available.Clear();
}
if (fix.enl >= 0) {
basic.engine_noise_level = fix.enl;
basic.engine_noise_level_available.Update(basic.clock);
} else
basic.engine_noise_level_available.Clear();
if (fix.trt >= 0) {
basic.track = Angle::Degrees(fixed(fix.trt));
basic.track_available.Update(basic.clock);
} else
basic.track_available.Clear();
if (fix.gsp >= 0) {
basic.ground_speed = Units::ToSysUnit(fixed(fix.gsp),
Unit::KILOMETER_PER_HOUR);
basic.ground_speed_available.Update(basic.clock);
} else
basic.ground_speed_available.Clear();
if (fix.ias >= 0) {
fixed ias = Units::ToSysUnit(fixed(fix.ias), Unit::KILOMETER_PER_HOUR);
if (fix.tas >= 0)
basic.ProvideBothAirspeeds(ias,
Units::ToSysUnit(fixed(fix.tas),
Unit::KILOMETER_PER_HOUR));
else
basic.ProvideIndicatedAirspeedWithAltitude(ias, basic.pressure_altitude);
} else if (fix.tas >= 0)
basic.ProvideTrueAirspeed(Units::ToSysUnit(fixed(fix.tas),
Unit::KILOMETER_PER_HOUR));
if (fix.siu >= 0) {
basic.gps.satellites_used = fix.siu;
basic.gps.satellites_used_available.Update(basic.clock);
}
basic.gps.real = false;
basic.gps.replay = true;
basic.gps.simulator = false;
return true;
}
bool
Replay::Update()
{
if (replay == nullptr)
return false;
if (time_scale <= 0) {
/* replay is paused */
/* to avoid a big fast-forward with the next
PeriodClock::ElapsedUpdate() call below after unpausing, update
the clock each time we're called while paused */
clock.Update();
return true;
}
const double old_virtual_time = virtual_time;
if (virtual_time >= 0) {
/* update the virtual time */
assert(clock.IsDefined());
if (fast_forward < 0) {
virtual_time += clock.ElapsedUpdate() * time_scale / 1000;
} else {
clock.Update();
virtual_time += 1;
if (virtual_time >= fast_forward)
fast_forward = -1;
}
} else {
/* if we ever received a valid time from the AbstractReplay, then
virtual_time must be initialised */
assert(!next_data.time_available);
}
if (cli == nullptr || fast_forward >= 0) {
if (next_data.time_available && virtual_time < next_data.time)
/* still not time to use next_data */
return true;
{
std::lock_guard<Mutex> lock(device_blackboard->mutex);
device_blackboard->SetReplayState() = next_data;
device_blackboard->ScheduleMerge();
}
while (true) {
if (!replay->Update(next_data)) {
Stop();
return false;
}
assert(!next_data.gps.real);
if (next_data.time_available) {
if (virtual_time < 0) {
virtual_time = next_data.time;
if (fast_forward >= 0)
fast_forward += virtual_time;
clock.Update();
break;
}
if (next_data.time >= virtual_time)
break;
if (next_data.time < old_virtual_time) {
/* time warp; that can happen on midnight wraparound during
NMEA replay */
virtual_time = next_data.time;
break;
}
}
}
} else {
while (cli->NeedData(virtual_time)) {
if (!replay->Update(next_data)) {
Stop();
return false;
}
assert(!next_data.gps.real);
if (next_data.time_available)
cli->Update(next_data.time, next_data.location,
next_data.gps_altitude,
next_data.pressure_altitude);
}
if (virtual_time < 0) {
virtual_time = cli->GetMaxTime();
if (fast_forward >= 0)
fast_forward += virtual_time;
clock.Update();
}
const CatmullRomInterpolator::Record r = cli->Interpolate(virtual_time);
const GeoVector v = cli->GetVector(virtual_time);
NMEAInfo data = next_data;
data.clock = virtual_time;
data.alive.Update(data.clock);
data.ProvideTime(virtual_time);
data.location = r.location;
data.location_available.Update(data.clock);
data.ground_speed = v.distance;
data.ground_speed_available.Update(data.clock);
data.track = v.bearing;
data.track_available.Update(data.clock);
data.gps_altitude = r.gps_altitude;
data.gps_altitude_available.Update(data.clock);
data.ProvidePressureAltitude(r.baro_altitude);
data.ProvideBaroAltitudeTrue(r.baro_altitude);
{
std::lock_guard<Mutex> lock(device_blackboard->mutex);
device_blackboard->SetReplayState() = data;
device_blackboard->ScheduleMerge();
}
}
return true;
}
