Transports classes to separate data transport from FPGA.

include/Transports/FPGASerialDevice.h

@@ -0,0 +1,60 @@
+/*
+ * Serial communication through FPGA FIFOs.
+ *
+ * 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 __Transports_FPGASerialDevice__
+#define __Transports_FPGASerialDevice__
+
+#include <chrono>
+
+#include "Transport.h"
+
+namespace Transports {
+
+/**
+ * Communicate with various serial devices hooked on cRIO serial ports.
+ */
+class FPGASerialDevice : public Transport {
+public:
+ /**
+ * Construct object to communicate with serial device connected to cRIO.
+ * The FPGA in cRIO shall use SerialDevice.vi to communicate with the device.
+ *
+ * @param fpga_session
+ * @param write_fifo
+ * @param read_fifo
+ */
+ FPGASerialDevice(uint32_t fpga_session, int write_fifo, int read_fifo);
+
+ void write(const char* buf, size_t len) override;
+
+ std::vector<uint8_t> read(size_t len, const std::chrono::duration<long int>& timeout,
+ LSST::cRIO::Thread* calling_thread = NULL) override;
+
+private:
+ uint32_t _fpga_session;
+ int _write_fifo;
+ int _read_fifo;
+};
+
+} // namespace Transports
+
+#endif // !__Transports_FPGASerialDevice__

include/Transports/Transport.h

@@ -0,0 +1,89 @@
+/*
+ * Transport base class for communication.
+ *
+ * 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 __Transports_Transport__
+#define __Transports_Transport__
+
+#include <vector>
+
+#include <cRIO/Thread.h>
+
+namespace Transports {
+
+/**
+ * Base transport class. Provides abstract interface to write and read bytes to
+ * serial devices. The methods can throw errors on failures.
+ */
+class Transport {
+public:
+ /**
+ * Opens transport connection.
+ *
+ * @throw std::runtime_error on failure
+ */
+ virtual void open() {}
+
+ /**
+ * Closes transport connection.
+ *
+ * @throw std::runtime_error on failure
+ */
+ virtual void close() {}
+
+ /**
+ * Send data to the other end of the transport.
+ *
+ * @param buf buffer to send
+ * @param size its size
+ *
+ * @throw std::runtime_error on failure
+ */
+ virtual void write(const char* buf, size_t len) = 0;
+
+ /**
+ * Send data to the other end of the transport.
+ *
+ * @param data data to send
+ *
+ * @throw std::runtime_error on failure
+ */
+ virtual void write(std::vector<uint8_t> buf) {
+ write(reinterpret_cast<const char*>(buf.data()), buf.size());
+ }
+
+ /**
+ * Reads data from transport. Returns data available until timeout expires. Can be interrupted by notifing
+ * interrupt_condition.
+ *
+ * @param len expected len to read. If timeout expires and data aren't available, returns what was read
+ * @param timeout maximal time to wait for data
+ * @param interrupt_condition if not NULL, shall be used for waiting
+ *
+ * @throw std::runtime_error on failure
+ */
+ virtual std::vector<uint8_t> read(size_t len, const std::chrono::duration<long int>& timeout,
+ LSST::cRIO::Thread* calling_thread = NULL) = 0;
+};
+
+} // namespace Transports
+
+#endif // !__Transports_Transport__

include/cRIO/Application.h

