APA102 cpp implementation

panther_lights/CMakeLists.txt

@@ -1,15 +1,57 @@
-cmake_minimum_required(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.16.3)
 project(panther_lights)
 
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_library(LIBGPIOD libgpiod)
+if(NOT LIBGPIOD)
+  message(WARNING "libgpiod not found. Building from source")
+  include(ExternalProject)
+
+  ExternalProject_Add(libgpiod
+    GIT_REPOSITORY git://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git
+    GIT_TAG v2.0.1
+    PREFIX ${CATKIN_DEVEL_PREFIX}
+    CONFIGURE_COMMAND <SOURCE_DIR>/autogen.sh --prefix=<INSTALL_DIR> --enable-tools=no --enable-bindings-cxx
+    BUILD_COMMAND make -j ${N}
+    INSTALL_COMMAND make install INSTALL_PREFIX=${CATKIN_DEVEL_PREFIX}/lib/libgpiod
+    BUILD_IN_SOURCE 1
+  )
+endif()
+
 find_package(catkin REQUIRED COMPONENTS
   panther_msgs
+  image_transport
+  roscpp
   rospy
   sensor_msgs
   std_msgs
   std_srvs
 )
 
-catkin_package()
+catkin_package(
+  INCLUDE_DIRS include
+  LIBRARIES libgpiod
+  CATKIN_DEPENDS panther_msgs roscpp
+)
+
+include_directories(
+  include
+  ${catkin_INCLUDE_DIRS}
+)
+
+add_executable(driver_node
+  src/main.cpp
+  src/lights_driver_node.cpp
+  src/apa102.cpp
+)
+
+add_dependencies(driver_node libgpiod ${catkin_EXPORTED_TARGETS})
+target_link_libraries(driver_node
+  ${CATKIN_DEVEL_PREFIX}/lib/libgpiodcxx.so
+  ${catkin_LIBRARIES}
+)
 
 install(DIRECTORY
   config

panther_lights/include/panther_lights/apa102.hpp

@@ -0,0 +1,35 @@
+#ifndef PANTHER_LIGHTS_APA_102_HPP_
+#define PANTHER_LIGHTS_APA_102_HPP_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace apa_102
+{
+
+class APA102
+{
+public:
+  APA102(const std::string device, const std::uint32_t speed = 800000, const bool cs_high = false);
+  ~APA102();
+  void set_global_brightness(const std::uint8_t brightness);
+  void set_global_brightness(const double brightness);
+  void set_panel(const std::vector<std::uint8_t> & frame) const;
+
+private:
+  const int fd_;
+  const std::string device_;
+  const std::uint8_t bits_ = 8;
+  const std::uint32_t speed_;
+  std::uint16_t global_brightness_;
+
+  // color correction constants
+  const std::uint16_t corr_red = 255.0;
+  const std::uint16_t corr_green = 200.0;
+  const std::uint16_t corr_blue = 62.0;
+};
+
+}  // namespace apa_102
+
+#endif  // PANTHER_LIGHTS_APA_102_HPP_

panther_lights/include/panther_lights/lights_driver_node.hpp

@@ -0,0 +1,57 @@
+#ifndef PANTHER_LIGHTS_DRIVER_NODE_HPP_
+#define PANTHER_LIGHTS_DRIVER_NODE_HPP_
+
+#include <panther_lights/apa102.hpp>
+
+#include <fstream>
+#include <memory>
+#include <vector>
+
+#include <gpiod.hpp>
+#include <ros/ros.h>
+
+#include <image_transport/image_transport.h>
+
+#include <panther_msgs/SetLEDBrightness.h>
+
+namespace panther_lights_driver
+{
+
+class LightsDriverNode
+{
+public:
+  LightsDriverNode(
+    const std::shared_ptr<ros::NodeHandle> private_nh, std::shared_ptr<ros::NodeHandle> nh,
+    const std::shared_ptr<image_transport::ImageTransport> it);
+  ~LightsDriverNode();
+
+private:
+  int num_led_;
+  double frame_timeout_;
+  bool panels_initialised_ = false;
+  std::string node_name_;
+
+  apa_102::APA102 front_panel_;
+  apa_102::APA102 rear_panel_;
+
+  ros::Time front_panel_ts_;
+  ros::Time rear_panel_ts_;
+  std::shared_ptr<ros::NodeHandle> ph_;
+  std::shared_ptr<ros::NodeHandle> nh_;
+  std::shared_ptr<image_transport::ImageTransport> it_;
+  ros::ServiceServer set_brightness_server_;
+  image_transport::Subscriber rear_light_sub_;
+  image_transport::Subscriber front_light_sub_;
+
+  void frame_cb(
+    const sensor_msgs::ImageConstPtr & msg, const apa_102::APA102 & panel,
+    const ros::Time & last_time, const std::string panel_name);
+  void set_pin_value(const gpiod::line::value value) const;
+  bool set_brightness_cb(
+    panther_msgs::SetLEDBrightness::Request & request,
+    panther_msgs::SetLEDBrightness::Response & response);
+};
+
+}  // namespace panther_lights_driver
+
+#endif  // PANTHER_LIGHTS_DRIVER_NODE_HPP_

panther_lights/package.xml

@@ -22,9 +22,12 @@
   <depend>std_msgs</depend>
   <depend>std_srvs</depend>
 
+  <depend>libgpiod-dev</depend>
+
+  <depend>image_transport</depend>
+  <depend>roscpp</depend>
+
   <!-- Python dependencies -->
-  <depend>python-rpi.gpio-pip</depend>
-  <depend>python3-apa102-pi-pip</depend>
   <depend>python3-pil</depend>
 
 </package>

panther_lights/src/apa102.cpp

@@ -0,0 +1,102 @@
+#include <panther_lights/apa102.hpp>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <linux/spi/spidev.h>
+#include <sys/ioctl.h>
+
+#include <cmath>
+#include <cstdint>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace apa_102
+{
+APA102::APA102(const std::string device, const std::uint32_t speed, const bool cs_high)
+: device_(device), speed_(speed), fd_(open(device_.c_str(), O_RDWR))
+{
+  if (fd_ < 0) {
+    throw std::ios_base::failure(std::string("Failed to open ") + device_);
+  }
+
+  static std::uint8_t mode = SPI_MODE_3;
+  if (cs_high) {
+    mode |= SPI_CS_HIGH;
+  }
+  if (ioctl(fd_, SPI_IOC_WR_MODE32, &mode) == -1) {
+    close(fd_);
+    throw std::ios_base::failure(std::string("Failed to set mode for ") + device_);
+  }
+
+  if (ioctl(fd_, SPI_IOC_WR_BITS_PER_WORD, &bits_) == -1) {
+    close(fd_);
+    throw std::ios_base::failure(std::string("Can't set bits per word for ") + device_);
+  }
+
+  if (ioctl(fd_, SPI_IOC_WR_MAX_SPEED_HZ, &speed_) == -1) {
+    close(fd_);
+    throw std::ios_base::failure(std::string("Can't set speed for ") + device_);
+  }
+}
+
+APA102::~APA102() { close(fd_); }
+
+void APA102::set_global_brightness(const double brightness)
+{
+  std::uint8_t val = brightness > 0.0f ? ceil(brightness * 31.0f) : 0;
+  set_global_brightness(val);
+}
+
+void APA102::set_global_brightness(const std::uint8_t brightness)
+{
+  // clamp values to be at max 31
+  global_brightness_ = std::uint16_t(brightness) & 0x1F;
+}
+
+void APA102::set_panel(const std::vector<std::uint8_t> & frame) const
+{
+  if (frame.size() % 4 != 0) {
+    throw std::runtime_error("Incorrect number of bytes to transfer to LEDs");
+  }
+  // init buffer with start and end frames
+  std::size_t buffer_size = (4 * sizeof(std::uint8_t)) + frame.size() + (4 * sizeof(std::uint8_t));
+  std::uint8_t * buffer = new std::uint8_t[buffer_size];
+
+  // init start and end frames
+  for (std::size_t i = 0; i < 4; i++) {
+    buffer[i] = 0x00;
+    buffer[buffer_size - i - 1] = 0xFF;
+  }
+
+  // copy frame from vector to sending buffer
+  for (std::size_t i = 0; i < frame.size() / 4; i++) {
+    // padding
+    std::size_t pad = i * 4;
+    // header with brightness
+    std::uint8_t brightness = (std::uint16_t(frame[pad + 3]) * global_brightness_) / 255;
+    buffer[4 + pad] = 0xE0 | brightness;
+    // convert rgb to bgr with collor correction
+    buffer[4 + pad + 1] = std::uint8_t((std::uint16_t(frame[pad + 2]) * corr_blue) / 255);
+    buffer[4 + pad + 2] = std::uint8_t((std::uint16_t(frame[pad + 1]) * corr_green) / 255);
+    buffer[4 + pad + 3] = std::uint8_t((std::uint16_t(frame[pad + 0]) * corr_red) / 255);
+  }
+
+  struct spi_ioc_transfer tr = {
+    .tx_buf = (unsigned long long)buffer,
+    .rx_buf = 0,
+    .len = (unsigned int)buffer_size,
+    .speed_hz = speed_,
+    .delay_usecs = 0,
+    .bits_per_word = 8,
+  };
+
+  int ret = ioctl(fd_, SPI_IOC_MESSAGE(1), &tr);
+  delete[] buffer;
+
+  if (ret < 1) {
+    throw std::ios_base::failure(std::string("Failed to send data over SPI ") + device_);
+  }
+}
+}  // namespace apa_102