Merge pull request #68 from lsst-ts/tickets/DM-45837

Simplify MPU communication

.github/workflows/run_tests.yml

@@ -20,28 +20,6 @@ jobs:
  make
  make junit || true
 
- centos:
- runs-on: ubuntu-latest
- name: Test compile on Centos7
- container:
- image: centos/devtoolset-7-toolchain-centos7
- options: -u root
- steps:
- - name: Install dependencies
- run: |
- yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
- yum install -y make catch-devel readline-devel yaml-cpp-devel git
- - name: Checkout
- uses: actions/checkout@v3
- - name: make junit
- run: |
- git clone https://github.com/gabime/spdlog.git
- mv spdlog/include/spdlog include/
- git clone https://github.com/fmtlib/fmt
- mv fmt/include/fmt include
- make
- make junit || true
-
  ubuntu:
  runs-on: ubuntu-latest
  name: Test compile on Ubuntu

doc/version-history.rst

@@ -2,12 +2,17 @@
 Version History
 ###############
 
+v1.12.0
+-------
+* simplified MPU communication
 
 v1.11.1
 -------
 * SensorMonitor ILC
 * broadcast commands to step and freeze
 * SimpleFPGACliApp class
+* formatDuration template class
+* More constants
 
 v1.11.0
 -------

include/cRIO/ElectromechanicalPneumaticILC.h

