still the biggest refactor

FlippR-Driver/src/output/DriverBoardPinController.h

@@ -5,13 +5,17 @@
 #ifndef FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H
 #define FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H
 
-#include <output/items/DriverBoardItem.h>
 
 namespace flippR_driver
 {
 namespace output
 {
 
+namespace items
+{
+  class DriverBoardItem;
+}
+
 class DriverBoardPinController
 {
 public:

FlippR-Driver/src/output/OutputDriverFactory.cpp

@@ -2,15 +2,18 @@
 // Created by rhetenor on 04.10.18.
 //
 
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/adaptor/map.hpp>
 #include "OutputDriverFactory.h"
 
 #include "utility/LoggerFactory.h"
 
 #include "output/impl/OutputDriver.h"
-#include "output/impl/OutputPinController.h"
+#include "output/impl/DisplayController.h"
+
+#include "output/impl/DisplayBoardPinController.h"
 #include "output/impl/DriverBoardPinController.h"
 #include "output/impl/SoundBoardPinController.h"
-#include "DisplayBoardPinController.h"
 
 namespace flippR_driver
 {
@@ -28,37 +31,30 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream &output_pin_config,
 {
   utility::LoggerFactory::CreateOutputLogger();
 
-  std::shared_ptr<std::mutex> output_pin_mutex();
+  std::shared_ptr<std::mutex> output_pin_mutex;
 
   json output_config;
   output_pin_config >> output_config;
 
   json driver_board_config = output_config.at("driver_board");
   std::shared_ptr<DriverBoardPinController> driver_board_pin_controller(new impl::DriverBoardPinController(parse_pins_driver_board(driver_board_config), output_pin_mutex));
+  auto solenoids = create_solenoids(solenoid_config, driver_board_pin_controller);
+  auto lamps = create_lamps(lamp_config, driver_board_pin_controller);
 
   json sound_board_config = output_config.at("sound_board");
   std::shared_ptr<SoundBoardPinController> sound_board_pin_controller(new impl::SoundBoardPinController(parse_pins_sound_board(sound_board_config), output_pin_mutex));
+  auto sounds = create_sounds(sound_config, sound_board_pin_controller);
 
   json display_board_config = output_config.at("display_board");
-  std::shared_ptr<DisplayBoardPinController> display_board_pin_controller(new impl::DisplayBoardPinController(parse_pins_display_board(display_board_config)));
+  std::unique_ptr<DisplayBoardPinController> display_board_pin_controller(new impl::DisplayBoardPinController(parse_pins_display_board(display_board_config)));
+  auto displays = create_displays(display_config);
 
-  auto solenoids = create_solenoids(solenoid_config, output_gpio_interface);
+  // todo
-  auto lamps = create_lamps(lamp_config, output_gpio_interface);
+  std::vector<std::shared_ptr<items::IDisplay>> displays_vec;
-  auto sounds = create_sounds(sound_config, output_gpio_interface);
+  boost::copy(displays | boost::adaptors::map_values, std::back_inserter(displays_vec));
+  std::unique_ptr<DisplayController> display_controller(new impl::DisplayController(displays_vec, std::move(display_board_pin_controller)));
 
-  auto displays = create_displays(display_config, output_gpio_interface);
+  return std::make_shared<OutputDriver>(display_controller, solenoids, lamps, sounds, displays);
-
-  return std::make_shared<OutputDriver>(solenoids, lamps, sounds, displays);
-}
-
-OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_config)
-{
-  json output_config;
-  output_pin_config >> output_config;
-
-  return new OutputGPIOInterface(parse_pins_driver_board(output_config.at("driver_board")),
-    parse_pins_sound(output_config.at("sound_board")),
-    parse_pins_sound(output_config.at("display_board")));
 }
 
 std::map<std::string, uint8_t> parse_pins_driver_board(json &driver_board_config)
@@ -124,12 +120,15 @@ std::map<std::string, uint8_t> parse_pins_display(json &display_board_config)
   try
   {
     pins_display["run"] = display_board_config.at("run");
+    //todo
   }
   catch(json::exception &e)
   {
     CLOG(ERROR, OUTPUT_LOGGER) << "Output pin config file at display_board corrupted: " << e.what();
     exit(EXIT_FAILURE);
   }
+
+  return pins_display;
 }
 
 std::map<std::string, std::shared_ptr<items::ISolenoid>> create_solenoids(std::istream &solenoid_config, std::shared_ptr<OutputPinController> output_gpio_interface)
@@ -197,7 +196,7 @@ std::chrono::milliseconds get_deactivation_time(nlohmann::json &json)
   }
 }
 
