Initial FTDI RDM support

.gitignore

@@ -246,3 +246,7 @@ javascript/new-src/node_modules
 .cproject
 .settings
 .vscode/
+*.config
+*.creator*
+*.files
+*.includes

.travis-ci.sh

@@ -11,6 +11,19 @@ COVERITY_SCAN_BUILD_URL="https://scan.coverity.com/scripts/travisci_build_coveri
 
 PYCHECKER_BLACKLIST="threading,unittest,cmd,optparse,google,google.protobuf,ssl,fftpack,lapack_lite,mtrand"
 
+LINT_BLACKLIST=$(cat <<EOLBL
+        -wholename "./common/protocol/Ola.pb.*" -or \
+        -wholename "./common/rpc/Rpc.pb.*" -or \
+        -wholename "./common/rpc/TestService.pb.*" -or \
+        -wholename "./common/rdm/Pids.pb.*" -or \
+        -wholename "./config.h" -or \
+        -wholename "./plugins/*/messages/*ConfigMessages.pb.*" -or \
+        -wholename "./tools/ola_trigger/config.tab.*" -or \
+        -wholename "./tools/ola_trigger/lex.yy.cpp" -or \
+        -wholename "./plugins/ftdidmx/FtdiDmxPluginDescription.h"
+EOLBL
+)
+
 SPELLINGBLACKLIST=$(cat <<-BLACKLIST
       -wholename "./.codespellignore" -or \
       -wholename "./.git/*" -or \
@@ -69,19 +82,12 @@ if [[ $TASK = 'lint' ]]; then
     echo "Found $nolints generic NOLINTs"
   fi;
   # then fetch and run the main cpplint tool
+  lintfiles=$(eval "find ./ \( -name "*.h" -or -name "*.cpp" \) -and ! \( $LINT_BLACKLIST \) | xargs")
   wget -O cpplint.py $CPP_LINT_URL;
   chmod u+x cpplint.py;
   ./cpplint.py \
     --filter=-legal/copyright,-readability/streams,-runtime/arrays \
-    $(find ./ \( -name "*.h" -or -name "*.cpp" \) -and ! \( \
-        -wholename "./common/protocol/Ola.pb.*" -or \
-        -wholename "./common/rpc/Rpc.pb.*" -or \
-        -wholename "./common/rpc/TestService.pb.*" -or \
-        -wholename "./common/rdm/Pids.pb.*" -or \
-        -wholename "./config.h" -or \
-        -wholename "./plugins/*/messages/*ConfigMessages.pb.*" -or \
-        -wholename "./tools/ola_trigger/config.tab.*" -or \
-        -wholename "./tools/ola_trigger/lex.yy.cpp" \) | xargs)
+    $lintfiles
   if [[ $? -ne 0 ]]; then
     exit 1;
   fi;

common/utils/Clock.cpp

@@ -39,6 +39,8 @@
 #include <sstream>
 #include <string>
 
+#include "ola/Logging.h"
+
 namespace ola {
 
 using std::string;
@@ -129,6 +131,11 @@ int64_t BaseTimeVal::InMilliSeconds() const {
           m_tv.tv_usec / ONE_THOUSAND);
 }
 
+int64_t BaseTimeVal::InMicroSeconds() const {
+  return (m_tv.tv_sec * static_cast<int64_t>(USEC_IN_SECONDS) +
+          m_tv.tv_usec);
+}
+
 int64_t BaseTimeVal::AsInt() const {
   return (m_tv.tv_sec * static_cast<int64_t>(USEC_IN_SECONDS) + m_tv.tv_usec);
 }
@@ -272,4 +279,89 @@ void MockClock::CurrentTime(TimeStamp *timestamp) const {
   *timestamp = tv;
   *timestamp += m_offset;
 }
+
+Sleep::Sleep(std::string caller) :
+  m_caller(caller) {
+}
+
+/**
+ * @brief Set wanted granularity for usleep and check it.
+ * @note does not check at the nanosecond level,
+ * since internal sturtures use usecs.
+ *
+ * @param wanted wanted/needed granularity in usecs
+ * @param maxDeviation max deviation in usecs tolerated by calling thread.
+ *
+ * @attention the granularity of sleep is highly fluctuating depending on the
+ * load of the system, a prior GOOD state is no guarantee for future proper
+ * timing.
+ */
+bool Sleep::CheckTimeGranularity(uint64_t wanted, uint64_t maxDeviation) {
+  TimeStamp ts1, ts2;
+  Clock clock;
+
+  m_wanted_granularity = wanted;
+  m_max_granularity_deviation = maxDeviation;
+
+  timespec t;
+  t.tv_sec = wanted / USEC_IN_SECONDS;
+  t.tv_nsec = (wanted % USEC_IN_SECONDS) * ONE_THOUSAND;
+
+  clock.CurrentTime(&ts1);
+  this->usleep(1);
+  clock.CurrentTime(&ts2);
+  TimeInterval interval = ts2 - ts1;
+  m_clock_overhead = interval.InMicroSeconds();
+
+  clock.CurrentTime(&ts1);
+  this->usleep(t);
+  clock.CurrentTime(&ts2);
+
+  interval = ts2 - ts1;
+  m_granularity = (interval.InMicroSeconds() >
+                   (wanted + maxDeviation + m_clock_overhead)) ? BAD : GOOD;
+
+  OLA_INFO << "Granularity for OlaSleep in " << m_caller << " is "
+           << ((m_granularity == GOOD) ? "GOOD" : "BAD")
+           << " Requested: " << wanted << " Got: " << interval.InMicroSeconds()
+           << " Overhead: " << m_clock_overhead;
+  if (m_granularity == GOOD) {
+    return true;
+  }
+  return false;
+}
+
+void Sleep::usleep(TimeInterval requested) {
+  timespec req;
+  req.tv_sec = requested.Seconds();
+  req.tv_nsec = requested.MicroSeconds() * ONE_THOUSAND;
+
+  this->usleep(req);
+}
+
+void Sleep::usleep(uint32_t requested) {
+  timespec req;
+  req.tv_sec = requested / USEC_IN_SECONDS;
+  req.tv_nsec = (requested % USEC_IN_SECONDS) * ONE_THOUSAND;
+  req.tv_sec = 0;
+
+  this->usleep(req);
+}
+
+void Sleep::usleep(timespec requested) {
+  timespec rem;
+
+  if (nanosleep(&requested, &rem) < 0) {
+    if (errno == EINTR) {
+      while (rem.tv_nsec > 0 || rem.tv_sec > 0) {
+        requested.tv_nsec = rem.tv_nsec;
+        requested.tv_sec = rem.tv_sec;
+        nanosleep(&requested, &rem);
+      }
+    } else {
+      OLA_WARN << "nanosleep failed with state: " << errno;
+    }
+  }
+}
+
 }  // namespace ola

