src/Device/Driver/CAI302/Protocol.cpp

   1 /*
   2 Copyright_License {
   3
   4   XCSoar Glide Computer - http://www.xcsoar.org/
   5   Copyright (C) 2000-2013 The XCSoar Project
   6   A detailed list of copyright holders can be found in the file "AUTHORS".
   7
   8   This program is free software; you can redistribute it and/or
   9   modify it under the terms of the GNU General Public License
  10   as published by the Free Software Foundation; either version 2
  11   of the License, or (at your option) any later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with this program; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21 }
  22 */
  23
  24 #include "Protocol.hpp"
  25 #include "Device/Port/Port.hpp"
  26 #include "OS/ByteOrder.hpp"
  27 #include "Geo/GeoPoint.hpp"
  28
  29 #include <algorithm>
  30 #include <assert.h>
  31 #include <string.h>
  32 #include <stdio.h>
  33
  34 bool
  35 CAI302::WriteString(Port &port, const char *p, OperationEnvironment &env)
  36 {
  37   size_t length = strlen(p);
  38   return port.FullWrite(p, length, env, 2000);
  39 }
  40
  41 bool
  42 CAI302::CommandModeQuick(Port &port)
  43 {
  44   return port.Write('\x03');
  45 }
  46
  47 static bool
  48 WaitCommandPrompt(Port &port, OperationEnvironment &env,
  49                   unsigned timeout_ms=2000)
  50 {
  51   return port.ExpectString("cmd>", env, timeout_ms);
  52 }
  53
  54 bool
  55 CAI302::CommandMode(Port &port, OperationEnvironment &env)
  56 {
  57   port.Flush();
  58   return CommandModeQuick(port) && WaitCommandPrompt(port, env);
  59 }
  60
  61 bool
  62 CAI302::SendCommandQuick(Port &port, const char *cmd,
  63                          OperationEnvironment &env)
  64 {
  65   if (!CommandMode(port, env))
  66     return false;
  67
  68   port.Flush();
  69   return WriteString(port, cmd, env);
  70 }
  71
  72 bool
  73 CAI302::SendCommand(Port &port, const char *cmd,
  74                     OperationEnvironment &env, unsigned timeout_ms)
  75 {
  76   return SendCommandQuick(port, cmd, env) &&
  77     WaitCommandPrompt(port, env, timeout_ms);
  78 }
  79
  80 bool
  81 CAI302::LogModeQuick(Port &port, OperationEnvironment &env)
  82 {
  83   return CommandModeQuick(port) && WriteString(port, "LOG 0\r", env);
  84 }
  85
  86 bool
  87 CAI302::LogMode(Port &port, OperationEnvironment &env)
  88 {
  89   return SendCommandQuick(port, "LOG 0\r", env);
  90 }
  91
  92 static bool
  93 WaitUploadPrompt(Port &port, OperationEnvironment &env,
  94                  unsigned timeout_ms=2000)
  95 {
  96   return port.ExpectString("up>", env, timeout_ms);
  97 }
  98
  99 bool
 100 CAI302::UploadMode(Port &port, OperationEnvironment &env)
 101 {
 102   return SendCommandQuick(port, "UPLOAD 1\r", env) &&
 103     WaitUploadPrompt(port, env);
 104 }
 105
 106 int
 107 CAI302::ReadShortReply(Port &port, void *buffer, unsigned max_size,
 108                        OperationEnvironment &env, unsigned timeout_ms)
 109 {
 110   unsigned char header[3];
 111   if (!port.FullRead(header, sizeof(header), env, timeout_ms))
 112     return -1;
 113
 114   unsigned size = header[0];
 115   if (size < sizeof(header))
 116     return -1;
 117
 118   size -= sizeof(header);
 119   if (size > max_size)
 120     size = max_size;
 121
 122   if (!port.FullRead(buffer, size, env, timeout_ms))
 123     return -1;
 124
 125   // XXX verify the checksum
 126
 127   if (size < max_size) {
 128     /* fill the rest with zeroes */
 129     char *p = (char *)buffer;
 130     std::fill(p + size, p + max_size, 0);
 131   }
 132
 133   return size;
 134 }
 135
 136 int
 137 CAI302::ReadLargeReply(Port &port, void *buffer, unsigned max_size,
 138                        OperationEnvironment &env, unsigned timeout_ms)
 139 {
 140   unsigned char header[5];
 141   if (!port.FullRead(header, sizeof(header), env, timeout_ms))
 142     return -1;
 143
 144   unsigned size = (header[0] << 8) | header[1];
 145   if (size < sizeof(header))
 146     return -1;
 147
 148   size -= sizeof(header);
 149   if (size > max_size)
 150     size = max_size;
 151
 152   if (!port.FullRead(buffer, size, env, timeout_ms))
 153     return -1;
 154
 155   // XXX verify the checksum
 156
 157   if (size < max_size) {
 158     /* fill the rest with zeroes */
 159     char *p = (char *)buffer;
 160     std::fill(p + size, p + max_size, 0);
 161   }
 162
 163   return size;
 164 }
 165
 166 int
 167 CAI302::UploadShort(Port &port, const char *command,
 168                     void *response, unsigned max_size,
 169                     OperationEnvironment &env, unsigned timeout_ms)
 170 {
 171   port.Flush();
 172   if (!WriteString(port, command, env))
 173     return -1;
 174
 175   int nbytes = ReadShortReply(port, response, max_size, env, timeout_ms);
 176   if (nbytes < 0)
 177     return nbytes;
 178
 179   if (!WaitUploadPrompt(port, env))
 180     return -1;
 181
 182   return nbytes;
 183 }
 184
 185 int
 186 CAI302::UploadLarge(Port &port, const char *command,
 187                     void *response, unsigned max_size,
 188                     OperationEnvironment &env, unsigned timeout_ms)
 189 {
 190   port.Flush();
 191   if (!WriteString(port, command, env))
 192     return -1;
 193
 194   int nbytes = ReadLargeReply(port, response, max_size, env, timeout_ms);
 195   if (nbytes < 0)
 196     return nbytes;
 197
 198   if (!WaitUploadPrompt(port, env))
 199     return -1;
 200
 201   return nbytes;
 202 }
 203
 204 bool
 205 CAI302::UploadGeneralInfo(Port &port, GeneralInfo &data,
 206                           OperationEnvironment &env)
 207 {
 208   return UploadShort(port, "W\r", &data, sizeof(data), env) == sizeof(data);
 209 }
 210
 211 bool
 212 CAI302::UploadFileList(Port &port, unsigned i, FileList &data,
 213                        OperationEnvironment &env)
 214 {
 215   assert(i < 8);
 216
 217   char cmd[16];
 218   snprintf(cmd, sizeof(cmd), "B %u\r", 196 + i);
 219   return UploadLarge(port, cmd, &data, sizeof(data), env) == sizeof(data);
 220 }
 221
 222 bool
 223 CAI302::UploadFileASCII(Port &port, unsigned i, FileASCII &data,
 224                         OperationEnvironment &env)
 225 {
 226   assert(i < 64);
 227
 228   char cmd[16];
 229   snprintf(cmd, sizeof(cmd), "B %u\r", 64 + i);
 230   return UploadLarge(port, cmd, &data, sizeof(data), env) == sizeof(data);
 231 }
 232
 233 bool
 234 CAI302::UploadFileBinary(Port &port, unsigned i, FileBinary &data,
 235                          OperationEnvironment &env)
 236 {
 237   assert(i < 64);
 238
 239   char cmd[16];
 240   snprintf(cmd, sizeof(cmd), "B %u\r", 256 + i);
 241   return UploadLarge(port, cmd, &data, sizeof(data), env) == sizeof(data);
 242 }
 243
 244 int
 245 CAI302::UploadFileData(Port &port, bool next, void *data, unsigned length,
 246                        OperationEnvironment &env)
 247 {
 248   return UploadLarge(port, next ? "B N\r" : "B R\r", data, length, env, 15000);
 249 }
 250
 251 bool
 252 CAI302::UploadFileSignatureASCII(Port &port, FileSignatureASCII &data,
 253                                  OperationEnvironment &env)
 254 {
 255   return UploadLarge(port, "B S\r", &data, sizeof(data), env) == sizeof(data);
 256 }
 257
 258 bool
 259 CAI302::UploadPolarMeta(Port &port, PolarMeta &data, OperationEnvironment &env)
 260 {
 261   return UploadShort(port, "G\r", &data, sizeof(data), env) > 0;
 262 }
 263
 264 bool
 265 CAI302::UploadPolar(Port &port, Polar &data, OperationEnvironment &env)
 266 {
 267   return UploadShort(port, "G 0\r", &data, sizeof(data), env) > 0;
 268 }
 269
 270 bool
 271 CAI302::UploadPilotMeta(Port &port, PilotMeta &data, OperationEnvironment &env)
 272 {
 273   return UploadShort(port, "O\r", &data, sizeof(data), env) > 0;
 274 }
 275
 276 bool
 277 CAI302::UploadPilotMetaActive(Port &port, PilotMetaActive &data,
 278                               OperationEnvironment &env)
 279 {
 280   return UploadShort(port, "O A\r", &data, sizeof(data), env) > 0;
 281 }
 282
 283 bool
 284 CAI302::UploadPilot(Port &port, unsigned i, Pilot &data,
 285                     OperationEnvironment &env)
 286 {
 287   char cmd[16];
 288   snprintf(cmd, sizeof(cmd), "O %u\r", i);
 289   return UploadShort(port, cmd, &data, sizeof(data), env) > 0;
 290 }
 291
 292 int
 293 CAI302::UploadPilotBlock(Port &port, unsigned start, unsigned count,
 294                          unsigned record_size, void *buffer,
 295                          OperationEnvironment &env)
 296 {
 297   char cmd[16];
 298   snprintf(cmd, sizeof(cmd), "O B %u %u\r", start, count);
 299
 300   /* the CAI302 data port user's guide 2.2 says that the "O B"
 301      response is "large", but this seems wrong */
 302   int nbytes = UploadShort(port, cmd, buffer, count * record_size, env);
 303   return nbytes >= 0 && nbytes % record_size == 0
 304     ? nbytes / record_size
 305     : -1;
 306 }
 307
 308 static bool
 309 WaitDownloadPrompt(Port &port, OperationEnvironment &env,
 310                    unsigned timeout_ms=2000)
 311 {
 312   return port.ExpectString("dn>", env, timeout_ms);
 313 }
 314
 315 bool
 316 CAI302::DownloadMode(Port &port, OperationEnvironment &env)
 317 {
 318   return SendCommandQuick(port, "DOWNLOAD 1\r", env) &&
 319     WaitDownloadPrompt(port, env);
 320 }
 321
 322 bool
 323 CAI302::DownloadCommand(Port &port, const char *command,
 324                         OperationEnvironment &env, unsigned timeout_ms)
 325 {
 326   return WriteString(port, command, env) && WaitDownloadPrompt(port, env);
 327 }
 328
 329 bool
 330 CAI302::DownloadPilot(Port &port, const Pilot &pilot, unsigned ordinal,
 331                       OperationEnvironment &env)
 332 {
 333   char buffer[256];
 334   snprintf(buffer, sizeof(buffer),
 335            "O,%-24s,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\r",
 336            pilot.name,
 337            (ordinal << 8) | pilot.old_units,
 338            pilot.old_temperatur_units,
 339            pilot.sink_tone,
 340            pilot.total_energy_final_glide,
 341            pilot.show_final_glide_altitude_difference,
 342            pilot.map_datum,
 343            FromBE16(pilot.approach_radius),
 344            FromBE16(pilot.arrival_radius),
 345            FromBE16(pilot.enroute_logging_interval),
 346            FromBE16(pilot.close_logging_interval),
 347            FromBE16(pilot.time_between_flight_logs),
 348            FromBE16(pilot.minimum_speed_to_force_flight_logging),
 349            pilot.stf_dead_band,
 350            pilot.reserved_vario,
 351            FromBE16(pilot.unit_word),
 352            FromBE16(pilot.margin_height));
 353
 354   return DownloadCommand(port, buffer, env);
 355 }
 356
 357 bool
 358 CAI302::DownloadPolar(Port &port, const Polar &polar,
 359                       OperationEnvironment &env)
 360 {
 361   char buffer[256];
 362   snprintf(buffer, sizeof(buffer),
 363            "G,%-12s,%-12s,%d,%d,%d,%d,%d,%d,%d,%d\r",
 364            polar.glider_type,
 365            polar.glider_id,
 366            polar.best_ld,
 367            polar.best_glide_speed,
 368            polar.two_ms_sink_at_speed,
 369            FromBE16(polar.weight_in_litres),
 370            FromBE16(polar.ballast_capacity),
 371            0,
 372            FromBE16(polar.config_word),
 373            FromBE16(polar.wing_area));
 374
 375   return DownloadCommand(port, buffer, env);
 376 }
 377
 378 bool
 379 CAI302::UploadNavpointMeta(Port &port, NavpointMeta &data,
 380                            OperationEnvironment &env)
 381 {
 382   return UploadShort(port, "C\r", &data, sizeof(data), env) > 0;
 383 }
 384
 385 bool
 386 CAI302::UploadNavpoint(Port &port, unsigned i, Navpoint &data,
 387                        OperationEnvironment &env)
 388 {
 389   char cmd[16];
 390   snprintf(cmd, sizeof(cmd), "C %u\r", i);
 391   return UploadShort(port, cmd, &data, sizeof(data), env) > 0;
 392 }
 393
 394 static void
 395 FormatGeoPoint(char *buffer, const GeoPoint &location)
 396 {
 397   int DegLat, DegLon;
 398   double tmp, MinLat, MinLon;
 399   char NoS, EoW;
 400
 401   tmp = (double)location.latitude.Degrees();
 402   NoS = 'N';
 403   if (tmp < 0) {
 404     NoS = 'S';
 405     tmp = -tmp;
 406   }
 407   DegLat = (int)tmp;
 408   MinLat = (tmp - DegLat) * 60;
 409
 410   tmp = (double)location.longitude.Degrees();
 411   EoW = 'E';
 412   if (tmp < 0) {
 413     EoW = 'W';
 414     tmp = -tmp;
 415   }
 416   DegLon = (int)tmp;
 417   MinLon = (tmp - DegLon) * 60;
 418
 419   sprintf(buffer, "%02d%07.4f%c,%03d%07.4f%c",
 420           DegLat, MinLat, NoS,
 421           DegLon, MinLon, EoW);
 422 }
 423
 424 bool
 425 CAI302::DownloadNavpoint(Port &port, const GeoPoint &location,
 426                          int altitude, unsigned id,
 427                          bool turnpoint, bool airfield, bool markpoint,
 428                          bool landing_point, bool start_point,
 429                          bool finish_point, bool home_point,
 430                          bool thermal_point, bool waypoint, bool airspace,
 431                          const char *name, const char *remark,
 432                          OperationEnvironment &env)
 433 {
 434   assert(name != NULL);
 435
 436   char location_string[32];
 437   FormatGeoPoint(location_string, location);
 438
 439   unsigned attr = turnpoint | (airfield << 1) | (markpoint << 2) |
 440     (landing_point << 3) | (start_point << 4) | (finish_point << 5) |
 441     (home_point << 6) | (thermal_point << 7) | (waypoint << 8) |
 442     (airfield << 9);
 443
 444   if (remark == NULL)
 445     remark = "";
 446
 447   char buffer[256];
 448   snprintf(buffer, sizeof(buffer), "C,0,%s,%d,%u,%u,%-12s,%-12s\r",
 449            location_string, altitude, id, attr, name, remark);
 450   return DownloadCommand(port, buffer, env);
 451 }
 452
 453 bool
 454 CAI302::DeclareTP(Port &port, unsigned i, const GeoPoint &location,
 455                   int altitude, const char *name, OperationEnvironment &env)
 456 {
 457   char location_string[32];
 458   FormatGeoPoint(location_string, location);
 459
 460   char buffer[256];
 461   snprintf(buffer, sizeof(buffer),
 462            "D,%d,%s,%s,%d\r",
 463            128 + i, location_string,
 464            name,
 465            altitude);
 466
 467   return DownloadCommand(port, buffer, env);
 468 }
 469
 470 bool
 471 CAI302::DeclareSave(Port &port, OperationEnvironment &env)
 472 {
 473   return DownloadCommand(port, "D,255\r", env, 5000);
 474 }
 475
 476 bool
 477 CAI302::Reboot(Port &port, OperationEnvironment &env)
 478 {
 479   return SendCommandQuick(port, "SIF 0 0\r", env);
 480 }
 481
 482 bool
 483 CAI302::PowerOff(Port &port, OperationEnvironment &env)
 484 {
 485   return SendCommandQuick(port, "DIE\r", env);
 486 }
 487
 488 bool
 489 CAI302::StartLogging(Port &port, OperationEnvironment &env)
 490 {
 491   return SendCommand(port, "START\r", env);
 492 }
 493
 494 bool
 495 CAI302::StopLogging(Port &port, OperationEnvironment &env)
 496 {
 497   return SendCommand(port, "STOP\r", env);
 498 }
 499
 500 bool
 501 CAI302::SetVolume(Port &port, unsigned volume, OperationEnvironment &env)
 502 {
 503   char cmd[16];
 504   sprintf(cmd, "VOL %u\r", volume);
 505   return SendCommand(port, cmd, env);
 506 }
 507
 508 bool
 509 CAI302::ClearPoints(Port &port, OperationEnvironment &env)
 510 {
 511   return SendCommand(port, "CLEAR POINTS\r", env, 5000);
 512 }
 513
 514 bool
 515 CAI302::ClearPilot(Port &port, OperationEnvironment &env)
 516 {
 517   return SendCommand(port, "CLEAR PILOT\r", env, 5000);
 518 }
 519
 520 bool
 521 CAI302::ClearLog(Port &port, OperationEnvironment &env)
 522 {
 523   return SendCommand(port, "CLEAR LOG\r", env, 60000);
 524 }
 525
 526 static unsigned
 527 ConvertBaudRate(unsigned baud_rate)
 528 {
 529   switch (baud_rate) {
 530   case 1200: return 4;
 531   case 2400: return 5;
 532   case 4800: return 6;
 533   case 9600: return 7;
 534   case 19200: return 8;
 535   case 38400: return 9;
 536   case 57600: return 10;
 537   case 115200: return 11;
 538   default: return 0;
 539   }
 540 }
 541
 542 bool
 543 CAI302::SetBaudRate(Port &port, unsigned baud_rate, OperationEnvironment &env)
 544 {
 545   unsigned n = ConvertBaudRate(baud_rate);
 546   if (n == 0)
 547     return false;
 548
 549   char cmd[16];
 550   sprintf(cmd, "BAUD %u\r", n);
 551   return SendCommandQuick(port, cmd, env);
 552 }