-std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<OutputPinController> output_gpio_interface, std::chrono::milliseconds deactivation_time)
+std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<DriverBoardPinController> &pin_controller, std::chrono::milliseconds deactivation_time)
 {
   try
   {
@@ -209,7 +208,7 @@ std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json,
       deactivation_time = get_deactivation_time(solenoid_json);
     }
     
-    return std::make_shared<items::Solenoid>(output_gpio_interface, address, name, deactivation_time);
+    return std::make_shared<items::Solenoid>(pin_controller, address, name, deactivation_time);
   }
   catch(json::type_error &e)
   {
@@ -218,13 +217,13 @@ std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json,
   }
 }
 
-std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<OutputPinController> output_gpio_interface)
+std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<DriverBoardPinController> &pin_controller)
 {
   try
   {
     std::string name = lamp_json.at("name");
     auto address = lamp_json.at("address").get<uint8_t>();
-    return std::make_shared<items::Lamp>(output_gpio_interface, address, name);
+    return std::make_shared<items::Lamp>(pin_controller, address, name);
   }
   catch(json::type_error &e)
   {
@@ -233,14 +232,14 @@ std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_
   }
 }
 
-std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<OutputPinController> &output_gpio_interface, std::chrono::milliseconds deactivation_time)
+std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<SoundBoardPinController> &pin_controller, std::chrono::milliseconds deactivation_time)
 {
   try
   {
     auto id = sound_json.at("id").get<uint>();
     std::string description = sound_json.at("description");
     auto address = sound_json.at("address").get<uint8_t>();
-    return std::make_shared<items::Sound>(output_gpio_interface, address, description, deactivation_time, id);
+    return std::make_shared<items::Sound>(pin_controller, address, description, deactivation_time, id);
   }
   catch(json::type_error &e)
   {

FlippR-Driver/src/output/OutputDriverFactory.h

@@ -9,7 +9,7 @@
 #include "output/items/Solenoid.h"
 #include "output/items/Lamp.h"
 #include "output/items/Sound.h"
-#include "OutputPinController.h"
+#include "output/DisplayBoardPinController.h"
 
 #include "json/json.hpp"
 
@@ -25,20 +25,19 @@ namespace OutputDriverFactory
 
   namespace
   {
-    std::map<std::string, std::shared_ptr<items::ISolenoid>> create_solenoids(std::istream &solenoid_config, std::shared_ptr<OutputPinController> output_gpio_interface);
+    std::map<std::string, std::shared_ptr<items::ISolenoid>> create_solenoids(std::istream &solenoid_config, std::shared_ptr<DriverBoardPinController> &pin_controller);
-    std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<OutputPinController> output_gpio_interface, std::chrono::milliseconds deactivation_time);
+    std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<DriverBoardPinController> pin_controller, std::chrono::milliseconds deactivation_time);
 
-    std::map<std::string, std::shared_ptr<items::ILamp>> create_lamps(std::istream &lamp_config, std::shared_ptr<OutputPinController> output_gpio_interface);
+    std::map<std::string, std::shared_ptr<items::ILamp>> create_lamps(std::istream &lamp_config, std::shared_ptr<DriverBoardPinController> &pin_controller);
-    std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<OutputPinController> output_gpio_interface);
+    std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<DriverBoardPinController> pin_controller);
 
-    std::map<std::string, std::shared_ptr<items::ISound>> create_sounds(std::istream &sound_config, std::shared_ptr<OutputPinController> output_gpio_interface);
+    std::map<std::string, std::shared_ptr<items::ISound>> create_sounds(std::istream &sound_config, std::shared_ptr<SoundBoardPinController> &pin_controller);
-    std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<OutputPinController> output_gpio_interface, std::chrono::milliseconds deactivation_time);
+    std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<SoundBoardPinController> pin_controller, std::chrono::milliseconds deactivation_time);
 
     std::chrono::milliseconds get_deactivation_time(nlohmann::json &json);
 