common/utils/StringUtils.cpp

@@ -152,13 +152,16 @@ bool StringToBoolTolerant(const string &value, bool *output) {
   return false;
 }
 
-bool StringToInt(const string &value, unsigned int *output, bool strict) {
+bool StringToInt(const string &value,
+                 unsigned int *output,
+                 bool strict,
+                 uint8_t base) {
   if (value.empty()) {
     return false;
   }
   char *end_ptr;
   errno = 0;
-  long long l = strtoll(value.data(), &end_ptr, 10);  // NOLINT(runtime/int)
+  long long l = strtoll(value.data(), &end_ptr, base);  // NOLINT(runtime/int)
   if (l < 0 || (l == 0 && errno != 0)) {
     return false;
   }
@@ -168,10 +171,12 @@ bool StringToInt(const string &value, unsigned int *output, bool strict) {
   if (strict && *end_ptr != 0) {
     return false;
   }
+
+  *output = static_cast<unsigned int>(l);
+
   if (l > static_cast<long long>(UINT32_MAX)) {  // NOLINT(runtime/int)
     return false;
   }
-  *output = static_cast<unsigned int>(l);
   return true;
 }
 
@@ -199,16 +204,19 @@ bool StringToInt(const string &value, uint8_t *output, bool strict) {
   return true;
 }
 
-bool StringToInt(const string &value, int *output, bool strict) {
+bool StringToInt(const string &value, int *output, bool strict, uint8_t base) {
   if (value.empty()) {
     return false;
   }
   char *end_ptr;
   errno = 0;
-  long long l = strtoll(value.data(), &end_ptr, 10);  // NOLINT(runtime/int)
+  long long l = strtoll(value.data(), &end_ptr, base);  // NOLINT(runtime/int)
   if (l == 0 && errno != 0) {
     return false;
   }
+
+  *output = static_cast<unsigned int>(l);
+
   if (value == end_ptr) {
     return false;
   }
@@ -218,7 +226,7 @@ bool StringToInt(const string &value, int *output, bool strict) {
   if (l < INT32_MIN || l > INT32_MAX) {
     return false;
   }
-  *output = static_cast<unsigned int>(l);
+
   return true;
 }
 

include/ola/Clock.h

@@ -41,7 +41,9 @@
 namespace ola {
 
 static const int USEC_IN_SECONDS = 1000000;
-static const int ONE_THOUSAND = 1000;
+static const int MSEC_IN_SEC = 1000;
+static const uint64_t NSEC_IN_SEC = 1000000000;
+static const int ONE_THOUSAND = MSEC_IN_SEC;
 
 /**
  * Don't use this class directly. It's an implementation detail of TimeInterval
@@ -98,6 +100,12 @@ class BaseTimeVal {
    */
   int64_t InMilliSeconds() const;
 
+  /**
+   * @brief Returns the entire BaseTimeVal as microseconds
+   * @return The entire BaseTimeVal in microseconds
+   */
+  int64_t InMicroSeconds() const;
+
   /**
    * @brief Returns the entire BaseTimeVal as microseconds
    * @return The entire BaseTimeVal in microseconds
@@ -160,6 +168,7 @@ class TimeInterval {
   int32_t MicroSeconds() const { return m_interval.MicroSeconds(); }
 
   int64_t InMilliSeconds() const { return m_interval.InMilliSeconds(); }
+  int64_t InMicroSeconds() const { return m_interval.InMicroSeconds(); }
   int64_t AsInt() const { return m_interval.AsInt(); }
 
   std::string ToString() const { return m_interval.ToString(); }
@@ -257,5 +266,30 @@ class MockClock: public Clock {
  private:
   TimeInterval m_offset;
 };
+
+enum TimerGranularity { UNKNOWN, GOOD, BAD };
+
+class Sleep {
+ public:
+  explicit Sleep(std::string caller);
+
+  void setCaller(std::string caller) { m_caller = caller; }
+
+  void usleep(TimeInterval requested);
+  void usleep(uint32_t requested);
+  void usleep(timespec requested);
+
+  TimerGranularity getGranularity() { return m_granularity; }
+  bool CheckTimeGranularity(uint64_t wanted, uint64_t maxDeviation);
+ private:
+  std::string m_caller;
+  uint64_t m_wanted_granularity;
+  uint64_t m_max_granularity_deviation;
+  uint64_t m_clock_overhead;
+
+  static const uint32_t BAD_GRANULARITY_LIMIT = 10;
+
+  TimerGranularity m_granularity = UNKNOWN;
+};
 }  // namespace ola
 #endif  // INCLUDE_OLA_CLOCK_H_

include/ola/StringUtils.h

@@ -262,12 +262,14 @@ bool StringToBoolTolerant(const std::string &value, bool *output);
  * @param[in] value the string to convert
  * @param[out] output a pointer where the value will be stored.
  * @param[in] strict this controls if trailing characters produce an error.
+ * @param[in] base sets the base of the input string, default decimal (10)
  * @returns true if the value was converted, false if the string was not an int
  * or the value was too large / small for the type.
  */
 bool StringToInt(const std::string &value,
                  unsigned int *output,
-                 bool strict = false);
+                 bool strict = false,
+                 uint8_t base = 10);
 
 /**
  * @brief Convert a string to a uint16_t.
@@ -300,11 +302,15 @@ bool StringToInt(const std::string &value,
  * @param[in] value the string to convert
  * @param[out] output a pointer where the value will be stored.
  * @param[in] strict this controls if trailing characters produce an error.
+ * @param[in] base sets the base of the input string, default decimal (10)
  * @returns true if the value was converted, false if the string was not an int
  * or the value was too large / small for the type.
  * @sa StringToInt.
  */
-bool StringToInt(const std::string &value, int *output, bool strict = false);
+bool StringToInt(const std::string &value,
+                 int *output,
+                 bool strict = false,
+                 uint8_t base = 10);
 
 /**
  * @brief Convert a string to a int16_t.

plugins/convert_README_to_header.sh

@@ -30,8 +30,8 @@ outfilename=`basename $outfile`;
 # See http://stackoverflow.com/a/16576291
 # On Mac OS's sed, \n is not recognized as a newline character, but
 # \[actual newline] works
-desc=`sed -e ':a' -e 'N' -e '$!ba' -e 's/\"/\\\"/g' -e 's/\n/\\\\n"\\
-"/g' "$path/README.md"`;
+desc=`sed -e ':a' -e 'N' -e '$!ba' -e 's#\\\#\\\\\\\#g' -e 's#\"#\\\"#g' -e 's#\n#\\\\n"\\
+"#g' "$path/README.md"`;
 
 identifier=`echo "PLUGINS_${plugin}_${outfilename%.h}_H_" | tr '[:lower:]' '[:upper:]'`
 

plugins/ftdidmx/FtdiDmxDevice.cpp

@@ -56,15 +56,20 @@ FtdiDmxDevice::~FtdiDmxDevice() {
 bool FtdiDmxDevice::StartHook() {
   unsigned int interface_count = m_widget->GetInterfaceCount();
   unsigned int successfully_added = 0;
+  unsigned int serial = 0;
 
   OLA_INFO << "Widget " << m_widget->Name() << " has " << interface_count
            << " interfaces.";
 
   for (unsigned int i = 1; i <= interface_count; i++) {
+    if (!StringToInt(m_widget->Serial().substr(2, 6), &serial, false, 36)) {
+      OLA_WARN << "StringToInt returned false, serial used: " << serial
+               << " Generated from: " << m_widget->Serial().substr(2, 6);
+    }
     FtdiInterface *port = new FtdiInterface(m_widget,
                                             static_cast<ftdi_interface>(i));
     if (port->SetupOutput()) {
-      AddPort(new FtdiDmxOutputPort(this, port, i, m_frequency));
+      AddPort(new FtdiDmxOutputPort(this, port, i, m_frequency, serial));
       successfully_added += 1;
     } else {
       OLA_WARN << "Failed to add interface: " << i;