cmake command added to build example line in README.md

dbc mux feature aded to parsing and printing tests for mux added
astand · mork2020 · Jan 30, 2023 · Feb 26, 2023 · Feb 26, 2023 · Aug 5, 2022
commit ad2411948ff01c0d6f08654ef6a1e88bf5a9fa5c
diff --git a/README.md b/README.md
@@ -26,7 +26,7 @@ cmake -S src -B build
 ```
 Run cmake build:
 ```sh
---build build --config release
+cmake --build build --config release
 ```
 Go to the build directory and run:
 ```sh

diff --git a/src/codegen/c-main-generator.cpp b/src/codegen/c-main-generator.cpp
@@ -523,11 +523,11 @@ void CiMainGenerator::WriteSigStructField(const SignalDescriptor_t& sig, bool bi
 
   if (sig.Multiplex == MultiplexType::kMulValue)
   {
-    fwriter.Append("  // multiplex variable");
+    fwriter.Append("  // multiplex variable - " + sig.MultiplexName + " - m" + std::to_string(sig.MultiplexGroup));
   }
   else if (sig.Multiplex == MultiplexType::kMaster)
   {
-    fwriter.Append("  // MULTIPLEX master signal");
+    fwriter.Append("  // multiplex master signal");
   }
 
   std::string dtype = "";
@@ -639,14 +639,23 @@ void CiMainGenerator::WriteUnpackBody(const CiExpr_t* sgs)
     // for code shortening
     const char* sname = sgs->msg.Signals[num].Name.c_str();
 
+    std::string ident = "  ";
+
+    if (sgs->msg.Signals[num].Multiplex == MultiplexType::kMulValue)
+    {
+      ident = "    ";
+      fwriter.Append("  if (_m->%s == %d)", sgs->msg.Signals[num].MultiplexName.c_str(), sgs->msg.Signals[num].MultiplexGroup);
+      fwriter.Append("  {");
+    }
+
     if (sgs->msg.Signals[num].Signed)
     {
-      fwriter.Append("  _m->%s = %s(( %s ), %d);",
-        sname, ext_sig_func_name, expr.c_str(), (int32_t)sgs->msg.Signals[num].LengthBit);
+      fwriter.Append("%s_m->%s = %s(( %s ), %d);",
+        ident.c_str(), sname, ext_sig_func_name, expr.c_str(), (int32_t)sgs->msg.Signals[num].LengthBit);
     }
     else
     {
-      fwriter.Append("  _m->%s = %s;", sname, expr.c_str());
+      fwriter.Append("%s_m->%s = %s;", ident.c_str(), sname, expr.c_str());
     }
 
     // print sigfloat conversion
@@ -657,20 +666,24 @@ void CiMainGenerator::WriteUnpackBody(const CiExpr_t* sgs)
       if (sgs->msg.Signals[num].IsDoubleSig)
       {
         // for double signals (sigfloat_t) type cast
-        fwriter.Append("  _m->%s = (sigfloat_t)(%s_%s_fromS(_m->%s));",
-          sgs->msg.Signals[num].NameFloat.c_str(), fdesc->gen.DRVNAME.c_str(), sname, sname);
+        fwriter.Append("%s_m->%s = (sigfloat_t)(%s_%s_fromS(_m->%s));",
+          ident.c_str(), sgs->msg.Signals[num].NameFloat.c_str(), fdesc->gen.DRVNAME.c_str(), sname, sname);
       }
       else
       {
-        fwriter.Append("  _m->%s = %s_%s_fromS(_m->%s);",
-          sgs->msg.Signals[num].NameFloat.c_str(), fdesc->gen.DRVNAME.c_str(), sname, sname);
+        fwriter.Append("%s_m->%s = %s_%s_fromS(_m->%s);",
+          ident.c_str(), sgs->msg.Signals[num].NameFloat.c_str(), fdesc->gen.DRVNAME.c_str(), sname, sname);
       }
 
       fwriter.Append("#endif // %s", fdesc->gen.usesigfloat_def.c_str());
-      fwriter.Append();
     }
 
