test/src/RunLX1600Utils.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 "DebugPort.hpp"
  25 #include "Device/Port/Port.hpp"
  26 #include "Device/Port/ConfiguredPort.hpp"
  27 #include "Device/Driver.hpp"
  28 #include "Device/Register.hpp"
  29 #include "Device/Parser.hpp"
  30 #include "Device/Driver/LX/LX1600.hpp"
  31 #include "OS/PathName.hpp"
  32 #include "OS/Args.hpp"
  33 #include "Profile/DeviceConfig.hpp"
  34 #include "Util/StringUtil.hpp"
  35 #include "Operation/ConsoleOperationEnvironment.hpp"
  36 #include "IO/Async/GlobalIOThread.hpp"
  37 #include "Units/System.hpp"
  38 #include "Atmosphere/Pressure.hpp"
  39 #include "IO/DataHandler.hpp"
  40
  41 #include <memory>
  42
  43 #include <stdio.h>
  44
  45 static bool
  46 ReadFixed(fixed &value)
  47 {
  48   char buffer[64];
  49   if (fgets(buffer, 64, stdin) == NULL || strlen(buffer) == 0)
  50     return false;
  51
  52   char *end_ptr;
  53   value = fixed(strtod(buffer, &end_ptr));
  54   return end_ptr != buffer;
  55 }
  56
  57 static bool
  58 ReadUnsigned(unsigned &value)
  59 {
  60   char buffer[64];
  61   if (fgets(buffer, 64, stdin) == NULL || strlen(buffer) == 0)
  62     return false;
  63
  64   char *end_ptr;
  65   value = strtoul(buffer, &end_ptr, 10);
  66   return end_ptr != buffer;
  67 }
  68
  69 static void
  70 PrintInputRequest(const char *setting)
  71 {
  72   fprintf(stdout, "Please enter %s:\n", setting);
  73   fprintf(stdout, "> ");
  74 }
  75
  76 static bool
  77 ReadFixed(const char *setting, fixed &value)
  78 {
  79   PrintInputRequest(setting);
  80   if (ReadFixed(value))
  81     return true;
  82
  83   fprintf(stdout, "Invalid input\n");
  84   return false;
  85 }
  86
  87 static bool
  88 ReadUnsigned(const char *setting, unsigned &value)
  89 {
  90   PrintInputRequest(setting);
  91   if (ReadUnsigned(value))
  92     return true;
  93
  94   fprintf(stdout, "Invalid input\n");
  95   return false;
  96 }
  97
  98 static void
  99 SetMC(Port &port, OperationEnvironment &env)
 100 {
 101   fixed mc;
 102   if (!ReadFixed("the MC setting (0.0 - 5.0)", mc))
 103     return;
 104
 105   fprintf(stdout, "Setting MC to \"%.1f\" ...\n", (double)mc);
 106
 107   if (LX1600::SetMacCready(port, env, mc))
 108     fprintf(stdout, "MC set to \"%.1f\"\n", (double)mc);
 109   else
 110     fprintf(stdout, "Operation failed!\n");
 111 }
 112
 113 static void
 114 SetBallast(Port &port, OperationEnvironment &env)
 115 {
 116   fixed ballast;
 117   if (!ReadFixed("the Ballast setting (1.0 - 1.5)", ballast))
 118     return;
 119
 120   fprintf(stdout, "Setting Ballast to \"%.1f\" ...\n", (double)ballast);
 121
 122   if (LX1600::SetBallast(port, env, ballast))
 123     fprintf(stdout, "Ballast set to \"%.1f\"\n", (double)ballast);
 124   else
 125     fprintf(stdout, "Operation failed!\n");
 126 }
 127
 128 static void
 129 SetBugs(Port &port, OperationEnvironment &env)
 130 {
 131   unsigned bugs;
 132   if (!ReadUnsigned("the Bugs setting (0 - 30%)", bugs))
 133     return;
 134
 135   fprintf(stdout, "Setting Bugs to \"%u\" ...\n", bugs);
 136
 137   if (LX1600::SetBugs(port, env, bugs))
 138     fprintf(stdout, "Bugs set to \"%u\"\n", bugs);
 139   else
 140     fprintf(stdout, "Operation failed!\n");
 141 }
 142
 143 static void
 144 SetAltitudeOffset(Port &port, OperationEnvironment &env)
 145 {
 146   fixed altitude_offset;
 147   if (!ReadFixed("the altitude offset setting (m)", altitude_offset))
 148     return;
 149
 150   fprintf(stdout, "Setting altitude offset to \"%.1f m\" ...\n",
 151           (double)altitude_offset);
 152
 153   if (LX1600::SetAltitudeOffset(port, env, Units::ToUserUnit(altitude_offset, Unit::FEET)))
 154     fprintf(stdout, "Altitude offset set to \"%.1f m\"\n",
 155             (double)altitude_offset);
 156   else
 157     fprintf(stdout, "Operation failed!\n");
 158 }
 159
 160 static void
 161 SetQNH(Port &port, OperationEnvironment &env)
 162 {
 163   fixed qnh;
 164   if (!ReadFixed("the QNH setting (hPa)", qnh))
 165     return;
 166
 167   fprintf(stdout, "Setting QNH to \"%.1f hPa\" ...\n",
 168           (double)qnh);
 169
 170   if (LX1600::SetQNH(port, env, AtmosphericPressure::HectoPascal(qnh)))
 171     fprintf(stdout, "QNH set to \"%.1f hPa\"\n",
 172             (double)qnh);
 173   else
 174     fprintf(stdout, "Operation failed!\n");
 175 }
 176
 177 static void
 178 SetVolume(Port &port, OperationEnvironment &env)
 179 {
 180   unsigned volume;
 181   if (!ReadUnsigned("the Volume setting (0 - 100%)", volume))
 182     return;
 183
 184   fprintf(stdout, "Setting Volume to \"%u %%\" ...\n", volume);
 185
 186   if (LX1600::SetVolume(port, env, volume))
 187     fprintf(stdout, "Volume set to \"%u %%\"\n", volume);
 188   else
 189     fprintf(stdout, "Operation failed!\n");
 190 }
 191
 192 static void
 193 SetPolar(Port &port, OperationEnvironment &env)
 194 {
 195   fixed a, b, c;
 196   if (!ReadFixed("polar coefficient a", a) ||
 197       !ReadFixed("polar coefficient b", b) ||
 198       !ReadFixed("polar coefficient c", c))
 199     return;
 200
 201   if (LX1600::SetPolar(port, env, a, b, c))
 202     fprintf(stdout, "Polar coefficients set to \"%.2f, %.2f, %.2f\"\n",
 203             (double)a, (double)b, (double)c);
 204   else
 205     fprintf(stdout, "Operation failed!\n");
 206 }
 207
 208 static void
 209 SetFilters(Port &port, OperationEnvironment &env)
 210 {
 211   fixed vario_filter, te_filter;
 212   unsigned te_level;
 213   if (!ReadFixed("the Vario filter (sec, default = 1)", vario_filter) ||
 214       !ReadFixed("the TE filter (0.1 - 2.0, default = 1.5)", te_filter) ||
 215       !ReadUnsigned("the TE level (50 - 150 %, default = 0 = off)", te_level))
 216     return;
 217
 218   if (LX1600::SetFilters(port, env, vario_filter, te_filter, te_level))
 219     fprintf(stdout, "Filters set to \"%.1f, %.1f, %u\"\n",
 220             (double)vario_filter, (double)te_filter, te_level);
 221   else
 222     fprintf(stdout, "Operation failed!\n");
 223 }
 224
 225 static void
 226 SetSCSettings(Port &port, OperationEnvironment &env)
 227 {
 228   unsigned mode, control_mode;
 229   fixed deadband, threshold_speed;
 230
 231   if (!ReadUnsigned("the SC Mode (EXTERNAL = 0, default = ON_CIRCLING = 1, AUTO_IAS = 2)", mode) ||
 232       !ReadFixed("the SC deadband (0 - 10.0 m/s, default=1)", deadband) ||
 233       !ReadUnsigned("the SC switch mode (NORMAL = 0, default = INVERTED = 1, TASTER = 2)", control_mode))
 234     return;
 235
 236   if (mode != 2u)
 237     threshold_speed = fixed(0);
 238   else if (!ReadFixed("the SC threshold speed (50 - 150 km/h, default=110)", threshold_speed))
 239     return;
 240
 241   if (LX1600::SetSCSettings(port, env, (LX1600::SCMode)mode, deadband,
 242                             (LX1600::SCControlMode)control_mode, threshold_speed))
 243     fprintf(stdout, "SC settings changed!\n");
 244   else
 245     fprintf(stdout, "Operation failed!\n");
 246 }
 247
 248 static void
 249 WriteMenu()
 250 {
 251   fprintf(stdout, "------------------------------------\n"
 252                   "LX1600 Utils Menu\n"
 253                   "------------------------------------\n"
 254                   "Press any of the following commands:\n\n"
 255                   "h:  Display this menu\n"
 256                   "1:  Set the MC\n"
 257                   "2:  Set Ballast\n"
 258                   "3:  Set Bugs\n"
 259                   "4:  Set Altitude Offset\n"
 260                   "5:  Set QNH\n"
 261                   "6:  Set Volume\n"
 262                   "p:  Set polar coefficients\n"
 263                   "f:  Set filter settings\n"
 264                   "s:  Set speed control settings\n"
 265                   "q:  Quit this application\n"
 266                   "------------------------------------\n");
 267 }
 268
 269 static void
 270 RunUI(Port &port, OperationEnvironment &env)
 271 {
 272   WriteMenu();
 273
 274   while (true) {
 275     fprintf(stdout, "> ");
 276
 277     char in[20];
 278     if (fgets(in, 20, stdin) == NULL || strlen(in) == 0) {
 279       fprintf(stdout, "Invalid input\n");
 280       continue;
 281     }
 282
 283     switch (in[0]) {
 284     case '?':
 285     case 'h':
 286     case 'H':
 287       WriteMenu();
 288       break;
 289     case '1':
 290       SetMC(port, env);
 291       break;
 292     case '2':
 293       SetBallast(port, env);
 294       break;
 295     case '3':
 296       SetBugs(port, env);
 297       break;
 298     case '4':
 299       SetAltitudeOffset(port, env);
 300       break;
 301     case '5':
 302       SetQNH(port, env);
 303       break;
 304     case '6':
 305       SetVolume(port, env);
 306       break;
 307     case 'p':
 308     case 'P':
 309       SetPolar(port, env);
 310       break;
 311     case 'f':
 312     case 'F':
 313       SetFilters(port, env);
 314       break;
 315     case 's':
 316     case 'S':
 317       SetSCSettings(port, env);
 318       break;
 319     case 'q':
 320     case 'Q':
 321       fprintf(stdout, "Closing LX1600 Utils ...\n");
 322       return;
 323     default:
 324       fprintf(stdout, "Invalid input\n");
 325       break;
 326     }
 327   }
 328 }
 329
 330 class NullDataHandler : public DataHandler {
 331 public:
 332   virtual void DataReceived(const void *data, size_t length) {}
 333 };
 334
 335 int
 336 main(int argc, char **argv)
 337 {
 338   Args args(argc, argv, "PORT BAUD");
 339   const DeviceConfig config = ParsePortArgs(args);
 340   args.ExpectEnd();
 341
 342   InitialiseIOThread();
 343
 344   NullDataHandler handler;
 345   std::unique_ptr<Port> port(OpenPort(config, handler));
 346   if (!port) {
 347     fprintf(stderr, "Failed to open COM port\n");
 348     return EXIT_FAILURE;
 349   }
 350
 351   ConsoleOperationEnvironment env;
 352   RunUI(*port, env);
 353
 354   DeinitialiseIOThread();
 355
 356   return EXIT_SUCCESS;
 357 }