-    std::map<char, std::shared_ptr<items::IDisplay>> create_displays(std::istream &display_config, std::shared_ptr<OutputPinController> output_gpio_interface);
+    std::map<char, std::shared_ptr<items::IDisplay>> create_displays(std::istream &display_config);
 
-    OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_config);
     std::map<std::string, uint8_t> parse_pins_driver_board(nlohmann::json &driver_board_config);
     std::map<std::string, uint8_t> parse_pins_sound_board(nlohmann::json &sound_board_config);
     std::map<std::string, uint8_t> parse_pins_display_board(nlohmann::json &display_board_config);

FlippR-Driver/src/output/OutputPinController.cpp

@@ -0,0 +1,34 @@
+/*
+ * OutputGPIOInterface.h
+ *
+ *  Created on: May 31, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#include "OutputPinController.h"
+
+#include "utility/config.h"
+
+#include <mcp23017.h>
+
+namespace flippR_driver
+{
+namespace output
+{
+
+void OutputPinController::initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base)
+{
+  mcp23017Setup(pin_base, i2c_address);
+}
+
+void OutputPinController::initialize_pins_output(const uint8_t &pin_base)
+{
+  // Since this are all outputs we just initialize everything as output conveniently
+  for(int i = 0; i < 16; i++)
+  {
+    PinController::initialize_output_pin(pin_base + i);
+  }
+}
+
+}
+}

FlippR-Driver/src/output/OutputPinController.h

@@ -8,34 +8,24 @@
 #ifndef SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
 #define SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
 
-#include "output/OutputPinController.h"
 #include "PinController.h"
 
-#include <mcp23017.h>
-#include <mutex>
-#include <map>
-
 namespace flippR_driver
 {
 namespace output
 {
-namespace impl
-{
 
-class OutputGPIOInterface : public PinController
+class OutputPinController : public PinController
 {
 
 public:
-  OutputGPIOInterface();
+  virtual ~OutputPinController() = default;
-
-  ~OutputGPIOInterface() override = default;
 
 protected:
   static void initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base);
   static void initialize_pins_output(const uint8_t &pin_base);
 };
 
-}
 }
 }
 

FlippR-Driver/src/output/SoundBoardPinController.h

@@ -2,16 +2,20 @@
 // Created by rhetenor on 14.12.18.
 //
 
-#ifndef FLIPPR_DRIVER_SOUNDPINCONTROLLER_H
+#ifndef FLIPPR_DRIVER_OUTPUT_SOUNDBOARDPINCONTROLLER_H
-#define FLIPPR_DRIVER_SOUNDPINCONTROLLER_H
+#define FLIPPR_DRIVER_OUTPUT_SOUNDBOARDPINCONTROLLER_H
 
-#include <output/items/Sound.h>
+#include "output/items/Sound.h"
 
 namespace flippR_driver
 {
 namespace output
 {
 
+namespace items
+{
+  class Sound;
+}
 class SoundBoardPinController
 {
 public:

FlippR-Driver/src/output/impl/DisplayController.cpp

@@ -16,8 +16,8 @@ namespace output
 namespace impl
 {
 
-DisplayController::DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<DisplayBoardPinController> output_gpio_interface)
+DisplayController::DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller)
-: displays(std::move(displays)), pin_controller(std::move(output_gpio_interface)), is_running(true)
+: displays(std::move(displays)), pin_controller(std::move(pin_controller)), is_running(true)
 {
   this->display_cycle_thread = std::thread(&DisplayController::cycle_displays, this);
 

FlippR-Driver/src/output/impl/DisplayController.h

@@ -26,7 +26,7 @@ namespace impl
 class DisplayController : public output::DisplayController
 {
 public:
-	explicit DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<DisplayBoardPinController> output_gpio_interface);
+	explicit DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller);
 	~DisplayController() override;
 
 private:

FlippR-Driver/src/output/impl/DriverBoardPinController.h

@@ -7,7 +7,9 @@
 
 #include "output/DriverBoardPinController.h"
 
-#include "OutputPinController.h"
+#include "output/OutputPinController.h"
+
+#include <output/items/DriverBoardItem.h>
 
 #include <map>
 #include <memory>

FlippR-Driver/src/output/impl/OutputDriver.cpp

@@ -19,8 +19,8 @@ namespace impl
 
 using namespace items;
 
-OutputDriver::OutputDriver(std::map<std::string, std::shared_ptr<ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<ILamp>> lamps, std::map<std::string, std::shared_ptr<ISound>> sounds, std::map<char, std::shared_ptr<IDisplay>> displays)
+OutputDriver::OutputDriver(std::unique_ptr<output::DisplayController> display_controller, std::map<std::string, std::shared_ptr<ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<ILamp>> lamps, std::map<std::string, std::shared_ptr<ISound>> sounds, std::map<char, std::shared_ptr<IDisplay>> displays)
-: solenoids(std::move(solenoids)), lamps(std::move(lamps)), sounds(std::move(sounds)), displays(std::move(displays))
+: display_controller(std::move(display_controller)), solenoids(std::move(solenoids)), lamps(std::move(lamps)), sounds(std::move(sounds)), displays(std::move(displays))
 {}
 
 std::vector<std::shared_ptr<ISound>> OutputDriver::get_sounds()

FlippR-Driver/src/output/impl/OutputDriver.h

@@ -9,6 +9,7 @@
 #define _SRC_OUTPUT_OUTPUTDRIVER_H_
 
 #include "output/OutputDriver.h"
+#include "output/DisplayController.h"
 
 #include <map>
 
@@ -22,7 +23,7 @@ namespace impl
 class OutputDriver : public output::OutputDriver
 {
 public:
-  OutputDriver(std::map<std::string, std::shared_ptr<items::ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<items::ILamp>> lamps, std::map<std::string, std::shared_ptr<items::ISound>> sounds, std::map<char, std::shared_ptr<items::IDisplay>> displays);
+  OutputDriver(std::unique_ptr<output::DisplayController> display_controller, std::map<std::string, std::shared_ptr<items::ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<items::ILamp>> lamps, std::map<std::string, std::shared_ptr<items::ISound>> sounds, std::map<char, std::shared_ptr<items::IDisplay>> displays);
 
   ~OutputDriver() override = default;
   // todo what is flipper_relay ?
@@ -37,6 +38,8 @@ public:
   boost::optional<std::shared_ptr<items::IDisplay>> get_display(char number) override;
 
 private:
+  std::unique_ptr<output::DisplayController> display_controller;
+
   const std::map<std::string, std::shared_ptr<items::ILamp>> lamps;
   const std::map<std::string, std::shared_ptr<items::ISolenoid>> solenoids;
   const std::map<std::string, std::shared_ptr<items::ISound>> sounds;

FlippR-Driver/src/output/impl/OutputPinController.cpp

@@ -1,51 +0,0 @@
-/*
- * OutputGPIOInterface.h
- *
- *  Created on: May 31, 2018
- *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
- */
-
-#include "OutputPinController.h"
-
-#include "utility/config.h"
-
-namespace flippR_driver
-{
-namespace output
-{
-namespace impl
-{
-
-using namespace output::items;
-
-OutputGPIOInterface::OutputGPIOInterface(std::map<std::string, uint8_t> pins_driver_board, std::map<std::string, uint8_t> pins_sound, std::map<std::string, uint8_t> pins_display)
-  : pins_driver_board(std::move(pins_driver_board)), pins_sound(std::move(pins_sound)), pins_display(std::move(pins_display))
-{
-  initialize_i2c_addresses();
-
-  initialize_pins();
-}
-
-void OutputGPIOInterface::initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base)
-{
-  mcp23017Setup(pin_base, i2c_address);
-}
-
-void OutputGPIOInterface::initialize_pins_output(const uint8_t &pin_base)
-{
-  // Since this are all outputs we just initialize everything as output conveniently
-  for(int i = 0; i < 16; i++)
-  {
-    PinController::initialize_output_pin(pin_base + i);
-  }
-}
-
-
-
-
-
-
-
-
-}
-}