-    else if (num + 1 == sgs->to_signals.size())
+    if (sgs->msg.Signals[num].Multiplex == MultiplexType::kMulValue)
+    {
+      fwriter.Append("  }");
+    }
+
+    if (num + 1 == sgs->to_signals.size())
     {
       // last signal without phys part, put \n manually
       fwriter.Append("");

diff --git a/src/codegen/c-sigprinter.cpp b/src/codegen/c-sigprinter.cpp
@@ -209,12 +209,20 @@ std::string CSigPrinter::PrintSignalExpr(const SignalDescriptor_t* sig, std::vec
   int32_t bbc = (startb % 8) + 1;
   int32_t slen = sig->LengthBit;
 
+  std::string multiplexPrefix = "";
+  std::string multiplexSuffix = "";
+  if (sig->Multiplex == MultiplexType::kMulValue)
+  {
+      multiplexPrefix = "((_m->" + sig->MultiplexName + " == " + std::to_string(sig->MultiplexGroup) + ") ? ";
+      multiplexSuffix = " : 0x0)";
+  }
+
   if (bbc > slen)
   {
     snprintf(workbuff, WBUFF_LEN, "((_d[%d] >> %d) & (%s))", bn, bbc - slen, msk[slen].c_str());
     tosigexpr += workbuff;
 
-    snprintf(workbuff, WBUFF_LEN, "((_m->%s & (%s)) << %d)", sig->Name.c_str(), msk[slen].c_str(), bbc - slen);
+    snprintf(workbuff, WBUFF_LEN, "%s((_m->%s & (%s)) << %d)%s", multiplexPrefix.c_str(), sig->Name.c_str(), msk[slen].c_str(), bbc - slen, multiplexSuffix.c_str());
     AppendToByteLine(to_bytes[bn], workbuff);
   }
   else if (bbc == slen)
@@ -223,7 +231,7 @@ std::string CSigPrinter::PrintSignalExpr(const SignalDescriptor_t* sig, std::vec
     snprintf(workbuff, WBUFF_LEN, "(_d[%d] & (%s))", bn, msk[slen].c_str());
     tosigexpr += workbuff;
 
-    snprintf(workbuff, WBUFF_LEN, "(_m->%s & (%s))", sig->Name.c_str(), msk[slen].c_str());
+    snprintf(workbuff, WBUFF_LEN, "%s(_m->%s & (%s))%s", multiplexPrefix.c_str(), sig->Name.c_str(), msk[slen].c_str(), multiplexSuffix.c_str());
     AppendToByteLine(to_bytes[bn], workbuff);
   }
   else
@@ -239,7 +247,7 @@ std::string CSigPrinter::PrintSignalExpr(const SignalDescriptor_t* sig, std::vec
     snprintf(workbuff, WBUFF_LEN, "(%s(_d[%d] & (%s)) << %d)", t64.c_str(), bn, msk[bbc].c_str(), slen);
     tosigexpr += workbuff;
 
-    snprintf(workbuff, WBUFF_LEN, "((_m->%s >> %d) & (%s))", sig->Name.c_str(), slen, msk[bbc].c_str());
+    snprintf(workbuff, WBUFF_LEN, "%s((_m->%s >> %d) & (%s))%s", multiplexPrefix.c_str(), sig->Name.c_str(), slen, msk[bbc].c_str(), multiplexSuffix.c_str());
     AppendToByteLine(to_bytes[bn], workbuff);
 
     while ((slen - 8) >= 0)
@@ -266,7 +274,7 @@ std::string CSigPrinter::PrintSignalExpr(const SignalDescriptor_t* sig, std::vec
         snprintf(workbuff, WBUFF_LEN, "(_d[%d] & (%s))", bn, msk[8].c_str());
         tosigexpr += workbuff;
 
-        snprintf(workbuff, WBUFF_LEN, "(_m->%s & (%s))", sig->Name.c_str(), msk[8].c_str());
+        snprintf(workbuff, WBUFF_LEN, "%s(_m->%s & (%s))%s", multiplexPrefix.c_str(), sig->Name.c_str(), msk[8].c_str(), multiplexSuffix.c_str());
         AppendToByteLine(to_bytes[bn], workbuff);
 
       }
@@ -280,7 +288,7 @@ std::string CSigPrinter::PrintSignalExpr(const SignalDescriptor_t* sig, std::vec
         snprintf(workbuff, WBUFF_LEN, "(%s(_d[%d] & (%s)) << %d)", t64.c_str(), bn, msk[8].c_str(), slen);
         tosigexpr += workbuff;
 
-        snprintf(workbuff, WBUFF_LEN, "((_m->%s >> %d) & (%s))", sig->Name.c_str(), slen, msk[8].c_str());
+        snprintf(workbuff, WBUFF_LEN, "%s((_m->%s >> %d) & (%s))%s", multiplexPrefix.c_str(), sig->Name.c_str(), slen, msk[8].c_str(), multiplexSuffix.c_str());
         AppendToByteLine(to_bytes[bn], workbuff);
       }
     }
@@ -292,8 +300,7 @@ std::string CSigPrinter::PrintSignalExpr(const SignalDescriptor_t* sig, std::vec
       snprintf(workbuff, WBUFF_LEN, " | ((_d[%d] >> %d) & (%s))", bn, 8 - slen, msk[slen].c_str());
       tosigexpr += workbuff;
 
-      snprintf(workbuff, WBUFF_LEN, "((_m->%s & (%s)) << %d)", sig->Name.c_str(), msk[slen].c_str(),
-        8 - slen);
+      snprintf(workbuff, WBUFF_LEN, "%s((_m->%s & (%s)) << %d)%s",multiplexPrefix.c_str(), sig->Name.c_str(), msk[slen].c_str(), 8 - slen, multiplexSuffix.c_str());
       AppendToByteLine(to_bytes[bn], workbuff);
     }
   }

diff --git a/src/parser/dbclineparser.cpp b/src/parser/dbclineparser.cpp
@@ -178,7 +178,7 @@ bool DbcLineParser::IsSignalLine(const std::string& line)
   return ret;
 }
 
