void
CaiLNavDevice::OnCalculatedUpdate(const MoreData &basic,
                                  const DerivedInfo &calculated)
{
  NullOperationEnvironment env;
  char buffer[100];

  const GeoPoint here = basic.location_available
    ? basic.location
    : GeoPoint::Invalid();

  const ElementStat &current_leg = calculated.task_stats.current_leg;
  AGeoPoint destination =
    AGeoPoint(current_leg.location_remaining,
              current_leg.solution_planned.min_arrival_altitude);

  if (FormatGPRMC(buffer, sizeof(buffer), basic))
    PortWriteNMEA(port, buffer, env);

  if (FormatGPRMB(buffer, sizeof(buffer), here, destination))
    PortWriteNMEA(port, buffer, env);

  if (FormatPCAIB(buffer, sizeof(buffer), destination))
    PortWriteNMEANoChecksum(port, buffer, env);
}

bool
DeviceDescriptor::WriteNMEA(const char *line)
{
  assert(line != NULL);

  return port != NULL && PortWriteNMEA(*port, line);
}

 /**
  * Set the MC setting of the V7 vario
  * @param mc in m/s
  */
 static inline bool
 SetMacCready(Port &port, OperationEnvironment &env, fixed mc)
 {
   char buffer[32];
   sprintf(buffer, "PLXV0,MC,W,%.1f", (double)mc);
   return PortWriteNMEA(port, buffer, env);
 }

bool
DeviceDescriptor::WriteNMEA(const char *line, OperationEnvironment &env)
{
  assert(line != nullptr);

  return port != nullptr && PortWriteNMEA(*port, line, env);
}

bool
VegaDevice::RequestSetting(const char *name, OperationEnvironment &env)
{
  char buffer[64];
  sprintf(buffer, "PDVSC,R,%s", name);
  return PortWriteNMEA(port, buffer, env);
}

bool
FlymasterF1Device::EnableNMEA(OperationEnvironment &env)
{
  /* this command initiates NMEA mode according to the "Flymaster F1
     Commands" document */
  return PortWriteNMEA(port, "$PFMNAV,", env);
}

bool
LXDevice::PutMacCready(fixed mac_cready, OperationEnvironment &env)
{
  if (!EnableNMEA(env))
    return false;

  char tmp[32];
  sprintf(tmp, "PFLX2,%1.1f,,,,,,", (double)mac_cready);
  PortWriteNMEA(port, tmp, env);

  // LXNAV V7 variant:
  sprintf(tmp, "PLXV0,MC,W,%.1f", (double)mac_cready);
  PortWriteNMEA(port, tmp, env);

  return true;
}

 /**
  * Set the ballast setting of the V7 vario
  * @param overload 1.0 - 1.4 (100 - 140%)
  */
 static inline bool
 SetBallast(Port &port, OperationEnvironment &env, fixed overload)
 {
   char buffer[100];
   sprintf(buffer, "PLXV0,BAL,W,%.2f", (double)overload);
   return PortWriteNMEA(port, buffer, env);
 }

 /**
  * Set the bugs setting of the V7 vario
  * @param bugs 0 - 30 %
  */
 static inline bool
 SetBugs(Port &port, OperationEnvironment &env, unsigned bugs)
 {
   char buffer[100];
   sprintf(buffer, "PLXV0,BUGS,W,%u", bugs);
   return PortWriteNMEA(port, buffer, env);
 }

bool
Vega::VolatileData::SendTo(Port &port, OperationEnvironment &env) const
{
  char buffer[100];
  sprintf(buffer, "PDVMC,%u,%u,%u,%d,%u",
          mc, stf, circling, terrain_altitude, qnh);
  return PortWriteNMEA(port, buffer, env);
}

 /**
  * Set the QNH setting of the V7 vario
  */
 static inline bool
 SetQNH(Port &port, OperationEnvironment &env, const AtmosphericPressure &qnh)
 {
   char buffer[100];
   unsigned QNHinPascal = uround(qnh.GetPascal());
   sprintf(buffer, "PLXV0,QNH,W,%u", QNHinPascal); 
   return PortWriteNMEA(port, buffer, env);
 }

bool
LXDevice::PutMacCready(fixed MacCready)
{
  char szTmp[32];
  sprintf(szTmp, "PFLX2,%1.1f,,,,,,", (double)MacCready);
  PortWriteNMEA(port, szTmp);
  return true;
}

void
devWriteNMEAString(DeviceDescriptor &d, const TCHAR *text)
{
  if (d.Com == NULL)
    return;

  PortWriteNMEA(d.Com, text);
}

void
VarioWriteNMEA(const TCHAR *text)
{
  for (int i = 0; i < NUMDEV; i++)
    if (DeviceList[i].IsVega())
      if (DeviceList[i].Com)
        PortWriteNMEA(DeviceList[i].Com, text);
}

bool
VaulterDevice::PutMacCready(fixed mc, OperationEnvironment &env)
{
  if (!EnableNMEA(env))
    return false;
  char buffer[30];
  sprintf(buffer,"PITV1,MC=%0.2f", (double)mc);
  return PortWriteNMEA(port, buffer, env);
}

static bool
RequestLogbookContents(Port &port, unsigned start, unsigned end,
                       OperationEnvironment &env)
{
  char buffer[32];
  sprintf(buffer, "PLXVC,LOGBOOK,R,%u,%u,", start, end);

  return PortWriteNMEA(port, buffer, env);
}

 static bool
 SetupNMEA(Port &port, OperationEnvironment &env)
 {
   /* This line initiates the Color Vario to send out LXWP2 and LXWP3
      LXWP0 once started, is repeated every second.  This is a copy
      of the initiation done in LK8000, realized by LX Navigation
      developers We have no documentation and so we do not know what
      this exactly means. */
   return PortWriteNMEA(port, "PFLX0,LXWP0,1,LXWP2,3,LXWP3,4", env);
 }

static bool
RequestFlight(Port &port, const char *filename,
              unsigned start_row, unsigned end_row,
              OperationEnvironment &env)
{
  char buffer[64];
  sprintf(buffer, "PLXVC,FLIGHT,R,%s,%u,%u,", filename, start_row, end_row);

  return PortWriteNMEA(port, buffer, env);
}

bool
BlueFlyDevice::RequestSettings(OperationEnvironment &env)
{
  {
    const ScopeLock lock(mutex_settings);
    settings_ready = false;
  }

  return PortWriteNMEA(port, "BST", env);
}

bool
BlueFlyDevice::WriteDeviceSetting(const char *name, int value,
                                  OperationEnvironment &env)
{
  char buffer[64];

  assert(strlen(name) == 3);

  sprintf(buffer, "%s %d", name, value);
  return PortWriteNMEA(port, buffer, env);
}