FlippR-Driver/src/output/impl/SoundBoardPinController.cpp

@@ -17,7 +17,7 @@ SoundBoardPinController::SoundBoardPinController(std::map<std::string, uint8_t>
 
 }
 
-void SoundBoardPinController::activate(items::Sound &sound)
+void SoundBoardPinController::activate(const items::Sound &sound)
 {
   std::lock_guard<std::mutex> guard(*output_item_mutex);
 
@@ -26,7 +26,7 @@ void SoundBoardPinController::activate(items::Sound &sound)
   fire_sound(true);
 }
 
-void SoundBoardPinController::deactivate(items::Sound &sound)
+void SoundBoardPinController::deactivate(const items::Sound &sound)
 {
   std::lock_guard<std::mutex> guard(*output_item_mutex);
 
@@ -36,7 +36,7 @@ void SoundBoardPinController::deactivate(items::Sound &sound)
 }
 
 
-void SoundBoardPinController::write_sound_address(uint8_t address)
+void SoundBoardPinController::write_sound_address(const uint8_t address)
 {
   write_pin(pins_sound.at("A"), address & 0b0000001u);
   write_pin(pins_sound.at("B"), address & 0b0000010u);
@@ -47,12 +47,12 @@ void SoundBoardPinController::write_sound_address(uint8_t address)
   write_pin(pins_sound.at("G"), address & 0b1000000u);
 }
 