@@ -66,6 +66,7 @@ class ElectromechanicalPneumaticILC : public virtual ILC::ILCBusList {
  REPORT_DCA_GAIN = 74,
  SET_FORCE_OFFSET = 75,
  REPORT_FA_FORCE_STATUS = 76,
+ SET_ADC_SCANRATE = 80,
  SET_OFFSET_AND_SENSITIVITY = 81,
  REPORT_CALIBRATION_DATA = 110,
  REPORT_MEZZANINE_PRESSURE = 119,

include/cRIO/FPGA.h

@@ -125,10 +125,11 @@ class FPGA : public SimpleFPGA {
  /**
  * Commands FPGA to write to MPU commands buffer.
  *
+ * @param mpu Modbus Processing Unit that shall be written
  * @param data data to write to the MPU command buffer
  * @param timeout timeout in milliseconds
  */
- virtual void writeMPUFIFO(const std::vector<uint8_t>& data, uint32_t timeout) = 0;
+ virtual void writeMPUFIFO(MPU& mpu, const std::vector<uint8_t>& data, uint32_t timeout) = 0;
 
  /**
  * Commands FPGA to copy MPU output FIFO to FPGA-C/C++ output FIFO. This

include/cRIO/MPU.h

@@ -38,6 +38,12 @@
 namespace LSST {
 namespace cRIO {
 
+struct CommandedInfo {
+ CommandedInfo(uint16_t _addres, uint16_t _length) : address(_addres), length(_length) {}
+ uint16_t address;
+ uint16_t length;
+};
+
 /**
  * The Modbus Processing Unit class. Prepares buffer with commands to send to
  * FPGA, read responses & telemetry values.
@@ -138,8 +144,7 @@ class MPU : public Modbus::BusList {
  /**
  * Address of register/input which will be read by the command
  */
- uint16_t _commanded_address = 0;
- uint16_t _commanded_length = 0;
+ std::list<CommandedInfo> _commanded_info;
 
  std::mutex _registerMutex;
 

include/cRIO/MPUTelemetry.h

@@ -38,41 +38,12 @@ class MPUTelemetry {
  *
  * @param data[45] data as received from FPGA
  */
- MPUTelemetry(uint8_t* data);
- uint32_t writeBytes; /// Number of bytes written
- uint32_t readBytes; /// Number of bytes read
- uint16_t readTimedout; /// read timedout counter
+ MPUTelemetry(const uint8_t* data);
 
- friend std::ostream& operator<<(std::ostream& os, const MPUTelemetry& tel);
+ uint64_t writeBytes; /// Number of bytes written
+ uint64_t readBytes; /// Number of bytes read
 
- /**
- * Updates MPU telemetry SAL message structure.
- *
- * @tparam message class with telemetry filed. Shall be SAL declared class
- * @param msg message to check and update
- *
- * @return true if message shall be send, false if updates are minor and it should not be send
- */
- template <class message>
- bool sendUpdates(message* msg) {
- return false;
-
- /**
- if (msg->readBytes != readBytes || msg->writeTimedout != writeTimedout ||
- msg->instructionPointerOnError != instructionPointerOnError || msg->errorCode != errorCode) {
- send = true;
- }
- msg->instructionPointer = instructionPointer;
- msg->outputCounter = outputCounter;
- msg->inputCounter = inputCounter;
- msg->outputTimeouts = outputTimeouts;
- msg->inputTimeouts = inputTimeouts;
- msg->instructionPointerOnError = instructionPointerOnError;
- msg->writeTimeout = writeTimeout;
- msg->readTimeout = readTimeout;
- msg->errorCode = errorCode;
- return send; */
- }
+ friend std::ostream& operator<<(std::ostream& os, const MPUTelemetry& tel);
 };
 
 } // namespace cRIO

include/cRIO/PrintILC.h

@@ -123,6 +123,8 @@ class PrintILC : public virtual ILC::ILCBusList {
  WRITE_VERIFY_APPLICATION = 103
  };
 
+ static constexpr uint8_t APPLICATION_PAGE_LENGTH = 192;
+
 protected:
  void processServerID(uint8_t address, uint64_t uniqueID, uint8_t ilcAppType, uint8_t networkNodeType,
  uint8_t ilcSelectedOptions, uint8_t networkNodeOptions, uint8_t majorRev,

include/cRIO/SimpleFPGA.h

@@ -99,10 +99,10 @@ class SimpleFPGA {
  */
  void openDebugFile(const char* path);
 
- void writeDebugFile(const char* message);
+ void writeDebugFile(const std::string& message);
 
  template <typename dt>
- const void writeDebugFile(const char* message, const std::vector<dt>& data) {
+ const void writeDebugFile(const std::string& message, const std::vector<dt>& data) {
  if (_debug_stream.is_open()) {
  try {
  auto now = std::chrono::system_clock::now();
@@ -117,7 +117,7 @@ class SimpleFPGA {
  }
 
  template <typename dt>
- const void writeDebugFile(const char* message, dt* buf, size_t length) {
+ const void writeDebugFile(const std::string& message, dt* buf, size_t length) {
  if (_debug_stream.is_open()) {
  try {
  auto now = std::chrono::system_clock::now();
@@ -132,7 +132,7 @@ class SimpleFPGA {
  }
 
  template <typename dt>
- const void writeDebugFile(const char* message, ModbusBuffer& mb) {
+ const void writeDebugFile(const std::string& message, ModbusBuffer& mb) {
  if (_debug_stream.is_open()) {
  try {
  auto now = std::chrono::system_clock::now();
@@ -146,7 +146,7 @@ class SimpleFPGA {
  }
  }
 
- void writeDebugFile(const char* message, ModbusBuffer& mb);
+ void writeDebugFile(const std::string& message, ModbusBuffer& mb);
 
  void closeDebugFile();
 

include/cRIO/SimpleFPGACliApp.h

@@ -23,6 +23,7 @@
 #include <unistd.h>
 
 #include <cRIO/CliApp.h>
+#include <cRIO/formatDuration.h>
 #include <cRIO/SimpleFPGA.h>
 
 namespace LSST {
@@ -181,8 +182,8 @@ class TemplateFPGACliApp : public CliApp {
  auto end = std::chrono::steady_clock::now();
 
  if (_timeIt) {
- std::chrono::duration<double> diff = end - start;
- std::cout << "Took " << std::setprecision(3) << (diff.count() * 1000.0) << " ms" << std::endl;
+ std::cout << "Took " << std::setprecision(3) << std::fixed << formatDuration(end - start)
+   << std::endl;
  }
 
  return ret;

include/cRIO/formatDuration.h

@@ -0,0 +1,96 @@
+/*
+ * Developed for the Vera C. Rubin Observatory Telescope & Site Software Systems.
+ * This product includes software developed by the Vera C.Rubin Observatory Project
+ * (https://www.lsst.org). See the COPYRIGHT file at the top-level directory of
+ * this distribution for details of code ownership.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _formatDuration_H_
+#define _formatDuration_H_
+
+#include <chrono>
+#include <sstream>
+#include <string>
+
+using namespace std::chrono;
+
+/***
+ * Template function to format chrono::duration to human readable string.
+ *
+ * @parametr timeunit
+ *
+ * @return human-readable string (such as 1m:41s:341.179.283ns)
+ */
+template <typename T>
+inline std::string formatDuration(T timeunit) {
+ nanoseconds ns = duration_cast<nanoseconds>(timeunit);
+ std::ostringstream os;
+ bool foundNonZero = false;
+ os.fill('0');
+ typedef duration<int, std::ratio<86400 * 365>> years;
+ const auto y = duration_cast<years>(ns);
+ if (y.count()) {
+ foundNonZero = true;
+ os << y.count() << "y:";
+ ns -= y;
+ }
+ typedef duration<int, std::ratio<86400>> days;
+ const auto d = duration_cast<days>(ns);
+ if (d.count()) {
+ foundNonZero = true;
+ os << d.count() << "d:";
+ ns -= d;
+ }
+ const auto h = duration_cast<hours>(ns);
+ if (h.count() || foundNonZero) {
+ foundNonZero = true;
+ os << h.count() << "h:";
+ ns -= h;
+ }
+ const auto m = duration_cast<minutes>(ns);
+ if (m.count() || foundNonZero) {
+ foundNonZero = true;
+ os << m.count() << "m:";
+ ns -= m;
+ }
+ const auto s = duration_cast<seconds>(ns);
+ if (s.count() || foundNonZero) {
+ foundNonZero = true;
+ os << s.count() << "s:";
+ ns -= s;
+ }
+ const auto ms = duration_cast<milliseconds>(ns);
+ if (ms.count() || foundNonZero) {
+ if (foundNonZero) {
+ os << std::setw(3);
+ }
+ os << ms.count() << ".";
+ ns -= ms;
+ foundNonZero = true;
+ }
+ const auto us = duration_cast<microseconds>(ns);
+ if (us.count() || foundNonZero) {
+ if (foundNonZero) {
+ os << std::setw(3);
+ }
+ os << us.count() << ".";
+ ns -= us;
+ }
+ os << std::setw(3) << ns.count() << "ns";
+ return os.str();
+}
+
+#endif ///!_formatDuration_H_

src/LSST/cRIO/FPGA.cpp

@@ -155,13 +155,7 @@ void FPGA::mpuCommands(MPU &mpu, const std::chrono::duration<double> &timeout) {
  // construct buffer to send
  std::vector<uint8_t> data;
 
- data.push_back(mpu.getBus());
- data.push_back(cmd.buffer.size() + 2);
- data.push_back(MPUCommands::WRITE);
- data.push_back(cmd.buffer.size());
- data.insert(data.end(), cmd.buffer.begin(), cmd.buffer.end());
-
- writeMPUFIFO(data, 0);
+ writeMPUFIFO(mpu, cmd.buffer, 0);
 
  // read reply
  auto answer = readMPUFIFO(mpu);