-bool DbcLineParser::ParseSignalLine(SignalDescriptor_t* sig, const std::string& line)
+bool DbcLineParser::ParseSignalLine(SignalDescriptor_t* sig, const std::string& line, std::string& sigMultiplexMasterName)
 {
   // split line in two parts
   auto halfs = resplit(line, kRegSigSplit1, -1);
@@ -200,17 +200,23 @@ bool DbcLineParser::ParseSignalLine(SignalDescriptor_t* sig, const std::string&
   {
     sig->Name = halfs[1];
     sig->Multiplex = MultiplexType::kNone;
+    sig->MultiplexGroup = 0;
 
     if (halfs.size() == 3)
     {
       // Multiplex signal, put additional comment
       if (halfs[2] == "M")
       {
         sig->Multiplex = MultiplexType::kMaster;
+        sigMultiplexMasterName = sig->Name;
       }
       else
       {
         sig->Multiplex = MultiplexType::kMulValue;
+        sig->MultiplexName = sigMultiplexMasterName;
+        // get multiplex group from string m<group number>
+        // convert string starting at index 1 (not zero) to int        
+        sig->MultiplexGroup = std::stoi(halfs[2].substr(1, halfs[2].size()-1));
       }
     }
   }

diff --git a/src/parser/dbclineparser.h b/src/parser/dbclineparser.h
@@ -48,13 +48,15 @@ class DbcLineParser {
 
   // checks if the line is message description
   bool IsMessageLine(const std::string& line);
+
   // parses message line
   bool ParseMessageLine(MessageDescriptor_t* msg, const std::string& line = "");
 
   // checks if the line is signal description
   bool IsSignalLine(const std::string& line);
+
   // parses signal line
-  bool ParseSignalLine(SignalDescriptor_t* sig, const std::string& line);
+  bool ParseSignalLine(SignalDescriptor_t *sig, const std::string &line, std::string& sigMultiplexMasterName);
 
   // tries to parse attribute line (or a few lines) and
   // loads result in attr struct, return @true if parsed ok

diff --git a/src/parser/dbcscanner.cpp b/src/parser/dbcscanner.cpp
@@ -66,6 +66,8 @@ void DbcScanner::ParseMessageInfo(istream& readstrm)
 
   MessageDescriptor_t* pMsg = nullptr;
 
+  std::string sigMultiplexMasterName;
+
   while (readstrm.eof() == false)
   {
     std::getline(readstrm, sline);
@@ -97,7 +99,7 @@ void DbcScanner::ParseMessageInfo(istream& readstrm)
       SignalDescriptor_t sig;
 
       // parse signal line
-      if (lparser.ParseSignalLine(&sig, sline))
+      if (lparser.ParseSignalLine(&sig, sline, sigMultiplexMasterName))
       {
         // put successfully parsed  signal to the message signals
         pMsg->Signals.push_back(sig);

diff --git a/src/tests/dbcline-test.cpp b/src/tests/dbcline-test.cpp
@@ -8,20 +8,22 @@ TEST(TestSigLineParsing, test1)
 {
   DbcLineParser parser;
 
+  std::string sigMultiplexMasterName;
+
   const std::string t2 = " SG_ FLT4_TEST_1 : 39|4@0+ (2.01,1E-002) [-0.01|30.14] \"\"  BCM";
 
   expect_true(parser.IsSignalLine(t2));
 
   SignalDescriptor_t dsc;
 
-  parser.ParseSignalLine(&dsc, t2);
+  parser.ParseSignalLine(&dsc, t2, sigMultiplexMasterName);
 
   expect_true(dsc.IsDoubleSig);
   expect_true(dsc.Offset == 0.01);
 
   const std::string t3 = " SG_ FLT4_TEST_1 : 39|4@0+ (2, 1) [-0.01|30.14] \"\"  BCM";
 
-  parser.ParseSignalLine(&dsc, t3);
+  parser.ParseSignalLine(&dsc, t3, sigMultiplexMasterName);
 
   expect_false(dsc.IsDoubleSig);
   expect_true(dsc.Offset == 1.0);
@@ -35,25 +37,25 @@ TEST(TestSigLineParsing, test1)
   const std::string t3_nok_scie = " SG_ FLT4_TEST_1 : 39|4@0+ (1e-10, 44) [-0.01|30.14] \"\"  BCM";
   const std::string t3_nok_norm = " SG_ FLT4_TEST_1 : 39|4@0+ (0.00000000099, 2) [-0.01|30.14] \"\"  BCM";
 
-  parser.ParseSignalLine(&dsc, t2_ok_norm);
+  parser.ParseSignalLine(&dsc, t2_ok_norm, sigMultiplexMasterName);
 
   expect_true(dsc.IsDoubleSig);
   expect_eq(dsc.Offset, 0.000000001);
   expect_eq(dsc.Factor, 2.0);
 
-  parser.ParseSignalLine(&dsc, t2_ok_scie);
+  parser.ParseSignalLine(&dsc, t2_ok_scie, sigMultiplexMasterName);
 
   expect_true(dsc.IsDoubleSig);
   expect_eq(dsc.Offset, 0.000000001);
   expect_eq(dsc.Factor, 2.0);
 
-  parser.ParseSignalLine(&dsc, t3_nok_norm);
+  parser.ParseSignalLine(&dsc, t3_nok_norm, sigMultiplexMasterName);
 
   expect_false(dsc.IsDoubleSig);
   expect_eq(dsc.Offset, 0.0);
   expect_eq(dsc.Factor, 1.0);
 
-  parser.ParseSignalLine(&dsc, t3_nok_scie);
+  parser.ParseSignalLine(&dsc, t3_nok_scie, sigMultiplexMasterName);
 
   expect_false(dsc.IsDoubleSig);
   expect_eq(dsc.Offset, 0.0);
@@ -72,23 +74,25 @@ TEST(TestSigLineParsing, test_02)
 
   SignalDescriptor_t dsc;
 
-  parser.ParseSignalLine(&dsc, t3_ok);
+  std::string sigMultiplexMasterName;
+
+  parser.ParseSignalLine(&dsc, t3_ok, sigMultiplexMasterName);
 
   expect_true(dsc.IsDoubleSig);
 
-  parser.ParseSignalLine(&dsc, t4_ok);
+  parser.ParseSignalLine(&dsc, t4_ok, sigMultiplexMasterName);
 
   expect_true(dsc.IsDoubleSig);
   expect_eq(dsc.Factor, 0.0);
   expect_eq(dsc.Offset, -0.11);
 
-  parser.ParseSignalLine(&dsc, t5_notok);
+  parser.ParseSignalLine(&dsc, t5_notok, sigMultiplexMasterName);
 
   expect_false(dsc.IsDoubleSig);
   expect_eq(dsc.Factor, 1.0);
   expect_eq(dsc.Offset, 0.0);
 
-  parser.ParseSignalLine(&dsc, t6_ok);
+  parser.ParseSignalLine(&dsc, t6_ok, sigMultiplexMasterName);
 
   expect_true(dsc.IsDoubleSig);
   expect_eq(dsc.Factor, 0.0);
@@ -152,3 +156,53 @@ TEST(TestSigLineParsing, test_prt_double)
   expect_eq(prt_double(v6, 11), "123.0123456789");
   expect_eq(prt_double(v6, 15), "123.0123456789");
 }
+
+TEST(TestMuxParsing, test_mux)
+{
+  const std::string msg_mux = "SBO_ 546 FOO_MUXED_M: 6 FOO_NODE";
+
+  std::vector<std::string> sigLines;
+  sigLines.push_back("SG_ FOO_Mux1 M : 0|8@1+ (1,0) [0|4] \"\" BCM");
+  sigLines.push_back("SG_ FOO_Val_S8_L8_G0 m0 : 8|8@1+ (1,0) [0|255] "" BCM");
+  sigLines.push_back("SG_ FOO_Val_S8_L8_G1 m1 : 8|8@1+ (1,0) [0|255] "" BCM");
+  sigLines.push_back("SG_ FOO_Mux2 M : 0|8@1+ (1,0) [0|4] \"\" BCM");
+  sigLines.push_back("SG_ FOO_Val_S24_L8_G0 m0 : 8|8@1+ (1,0) [0|255] "" BCM");
+  sigLines.push_back("SG_ FOO_Val_S24_L8_G1 m1 : 8|8@1+ (1,0) [0|255] "" BCM");
+
+  DbcLineParser parser;
+
+  MessageDescriptor_t msg;
+
+  // parse message
+  parser.ParseMessageLine(&msg, msg_mux);
+
+  // parse signals
+  std::string sigMultiplexMasterName;
+  for (auto & element : sigLines) 
+  {
+    SignalDescriptor_t sig;
+
+    parser.ParseSignalLine(&sig, element, sigMultiplexMasterName);
+    msg.Signals.push_back(sig);
+  }
+
+  expect_true(msg.Signals[0].Multiplex == MultiplexType::kMaster);
+  expect_true(msg.Signals[1].Multiplex == MultiplexType::kMulValue);
+  expect_true(msg.Signals[2].Multiplex == MultiplexType::kMulValue);
+
+  expect_true(msg.Signals[1].MultiplexGroup == 0);
+  expect_true(msg.Signals[2].MultiplexGroup == 1);
+
+  expect_eq(msg.Signals[1].MultiplexName, "FOO_Mux1");
+  expect_eq(msg.Signals[2].MultiplexName, "FOO_Mux1");
+
+  expect_true(msg.Signals[3].Multiplex == MultiplexType::kMaster);
+  expect_true(msg.Signals[4].Multiplex == MultiplexType::kMulValue);
+  expect_true(msg.Signals[5].Multiplex == MultiplexType::kMulValue);
+
+  expect_true(msg.Signals[4].MultiplexGroup == 0);
+  expect_true(msg.Signals[5].MultiplexGroup == 1);
+
+  expect_eq(msg.Signals[4].MultiplexName, "FOO_Mux2");
+  expect_eq(msg.Signals[5].MultiplexName, "FOO_Mux2");
+}
diff --git a/src/types/message.h b/src/types/message.h
@@ -89,7 +89,13 @@ typedef struct
 
   std::string ValueText;
 
+  // multiplex information
+  // type
+  // group number
+  // multiplex name
   MultiplexType Multiplex;
+  uint16_t MultiplexGroup;
+  std::string MultiplexName;
 
 } SignalDescriptor_t;