-void SoundBoardPinController::fire_sound(bool fire)
+void SoundBoardPinController::fire_sound(const bool fire)
 {
   PinController::write_pin(pins_sound.at("fire"), fire);
 }
 
-void SoundBoardPinController::write_pin(uint8_t pin, bool value)
+void SoundBoardPinController::write_pin(const uint8_t pin, const bool value)
 {
   PinController::write_pin(pins_sound.at("pin_base") + pin, value);
 }

FlippR-Driver/src/output/impl/SoundBoardPinController.h

@@ -2,12 +2,14 @@
 // Created by rhetenor on 14.12.18.
 //
 
-#ifndef FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H
+#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_SOUNDBOARDPINCONTROLLER_H
-#define FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H
+#define FLIPPR_DRIVER_OUTPUT_IMPL_SOUNDBOARDPINCONTROLLER_H
 
 #include "output/SoundBoardPinController.h"
 
-#include "OutputPinController.h"
+#include "output/OutputPinController.h"
+
+#include <output/items/Sound.h>
 
 #include <map>
 namespace flippR_driver
@@ -27,10 +29,10 @@ public:
   void deactivate(const items::Sound &sound) override;
 
 private:
-  void write_sound_address(uint8_t address);
+  void write_sound_address(const uint8_t address);
-  void fire_sound(bool fire);
+  void fire_sound(const bool fire);
 
-  void write_pin(uint8_t pin, bool value);
+  void write_pin(const uint8_t pin, const bool value);
 
 private:
   std::shared_ptr<std::mutex> output_item_mutex;

FlippR-Driver/src/output/items/DriverBoardItem.h

@@ -7,6 +7,8 @@
 
 #include "output/items/Item.h"
 
+#include <output/DriverBoardPinController.h>
+
 #include <cstdint>
 
 namespace flippR_driver
@@ -19,10 +21,13 @@ namespace items
 class DriverBoardItem : public Item
 {
 public:
-  DriverBoardItem(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name) :
+  DriverBoardItem(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name) :
-  Item(std::move(output_gpio_interface), address, std::move(name)) {}
+  pin_controller(std::move(pin_controller)), Item(address, std::move(name)) {}
 
   ~DriverBoardItem() override = default;
+
+protected:
+  const std::shared_ptr<DriverBoardPinController> pin_controller;
 };
 
 }

FlippR-Driver/src/output/items/Item.cpp

