src/Device/Driver/Volkslogger/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 "Util/CRC.hpp"
  26 #include "Device/Port/Port.hpp"
  27 #include "Operation/Operation.hpp"
  28 #include "Time/TimeoutClock.hpp"
  29
  30 #include <string.h>
  31
  32 bool
  33 Volkslogger::Reset(Port &port, OperationEnvironment &env, unsigned n)
  34 {
  35   static constexpr unsigned delay = 2;
  36
  37   while (n-- > 0) {
  38     if (!port.Write(CAN))
  39       return false;
  40
  41     env.Sleep(delay);
  42   }
  43
  44   return true;
  45 }
  46
  47 bool
  48 Volkslogger::Handshake(Port &port, OperationEnvironment &env,
  49                        unsigned timeout_ms)
  50 {
  51   TimeoutClock timeout(timeout_ms);
  52
  53   while (true) { // Solange R's aussenden, bis ein L zurückkommt
  54     if (!port.Write('R'))
  55       return false;
  56
  57     int remaining = timeout.GetRemainingSigned();
  58     if (remaining < 0)
  59       return false;
  60
  61     if (remaining > 500)
  62       remaining = 500;
  63
  64     Port::WaitResult result =
  65       port.WaitForChar('L', env, remaining);
  66     if (result == Port::WaitResult::READY)
  67       break;
  68
  69     if (result != Port::WaitResult::TIMEOUT)
  70       return false;
  71
  72     /* timeout, try again */
  73   }
  74
  75   unsigned count = 1;
  76   while (true) { // Auf 4 hintereinanderfolgende L's warten
  77     int remaining = timeout.GetRemainingSigned();
  78     if (remaining < 0)
  79       return false;
  80
  81     if (port.WaitForChar('L', env, remaining) != Port::WaitResult::READY)
  82       return false;
  83
  84     count++;
  85     if (count >= 4)
  86       return true;
  87   }
  88 }
  89
  90 bool
  91 Volkslogger::Connect(Port &port, OperationEnvironment &env,
  92                      unsigned timeout_ms)
  93 {
  94   return Reset(port, env, 10) && Handshake(port, env, timeout_ms);
  95 }
  96
  97 bool
  98 Volkslogger::ConnectAndFlush(Port &port, OperationEnvironment &env,
  99                              unsigned timeout_ms)
 100 {
 101   port.Flush();
 102
 103   return Connect(port, env, timeout_ms) && port.FullFlush(env, 50, 300);
 104 }
 105
 106 static bool
 107 SendWithCRC(Port &port, const void *data, size_t length,
 108             OperationEnvironment &env)
 109 {
 110   if (!port.FullWrite(data, length, env, 2000))
 111     return false;
 112
 113   uint16_t crc16 = UpdateCRC16CCITT(data, length, 0);
 114   return port.Write(crc16 >> 8) && port.Write(crc16 & 0xff);
 115 }
 116
 117 bool
 118 Volkslogger::SendCommand(Port &port, OperationEnvironment &env,
 119                          Command cmd, uint8_t param1, uint8_t param2)
 120 {
 121   static constexpr unsigned delay = 2;
 122
 123   /* flush buffers */
 124   if (!port.FullFlush(env, 20, 100))
 125     return false;
 126
 127   /* reset command interpreter */
 128   if (!Reset(port, env, 6))
 129     return false;
 130
 131   /* send command packet */
 132
 133   const uint8_t cmdarray[8] = {
 134     (uint8_t)cmd, param1, param2,
 135     0, 0, 0, 0, 0,
 136   };
 137
 138   if (!port.Write(ENQ))
 139     return false;
 140
 141   env.Sleep(delay);
 142
 143   if (!SendWithCRC(port, cmdarray, sizeof(cmdarray), env))
 144     return false;
 145
 146   /* wait for confirmation */
 147
 148   return port.WaitRead(env, 4000) == Port::WaitResult::READY &&
 149     port.GetChar() == 0;
 150 }
 151
 152 gcc_const
 153 static int
 154 GetBaudRateIndex(unsigned baud_rate)
 155 {
 156   switch(baud_rate) {
 157   case 9600:
 158     return 1;
 159
 160   case 19200:
 161     return 2;
 162
 163   case 38400:
 164     return 3;
 165
 166   case 57600:
 167     return 4;
 168
 169   case 115200:
 170     return 5;
 171
 172   default:
 173     return -1;
 174   }
 175 }
 176
 177 bool
 178 Volkslogger::SendCommandSwitchBaudRate(Port &port, OperationEnvironment &env,
 179                                        Command cmd, uint8_t param1,
 180                                        unsigned baud_rate)
 181 {
 182   int baud_rate_index = GetBaudRateIndex(baud_rate);
 183   if (baud_rate_index < 0)
 184     return false;
 185
 186   if (!SendCommand(port, env, cmd, param1, baud_rate_index))
 187     return false;
 188
 189   return port.SetBaudrate(baud_rate);
 190 }
 191
 192 bool
 193 Volkslogger::WaitForACK(Port &port, OperationEnvironment &env)
 194 {
 195   return port.WaitForChar(ACK, env, 30000) == Port::WaitResult::READY;
 196 }
 197
 198 int
 199 Volkslogger::ReadBulk(Port &port, OperationEnvironment &env,
 200                       void *buffer, size_t max_length,
 201                       unsigned timeout_firstchar_ms)
 202 {
 203   unsigned nbytes = 0;
 204   bool dle_r = false;
 205   uint16_t crc16 = 0;
 206   bool start = false, ende = false;
 207
 208   memset(buffer, 0xff, max_length);
 209
 210   uint8_t *p = (uint8_t *)buffer;
 211
 212   constexpr unsigned TIMEOUT_NORMAL_MS = 2000;
 213   /**
 214    * We need to wait longer for the first char to
 215    * give the logger time to calculate security
 216    * when downloading a log-file.
 217    * Therefore timeout_firstchar is configurable.
 218    * If the timeout parameter is not specified or 0,
 219    * set standard timeout
 220    */
 221   if (timeout_firstchar_ms == 0)
 222     timeout_firstchar_ms = TIMEOUT_NORMAL_MS;
 223
 224   while (!ende) {
 225     // Zeichen anfordern und darauf warten
 226
 227     if (!port.Write(ACK))
 228       return -1;
 229
 230     // Set longer timeout on first char
 231     unsigned timeout = start ? TIMEOUT_NORMAL_MS : timeout_firstchar_ms;
 232     if (port.WaitRead(env, timeout) != Port::WaitResult::READY)
 233       return -1;
 234
 235     int ch = port.GetChar();
 236     if (ch < 0)
 237       return -1;
 238
 239     // dabei ist Benutzerabbruch jederzeit möglich
 240     if (env.IsCancelled()) {
 241       env.Sleep(10);
 242       port.Write(CAN);
 243       port.Write(CAN);
 244       port.Write(CAN);
 245       return -1;
 246     }
 247
 248     // oder aber das empfangene Zeichen wird ausgewertet
 249     switch (ch) {
 250     case DLE:
 251       if (!dle_r) {             //!DLE, DLE -> Achtung!
 252         dle_r = true;
 253       }
 254       else {                     // DLE, DLE -> DLE-Zeichen
 255         dle_r = false;
 256         if (start) {
 257           if(nbytes < max_length)
 258             *p++ = ch;
 259           nbytes++;
 260           crc16 = UpdateCRC16CCITT(ch, crc16);
 261         }
 262       }
 263       break;
 264     case ETX:
 265       if (!dle_r) {             //!DLE, ETX -> Zeichen
 266         if (start) {
 267           if(nbytes < max_length) {
 268             *p++ = ch;
 269           }
 270           nbytes++;
 271           crc16 = UpdateCRC16CCITT(ch, crc16);
 272         };
 273       }
 274       else {
 275         if (start) {
 276           ende = true; // DLE, ETX -> Blockende
 277           dle_r = false;
 278         }
 279       }
 280       break;
 281     case STX:
 282       if (!dle_r) { //!DLE, STX -> Zeichen
 283         if (start) {
 284           if(nbytes < max_length)
 285             *p++ = ch;
 286           nbytes++;
 287           crc16 = UpdateCRC16CCITT(ch, crc16);
 288         }
 289       }
 290       else {
 291         start = true; // DLE, STX -> Blockstart
 292         dle_r = false;
 293         crc16 = 0;
 294       }
 295       break;
 296     default:
 297       if (start) {
 298         if(nbytes < max_length)
 299           *p++ = ch;
 300         nbytes++;
 301         crc16 = UpdateCRC16CCITT(ch, crc16);
 302       }
 303       break;
 304     }
 305   }
 306
 307   env.Sleep(100);
 308
 309   if (crc16 != 0)
 310     return -1;
 311
 312   if (nbytes < 2)
 313     return 0;
 314
 315   // CRC am Ende abschneiden
 316   return nbytes - 2;
 317 }
 318
 319 bool
 320 Volkslogger::WriteBulk(Port &port, OperationEnvironment &env,
 321                        const void *buffer, unsigned length)
 322 {
 323   const unsigned delay = 1;
 324
 325   env.SetProgressRange(length);
 326
 327   uint16_t crc16 = 0;
 328   const uint8_t *p = (const uint8_t *)buffer, *end = p + length;
 329   while (p < end) {
 330     unsigned n = end - p;
 331     if (n > 400)
 332       n = 400;
 333
 334     n = port.Write(p, n);
 335     if (n == 0)
 336       return false;
 337
 338     crc16 = UpdateCRC16CCITT(p, n, crc16);
 339     p += n;
 340
 341     env.SetProgressPosition(p - (const uint8_t *)buffer);
 342
 343     /* throttle sending a bit, or the Volkslogger's receive buffer
 344        will overrun */
 345     env.Sleep(delay * 100);
 346   }
 347
 348   return port.Write(crc16 >> 8) && port.Write(crc16 & 0xff);
 349 }
 350
 351 int
 352 Volkslogger::SendCommandReadBulk(Port &port, OperationEnvironment &env,
 353                                  Command cmd,
 354                                  void *buffer, size_t max_length,
 355                                  const unsigned timeout_firstchar_ms)
 356 {
 357   return SendCommand(port, env, cmd)
 358     ? ReadBulk(port, env, buffer, max_length, timeout_firstchar_ms)
 359     : -1;
 360 }
 361
 362 int
 363 Volkslogger::SendCommandReadBulk(Port &port, unsigned baud_rate,
 364                                  OperationEnvironment &env,
 365                                  Command cmd, uint8_t param1,
 366                                  void *buffer, size_t max_length,
 367                                  const unsigned timeout_firstchar_ms)
 368 {
 369   unsigned old_baud_rate = port.GetBaudrate();
 370
 371   if (old_baud_rate != 0) {
 372     if (!SendCommandSwitchBaudRate(port, env, cmd, param1, baud_rate))
 373       return -1;
 374
 375     /* after switching baud rates, this sleep time is necessary; it has
 376        been verified experimentally */
 377     env.Sleep(300);
 378   } else {
 379     /* port does not support baud rate switching, use plain
 380        SendCommand() without new baud rate */
 381
 382     if (!SendCommand(port, env, cmd, param1))
 383       return -1;
 384   }
 385
 386   int nbytes = ReadBulk(port, env, buffer, max_length, timeout_firstchar_ms);
 387
 388   if (old_baud_rate != 0)
 389     port.SetBaudrate(old_baud_rate);
 390
 391   return nbytes;
 392 }
 393
 394 bool
 395 Volkslogger::SendCommandWriteBulk(Port &port, OperationEnvironment &env,
 396                                   Command cmd,
 397                                   const void *data, size_t size)
 398 {
 399   if (!SendCommand(port, env, cmd, 0, 0) || !WaitForACK(port, env))
 400     return false;
 401
 402   env.Sleep(100);
 403
 404   return WriteBulk(port, env, data, size) && WaitForACK(port, env);
 405 }
 406
 407 size_t
 408 Volkslogger::ReadFlight(Port &port, unsigned databaud,
 409                         OperationEnvironment &env,
 410                         unsigned flightnr, bool secmode,
 411                         void *buffer, size_t buffersize)
 412 {
 413   const Volkslogger::Command cmd = secmode
 414     ? Volkslogger::cmd_GFS
 415     : Volkslogger::cmd_GFL;
 416
 417   /*
 418    * It is necessary to wait long for the first reply from
 419    * the Logger in ReadBulk.
 420    * Since the VL needs time to calculate the Security of
 421    * the log before it responds.
 422    */
 423   const unsigned timeout_firstchar_ms = 300000;
 424
 425   // Download binary log data supports BulkBaudrate
 426   int groesse = SendCommandReadBulk(port, databaud, env, cmd,
 427                                     flightnr, buffer, buffersize,
 428                                     timeout_firstchar_ms);
 429   if (groesse <= 0)
 430     return 0;
 431
 432   // read signature
 433   env.Sleep(300);
 434
 435   /*
 436    * Testing has shown that downloading the Signature does not support
 437    * BulkRate. It has to be done with standard IO Rate (9600)
 438    */
 439   int sgr = SendCommandReadBulk(port, env, Volkslogger::cmd_SIG,
 440                                 (uint8_t *)buffer + groesse,
 441                                 buffersize - groesse);
 442   if (sgr <= 0)
 443     return 0;
 444
 445   return groesse + sgr;
 446 }