@@ -237,7 +237,7 @@ class Application {
  * Prints preamble for commands help. Can include tips which commands to
  * use,..
  */
- virtual void printGenericHelp() {};
+ virtual void printGenericHelp(){};
 
  /**
  * Process option from command line parsing.

include/cRIO/ModbusBuffer.h

@@ -411,13 +411,13 @@ class ModbusBuffer {
  * Called before responses are processed (before processXX methods are
  * called).
  */
- virtual void preProcess() {};
+ virtual void preProcess(){};
 
  /**
  * Called after responses are processed (after processXX methods are
  * called).
  */
- virtual void postProcess() {};
+ virtual void postProcess(){};
 
  /**
  * Thrown when an unknown response function is received. As unknown function

include/cRIO/Task.h

@@ -54,7 +54,7 @@ class Task {
  *
  * @param ex exception raised during processing
  */
- virtual void reportException(const std::exception &ex) {};
+ virtual void reportException(const std::exception &ex){};
 
  static constexpr task_return_t DONT_RESCHEDULE = 0xFFFFFFFF;
 

include/cRIO/Thread.h

@@ -71,8 +71,22 @@ class Thread {
  */
  bool joinable();
 
+ /**
+ * Returns whenever thread is running.
+ *
+ * @return true if the thread is running.
+ */
  bool isRunning();
 
+ /**
+ * Waits until given time and while thread is running (wasn't stopped).
+ *
+ * @param abs_time time to wait
+ *
+ * @return false if thread was requested to stop while waiting, otherwise true.
+ */
+ bool wait_until(std::chrono::time_point<std::chrono::steady_clock> abs_time);
+
 protected:
  /**
  * Mutex protecting keepRunning access, can be used in condition variable.

src/LSST/cRIO/ElectromechanicalPneumaticILC.cpp

@@ -103,7 +103,8 @@ ElectromechanicalPneumaticILC::ElectromechanicalPneumaticILC(uint8_t bus) : ILC:
 
  addResponse(ILC_EM_CMD::STEPPER_FORCE_STATUS, stepperForceStatus, 195);
 
- addResponse(ILC_EM_CMD::SET_DCA_GAIN, [this](Modbus::Parser parser) { parser.checkCRC(); }, 201);
+ addResponse(
+ ILC_EM_CMD::SET_DCA_GAIN, [this](Modbus::Parser parser) { parser.checkCRC(); }, 201);
 
  addResponse(ILC_EM_CMD::REPORT_DCA_GAIN, dcaGain, 202);
 

src/LSST/cRIO/FPGA.cpp

@@ -151,6 +151,8 @@ void FPGA::ilcCommands(ILC::ILCBusList &ilc, int32_t timeout) {
 }
 
 void FPGA::mpuCommands(MPU &mpu, const std::chrono::duration<double> &timeout) {
+ auto end = std::chrono::steady_clock::now() + timeout;
+
  for (auto cmd : mpu) {
  writeMPUFIFO(mpu, cmd.buffer, 0);
 

src/LSST/cRIO/FPGACliApp.cpp

@@ -44,8 +44,10 @@ FPGACliApp::FPGACliApp(const char* name, const char* description)
  "Temporary disable given ILC in * commands");
  addILCCommand("@enable", std::bind(&FPGACliApp::enableILC, this, std::placeholders::_1),
  "Re-enable given ILC in * commands");
- addILCCommand("info", [](ILCUnit u) { u.first->reportServerID(u.second); }, "Print ILC info");
- addILCCommand("status", [](ILCUnit u) { u.first->reportServerStatus(u.second); }, "Print ILC status");
+ addILCCommand(
+ "info", [](ILCUnit u) { u.first->reportServerID(u.second); }, "Print ILC info");
+ addILCCommand(
+ "status", [](ILCUnit u) { u.first->reportServerStatus(u.second); }, "Print ILC status");
  addILCCommand(
  "standby", [](ILCUnit u) { u.first->changeILCMode(u.second, ILC::Mode::Standby); },
  "Change ILC mode to standby");
@@ -61,7 +63,8 @@ FPGACliApp::FPGACliApp(const char* name, const char* description)
  addILCCommand(
  "clear-faults", [](ILCUnit u) { u.first->changeILCMode(u.second, ILC::Mode::ClearFaults); },
  "Clear ILC faults");
- addILCCommand("reset", [](ILCUnit u) { u.first->resetServer(u.second); }, "Reset server");
+ addILCCommand(
+ "reset", [](ILCUnit u) { u.first->resetServer(u.second); }, "Reset server");
 
  addCommand("program-ilc", std::bind(&FPGACliApp::programILC, this, std::placeholders::_1), "FS?",
  NEED_FPGA, "<firmware hex file> <ILC...>", "Program ILC with new firmware.");

src/LSST/cRIO/Thread.cpp

@@ -73,6 +73,11 @@ bool Thread::isRunning() {
  return _threadStarted;
 }
 
+bool Thread::wait_until(std::chrono::time_point<std::chrono::steady_clock> abs_time) {
+ std::unique_lock<std::mutex> lg(runMutex);
+ return (runCondition.wait_until(lg, abs_time, [this] { return keepRunning == true; }));
+}
+
 void Thread::_run() {
  {
  std::unique_lock<std::mutex> lock(runMutex);

src/Transports/FPGASerialDevice.cpp

@@ -0,0 +1,91 @@
+/*
+ * Serial communication through FPGA FIFOs.
+ *
+ * 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/>.
+ */
+
+#include <cassert>
+
+#include "cRIO/NiError.h"
+#include "NiFpga/NiFpga.h"
+#include "Transports/FPGASerialDevice.h"
+
+using namespace LSST::cRIO;
+using namespace Transports;
+
+FPGASerialDevice::FPGASerialDevice(uint32_t fpga_session, int write_fifo, int read_fifo)
+ : _fpga_session(fpga_session), _write_fifo(write_fifo), _read_fifo(read_fifo) {}
+
+void FPGASerialDevice::write(const char* buf, size_t len) {
+ assert(len < 255);
+
+ uint8_t header[2] = {1, static_cast<uint8_t>(len)};
+ NiThrowError("Writing FIFO write header",
+ NiFpga_WriteFifoU8(_fpga_session, _write_fifo, header, 2, 0, NULL));
+ NiThrowError("Writing FIFO write data",
+ NiFpga_WriteFifoU8(_fpga_session, _write_fifo, reinterpret_cast<const uint8_t*>(buf), len, 0,
+ NULL));
+}
+
+std::vector<uint8_t> FPGASerialDevice::read(size_t len, const std::chrono::duration<long int>& timeout,
+ LSST::cRIO::Thread* thread) {
+ auto end = std::chrono::steady_clock::now() + timeout;
+
+ std::vector<uint8_t> ret;
+
+ bool not_run = true;
+
+ do {
+ if (not_run == false) {
+ auto end_wait = std::chrono::steady_clock::now() + std::chrono::milliseconds(10);
+
+ thread->wait_until(end_wait < end ? end_wait : end);
+ } else {
+ not_run = true;
+ }
+
+ uint8_t data[255];
+
+ uint8_t req = 2;
+ NiThrowError("Reading FIFO requesting response",
+ NiFpga_WriteFifoU8(_fpga_session, _write_fifo, &req, 1, 0, NULL));
+
+ uint8_t response[2];
+ NiThrowError("Reading FIFO reading response and its length",
+ NiFpga_WriteFifoU8(_fpga_session, _read_fifo, response, 2, 1, NULL));
+
+ if (response[0] != 2) {
+ throw std::runtime_error(fmt::format("Invalid reply from bus - {}, expected 2", response[0]));
+ }
+ if (response[1] == 0) {
+ continue;
+ }
+
+ NiThrowError("ThermalFPGA::readMPUFIFO: reading response",
+ NiFpga_ReadFifoU8(_fpga_session, _read_fifo, data, response[1], 0, NULL));
+
+ ret.insert(ret.end(), data, data + response[1]);
+ if (ret.size() >= len) {
+ break;
+ }
+
+ } while (end <= std::chrono::steady_clock::now());
+
+ return ret;
+}