src/convert.cc

   1 /**
   2  * Copyright (C) 2012  TOYOTA MOTOR CORPORATION.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  */
  19 #include <string.h>
  20
  21 #include <algorithm>
  22 #include <sstream>
  23
  24 #include "debugout.h"
  25
  26 #include "ambinterface.h"
  27 #include "convert.h"
  28 #include "mwinterface.h"
  29
  30 Converter::Converter()
  31 {
  32     specialconvertlist.push_back(VehicleProperty::TransmissionShiftPosition);
  33     specialconvertlist.push_back(VehicleProperty::TransmissionGearPosition);
  34     specialconvertlist.push_back(VehicleProperty::TransmissionMode);
  35     specialconvertlist.push_back(VehicleProperty::TurnSignal);
  36     specialconvertlist.push_back(VehicleProperty::ButtonEvent);
  37 }
  38
  39 Converter::~Converter()
  40 {
  41     converttablelist.clear();
  42 }
  43
  44 bool
  45 Converter::initialize(AMBConfig *conf)
  46 {
  47     vector<VehicleInfoDefine> dtableArray;
  48     dtableArray = conf->getVehicleInfoConfig();
  49     for (auto itr = dtableArray.begin(), itr_end = dtableArray.end(); itr != itr_end; itr++) {
  50         ConvertTable ctable;
  51         ctable.mwname = string((*itr).KeyEventType);
  52         DebugOut(10) << "Converter initialize mwname = " << ctable.mwname << "\n";
  53         for (auto itr2 = (*itr).status.begin(); itr2 != (*itr).status.end();
  54              itr2++) {
  55             ConvertTable::AmbVehicleInfoData ambdata;
  56             ambdata.ambname = (*itr2).ambPropertyName;
  57             DebugOut(10) << "Converter initialize ambname = " << ambdata.ambname
  58                        << "\n";
  59             ambdata.type = (*itr2).type;
  60             ambdata.typesize = (*itr2).typesize;
  61             ambdata.zone = (*itr2).zone;
  62             ctable.ambdataarray.push_back(ambdata);
  63         }
  64         converttablelist.push_back(ctable);
  65     }
  66     DebugOut(1) << "INFO CHG_VIC_INF ConvertTable size is " << converttablelist.size() << ".\n";
  67     return true;
  68 }
  69
  70 int
  71 Converter::convertMWtoAMB(MWVehicleInfo *mwvehicleinfo,
  72                           AMBVehicleInfo *ambvehicleinfo, int arraysize)
  73 {
  74     int ret = 0;
  75     ConvertTable ct;
  76     ct.mwname = mwvehicleinfo->name;
  77     auto itr = std::find(converttablelist.begin(), converttablelist.end(), ct);
  78     if (itr == converttablelist.end()) {
  79         return ret;
  80     }
  81     int arrayidx = 0;
  82     int statusidx = 0;
  83     for (auto itr2 = (*itr).ambdataarray.begin();
  84          itr2 != (*itr).ambdataarray.end(); itr2++) {
  85         ambvehicleinfo[arrayidx].name = (*itr2).ambname;
  86         DebugOut(8) << "getPropertyTypeForPropertyNameValue Start\n";
  87         ambvehicleinfo[arrayidx].value =
  88                 VehicleProperty::getPropertyTypeForPropertyNameValue(
  89                         ambvehicleinfo[arrayidx].name, "0");
  90         DebugOut(8) << "getPropertyTypeForPropertyNameValue End\n";
  91         if (ambvehicleinfo[arrayidx].value == NULL) {
  92             continue;
  93         }
  94         ambvehicleinfo[arrayidx].value->timestamp = toDouble(
  95                 mwvehicleinfo->recordtime);
  96         char statusbuf[(*itr2).typesize];
  97         memcpy(statusbuf, mwvehicleinfo->status + statusidx,
  98                sizeof(statusbuf));
  99         DebugOut(8) << "fromString, toSting Start\n";
 100         ambvehicleinfo[arrayidx].value->fromString(
 101                 toString((*itr2).ambname, statusbuf, sizeof(statusbuf),
 102                          (*itr2).type));
 103         DebugOut(8) << "fromString, toSting End\n";
 104         statusidx += sizeof(statusbuf);
 105         DebugOut(8) << "Converter convertMWtoAMB ambname = "
 106                    << (*itr2).ambname << "("
 107                    << ambvehicleinfo[arrayidx].value->toString() << ")\n";
 108         ambvehicleinfo[arrayidx].zone = (*itr2).zone;
 109         arrayidx++;
 110         if (arrayidx == arraysize
 111                 && arraysize
 112                         < static_cast<int>((*itr).ambdataarray.size())) {
 113             ret = -1;
 114             break;
 115         }
 116         ret = arrayidx;
 117     }
 118     return ret;
 119 }
 120
 121 int
 122 Converter::convertAMBtoMW(AMBVehicleInfo *ambvehicleinfo,
 123                           MWVehicleInfo *mwvehicleinfo)
 124 {
 125     int ret = 0;
 126     int statusidx = 0;
 127     for (auto itr = converttablelist.begin(); itr != converttablelist.end();
 128             itr++) {
 129         statusidx = 0;
 130         DebugOut(10) << "Converter convertAMBtoMW mwname = " << (*itr).mwname
 131                      << "\n";
 132         for (auto itr2 = (*itr).ambdataarray.begin();
 133              itr2 != (*itr).ambdataarray.end(); itr2++) {
 134             DebugOut(10) << "Converter convertAMBtoMW ambname = "
 135                          << (*itr2).ambname << "\n";
 136             if ((*itr2).ambname == ambvehicleinfo->name) {
 137                 DebugOut(10) << "Converter convertAMBtoMW ambname = "
 138                            << (*itr2).ambname << "\n";
 139                 mwvehicleinfo->name = (*itr).mwname;
 140                 mwvehicleinfo->recordtime = toTimeval(
 141                         ambvehicleinfo->value->timestamp);
 142                 if (ambvehicleinfo->value == NULL) {
 143                     DebugOut(10) << "Converter convertAMBtoMW "
 144                                << "ambvehicleinfo->value is NULL\n";
 145                     ret = -1;
 146                 }
 147                 else {
 148                     DebugOut(10) << "Converter check data "
 149                                << ambvehicleinfo->value->toString() << std::endl;
 150                     toBinary(ambvehicleinfo->name, ambvehicleinfo->value,
 151                              (*itr2).typesize, (*itr2).type,
 152                              mwvehicleinfo->status + statusidx);
 153                     ret = 1;
 154                 }
 155                 return ret;
 156             }
 157             statusidx += (*itr2).typesize;
 158         }
 159     }
 160     return ret;
 161 }
 162
 163 string
 164 Converter::toString(string ambname, char *data, int size, DataType type)
 165 {
 166     if (find(specialconvertlist.begin(), specialconvertlist.end(), ambname)
 167             != specialconvertlist.end()) {
 168         return specialConvertMWtoAMB(ambname, data, size, type);
 169     }
 170     stringstream sstr;
 171     sstr.str("");
 172     sstr.precision(10);
 173     switch (type) {
 174     case INT:
 175     {
 176         int val;
 177         memcpy(&val, data, size);
 178         sstr << val;
 179         break;
 180     }
 181     case DOUBLE:
 182     {
 183         double val;
 184         memcpy(&val, data, size);
 185         sstr << val;
 186         break;
 187     }
 188     case CHAR:
 189     {
 190         char val;
 191         memcpy(&val, data, size);
 192         sstr << val;
 193         break;
 194     }
 195     case INT16:
 196     {
 197         int16_t val;
 198         memcpy(&val, data, size);
 199         sstr << val;
 200         break;
 201     }
 202     case UINT16:
 203     {
 204         uint16_t val;
 205         memcpy(&val, data, size);
 206         sstr << val;
 207         break;
 208     }
 209     case UINT32:
 210     {
 211         uint32_t val;
 212         memcpy(&val, data, size);
 213         sstr << val;
 214         break;
 215     }
 216     case INT64:
 217     {
 218         int64_t val;
 219         memcpy(&val, data, size);
 220         sstr << val;
 221         break;
 222     }
 223     case UINT64:
 224     {
 225         uint64_t val;
 226         memcpy(&val, data, size);
 227         sstr << val;
 228         break;
 229     }
 230     case BOOL:
 231     {
 232         bool val;
 233         memcpy(&val, data, size);
 234         DebugOut(10) << "ToString(BOOL): Receive data(size = " << size << ")  is " << data << " ->(convert this function)(size = " << sizeof(bool) <<  ") " << val << "\n";
 235         if (val) {
 236             sstr << "true";
 237         }
 238         else {
 239             sstr << "false";
 240         }
 241         //sstr << val;
 242         break;
 243     }
 244     default:
 245     {
 246         break;
 247     }
 248     }
 249     return sstr.str();
 250 }
 251
 252 int
 253 Converter::toBinary(string ambname, AbstractPropertyType *value, int size,
 254                     DataType type, char *buf)
 255 {
 256     stringstream sstr;
 257     sstr.str("");
 258     if (find(specialconvertlist.begin(), specialconvertlist.end(), ambname)
 259             != specialconvertlist.end()) {
 260         sstr << specialConvertAMBtoMW(ambname, value);
 261     }
 262     else {
 263         sstr << value->toString();
 264     }
 265     DebugOut(10) << "Converter toBinary " << sstr.str() << "\n";
 266     switch (type) {
 267     case INT:
 268     {
 269         int val;
 270         sstr >> val;
 271         memcpy(buf, &val, size);
 272         DebugOut(10) << "Converter toBinary<int> " << val << "\n";
 273         break;
 274     }
 275     case DOUBLE:
 276     {
 277         double val;
 278         sstr >> val;
 279         memcpy(buf, &val, size);
 280         DebugOut(10) << "Converter toBinary<double> " << val << "\n";
 281         break;
 282     }
 283     case CHAR:
 284     {
 285         char val;
 286         sstr >> val;
 287         memcpy(buf, &val, size);
 288         DebugOut(10) << "Converter toBinary<char> " << val << "\n";
 289         break;
 290     }
 291     case INT16:
 292     {
 293         int16_t val;
 294         sstr >> val;
 295         memcpy(buf, &val, size);
 296         DebugOut(10) << "Converter toBinary<int16_t> " << val << "\n";
 297         break;
 298     }
 299     case UINT16:
 300     {
 301         uint16_t val;
 302         sstr >> val;
 303         memcpy(buf, &val, size);
 304         DebugOut(10) << "Converter toBinary<uint16_t> " << val << "\n";
 305         break;
 306     }
 307     case UINT32:
 308     {
 309         uint32_t val;
 310         sstr >> val;
 311         memcpy(buf, &val, size);
 312         DebugOut(10) << "Converter toBinary<uint32_t> " << val << "\n";
 313         break;
 314     }
 315     case INT64:
 316     {
 317         int64_t val;
 318         sstr >> val;
 319         memcpy(buf, &val, size);
 320         DebugOut(10) << "Converter toBinary<int64_t> " << val << "\n";
 321         break;
 322     }
 323     case UINT64:
 324     {
 325         uint64_t val;
 326         sstr >> val;
 327         memcpy(buf, &val, size);
 328         DebugOut(10) << "Converter toBinary<uint64_t> " << val << "\n";
 329         break;
 330     }
 331     case BOOL:
 332     {
 333         int tmpval;
 334         bool val;
 335         sstr >> tmpval;
 336         if (tmpval > 0) {
 337             val = true;
 338         }
 339         else {
 340             val = false;
 341         }
 342         memcpy(buf, &val, sizeof(bool));
 343         DebugOut(10) << "Converter toBinary<bool> " << val << "\n";
 344         break;
 345     }
 346     default:
 347     {
 348         size = 0;
 349         break;
 350     }
 351     }
 352     return size;
 353 }
 354
 355 double
 356 Converter::toDouble(timeval time)
 357 {
 358     return static_cast<double>(time.tv_sec + (time.tv_usec * (1.0 / 1000000)));
 359 }
 360
 361 timeval
 362 Converter::toTimeval(double time)
 363 {
 364     timeval tv;
 365     tv.tv_sec = time;
 366     double utime = time - tv.tv_sec;
 367     tv.tv_usec = utime * 1000000;
 368     return tv;
 369 }
 370
 371 std::string
 372 Converter::specialConvertAMBtoMW(std::string ambname,
 373                                  AbstractPropertyType *value)
 374 {
 375     stringstream retstr;
 376     retstr.str("");
 377     if (ambname == VehicleProperty::TransmissionShiftPosition) {
 378         switch (boost::any_cast < Transmission::TransmissionPositions
 379                 > (value->anyValue())) {
 380         case Transmission::Neutral:
 381         {
 382             retstr << 2;
 383             break;
 384         }
 385         case Transmission::First:
 386         {
 387             retstr << 5;
 388             break;
 389         }
 390         case Transmission::Second:
 391         {
 392             retstr << 6;
 393             break;
 394         }
 395         case Transmission::Third:
 396         {
 397             retstr << 7;
 398             break;
 399         }
 400         case Transmission::Forth:
 401         {
 402             retstr << 8;
 403             break;
 404         }
 405         case Transmission::Fifth:
 406         {
 407             retstr << 9;
 408             break;
 409         }
 410         case Transmission::Sixth:
 411         {
 412             retstr << 10;
 413             break;
 414         }
 415         case Transmission::Seventh:
 416         {
 417             retstr << 11;
 418             break;
 419         }
 420         case Transmission::Eighth:
 421         {
 422             retstr << 12;
 423             break;
 424         }
 425         case Transmission::Ninth:
 426         {
 427             retstr << 13;
 428             break;
 429         }
 430         case Transmission::Tenth:
 431         {
 432             retstr << 14;
 433             break;
 434         }
 435         case Transmission::CVT:
 436         {
 437             retstr << 15;
 438             break;
 439         }
 440         case Transmission::Drive:
 441         {
 442             retstr << 4;
 443             break;
 444         }
 445         case Transmission::Reverse:
 446         {
 447             retstr << 1;
 448             break;
 449         }
 450         case Transmission::Park:
 451         {
 452             retstr << 0;
 453             break;
 454         }
 455         }
 456         DebugOut(10) << "Converter specialConvertAMBtoMW"
 457                    << "(TransmissionShiftPosition): " << value->toString() << "->"
 458                    << retstr.str() << std::endl;
 459     }
 460     else if (ambname == VehicleProperty::TransmissionGearPosition) {
 461         switch (boost::any_cast < Transmission::TransmissionPositions
 462                 > (value->anyValue())) {
 463         case Transmission::Neutral:
 464         {
 465             retstr << 64;
 466             break;
 467         }
 468         case Transmission::First:
 469         case Transmission::Second:
 470         case Transmission::Third:
 471         case Transmission::Forth:
 472         case Transmission::Fifth:
 473         case Transmission::Sixth:
 474         case Transmission::Seventh:
 475         case Transmission::Eighth:
 476         case Transmission::Ninth:
 477         case Transmission::Tenth:
 478         {
 479             retstr << value->toString();
 480             break;
 481         }
 482         case Transmission::CVT:
 483         {
 484             retstr << 256;
 485             break;
 486         }
 487         case Transmission::Drive:
 488         {
 489             retstr << 0;
 490             break;
 491         }
 492         case Transmission::Reverse:
 493         {
 494             retstr << 128;
 495             break;
 496         }
 497         case Transmission::Park:
 498         {
 499             retstr << 0;
 500             break;
 501         }
 502         default:
 503         {
 504             retstr << 172;
 505             break;
 506         }
 507         }
 508         DebugOut(10) << "Converter specialConvertAMBtoMW"
 509                    << "(TransmissionGearPosition): " << value->toString() << "->"
 510                    << retstr.str() << std::endl;
 511     }
 512     else if (ambname == VehicleProperty::TransmissionMode) {
 513         retstr << value->toString();
 514     }
 515     else if (ambname == VehicleProperty::TurnSignal) {
 516         retstr << value->toString();
 517     }
 518     else if (ambname == VehicleProperty::ButtonEvent) {
 519         /* ToDo */
 520     }
 521     return retstr.str();
 522 }
 523
 524 std::string
 525 Converter::specialConvertMWtoAMB(std::string ambname, char *data, int size,
 526                                  DataType type)
 527 {
 528     stringstream retstr;
 529     retstr.str("");
 530     if (ambname == VehicleProperty::TransmissionShiftPosition) {
 531         int val;
 532         memcpy(&val, data, size);
 533         switch (val) {
 534         case 0:
 535         {
 536             retstr << Transmission::Park;
 537             break;
 538         }
 539         case 1:
 540         {
 541             retstr << Transmission::Reverse;
 542             break;
 543         }
 544         case 2:
 545         {
 546             retstr << Transmission::Neutral;
 547             break;
 548         }
 549         case 4:
 550         {
 551             retstr << Transmission::Drive;
 552             break;
 553         }
 554         case 5:
 555         {
 556             retstr << Transmission::First;
 557             break;
 558         }
 559         case 6:
 560         {
 561             retstr << Transmission::Second;
 562             break;
 563         }
 564         case 7:
 565         {
 566             retstr << Transmission::Third;
 567             break;
 568         }
 569         case 8:
 570         {
 571             retstr << Transmission::Forth;
 572             break;
 573         }
 574         case 9:
 575         {
 576             retstr << Transmission::Fifth;
 577             break;
 578         }
 579         case 10:
 580         {
 581             retstr << Transmission::Sixth;
 582             break;
 583         }
 584         case 11:
 585         {
 586             retstr << Transmission::Seventh;
 587             break;
 588         }
 589         case 12:
 590         {
 591             retstr << Transmission::Eighth;
 592             break;
 593         }
 594         case 13:
 595         {
 596             retstr << Transmission::Ninth;
 597             break;
 598         }
 599         case 14:
 600         {
 601             retstr << Transmission::Tenth;
 602             break;
 603         }
 604         case 15:
 605         {
 606             retstr << Transmission::CVT;
 607             break;
 608         }
 609         default:
 610         {
 611             break;
 612         }
 613         }
 614         DebugOut(10) << "Converter specialConvertMWtoAMB"
 615                    << "(TransmissionShiftPosition): " << val << "->"
 616                    << retstr.str() << std::endl;
 617     }
 618     else if (ambname == VehicleProperty::TransmissionGearPosition) {
 619         int val;
 620         memcpy(&val, data, size);
 621         switch (val) {
 622         case 1:
 623         case 2:
 624         case 3:
 625         case 4:
 626         case 5:
 627         case 6:
 628         case 7:
 629         case 8:
 630         case 9:
 631         case 10:
 632         {
 633             retstr << val;
 634             break;
 635         }
 636         case 64:
 637         {
 638             retstr << Transmission::Neutral;
 639             break;
 640         }
 641         case 128:
 642         {
 643             retstr << Transmission::Reverse;
 644             break;
 645         }
 646         case 256:
 647         {
 648             retstr << Transmission::CVT;
 649             break;
 650         }
 651         default:
 652         {
 653             retstr << 0;
 654             break;
 655         }
 656         }
 657         DebugOut(10) << "Converter specialConvertMWtoAMB"
 658                    << "(TransmissionGearPosition): " << val << "->" << retstr.str()
 659                    << std::endl;
 660     }
 661     else if (ambname == VehicleProperty::TransmissionMode) {
 662         int val;
 663         memcpy(&val, data, size);
 664         retstr << val;
 665     }
 666     else if (ambname == VehicleProperty::TurnSignal) {
 667         int val;
 668         memcpy(&val, data, size);
 669         retstr << val;
 670     }
 671     else if (ambname == VehicleProperty::ButtonEvent) {
 672         /* ToDo */
 673     }
 674     return retstr.str();
 675 }