@@ -12,10 +12,8 @@ namespace output
 namespace items
 {
 
-Item::Item(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address,  std::string name) :
+Item::Item(uint8_t address,  std::string name) :
-  address(address),
+  address(address), name(std::move(name))
-  name(std::move(name)),
-  gpio_interface(std::move(output_gpio_interface))
 {}
 
 uint8_t Item::get_address()

FlippR-Driver/src/output/items/Item.h

@@ -18,15 +18,13 @@ namespace flippR_driver
 namespace output
 {
 
-class OutputPinController;
-
 namespace items
 {
 
 class Item : public IItem
 {
 public:
-  Item(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name);
+  Item(uint8_t address, std::string name);
   ~Item() override = default;
 
   uint8_t get_address() override;
@@ -36,8 +34,6 @@ protected:
   const uint8_t address;
   const std::string name;
 
-  const std::shared_ptr<OutputPinController> gpio_interface;
-
 };
 
 }

FlippR-Driver/src/output/items/Lamp.cpp

@@ -15,18 +15,18 @@ namespace output
 namespace items
 {
 
-Lamp::Lamp(std::shared_ptr<OutputPinController> output_gpio_interface,  uint8_t address, std::string name) :
+Lamp::Lamp(std::shared_ptr<DriverBoardPinController> pin_controller,  uint8_t address, std::string name) :
-DriverBoardItem(std::move(output_gpio_interface), address, std::move(name)), activated(false)
+DriverBoardItem(std::move(pin_controller), address, std::move(name)), activated(false)
 {}
 
 void Lamp::activate()
 {
-  gpio_interface->activate(this);
+  pin_controller->activate(this);
 }
 
 void Lamp::deactivate()
 {
-  gpio_interface->deactivate(this);
+  pin_controller->deactivate(this);
 }
 
 }

FlippR-Driver/src/output/items/Lamp.h

@@ -21,7 +21,7 @@ namespace items
 class Lamp : public DriverBoardItem, public ILamp
 {
 public:
-  Lamp(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name);
+  Lamp(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name);
   ~Lamp() override = default;
 
   void activate() override;

FlippR-Driver/src/output/items/Solenoid.cpp

@@ -16,17 +16,17 @@ namespace output
 namespace items
 {
 
-Solenoid::Solenoid(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time):
+Solenoid::Solenoid(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time):
-  DriverBoardItem(std::move(output_gpio_interface), address, std::move(name)), deactivation_time(deactivation_time)
+  DriverBoardItem(std::move(pin_controller), address, std::move(name)), deactivation_time(deactivation_time)
 {}
 
 void Solenoid::triggerTask()
 {
-  gpio_interface->activate(this);
+  pin_controller->activate(this);
 
   std::this_thread::sleep_for(deactivation_time);
 
-  gpio_interface->deactivate(this);
+  pin_controller->deactivate(this);
 }
 
 void Solenoid::trigger()

FlippR-Driver/src/output/items/Solenoid.h

@@ -24,7 +24,7 @@ namespace items
 class Solenoid : public DriverBoardItem, public ISolenoid
 {
 public:
-  Solenoid(std::shared_ptr<OutputPinController> output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time);
+  Solenoid(std::shared_ptr<DriverBoardPinController> pin_controller, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time);
   ~Solenoid() override = default;
 
   void trigger() override;

FlippR-Driver/src/output/items/Sound.cpp

@@ -7,7 +7,7 @@
 
 #include "Sound.h"
 
-#include "output/OutputPinController.h"
+#include <output/SoundBoardPinController.h>
 
 namespace flippR_driver
 {
@@ -16,8 +16,8 @@ namespace output
 namespace items
 {
 
-Sound::Sound(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id) :
+Sound::Sound(std::shared_ptr<SoundBoardPinController> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id) :
-  Item(std::move(output_gpio_interface), address, std::move(name)), deactivation_time(deactivation_time), id(id)
+  pin_controller(std::move(pin_controller)), Item(address, std::move(name)), deactivation_time(deactivation_time), id(id)
 {}
 
 void Sound::play()
@@ -27,11 +27,11 @@ void Sound::play()
 
 void Sound::playTask()
 {
-  gpio_interface->activate(this);
+  pin_controller->activate(this);
 
   std::this_thread::sleep_for(deactivation_time);
 
-  gpio_interface->deactivate(this);
+  pin_controller->deactivate(this);
 }
 
 }

FlippR-Driver/src/output/items/Sound.h

@@ -20,6 +20,9 @@ namespace flippR_driver
 {
 namespace output
 {
+
+class SoundBoardPinController;
+
 namespace items
 {
 
@@ -29,12 +32,14 @@ public:
 	u_int id;
 
 public:
-	Sound(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id);
+	Sound(std::shared_ptr<SoundBoardPinController> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id);
 	~Sound() override = default;
 
 	void play() override;
 
 private:
+	const std::shared_ptr<SoundBoardPinController> pin_controller;
+
 	std::chrono::milliseconds deactivation_time;
 
 	std::future<void> play_task;