Did some further adaptions to new board layout.

FlippR-Driver/contrib/json_example/output/Solenoid_Config.json

@@ -1,5 +1,5 @@
 {
-  "port_extender" : 
+  "port_extenders" : 
   [
     "name" : "extender_0",
     "i2c_address" : 32,
@@ -20,9 +20,11 @@
   "solenoids" :
   [
     {
+      "_comment" :"addresses relative to port_extender",
       "address" : 79,
       "name" : "Out Hole",
-      "deactivation_time_milliseconds" : 15
+      "deactivation_time_milliseconds" : 15,
+      "extender" : "extender_0"
     },
     {
       "address" : 82,

FlippR-Driver/src/PinController.h

@@ -12,6 +12,7 @@
 
 #include <mutex>
 #include <fstream>
+
 namespace flippR_driver
 {
 
@@ -21,11 +22,11 @@ public:
   PinController();
   virtual ~PinController() = default;
 
+  static void initialize_output_pin(const uint8_t address);
+
 protected:
   static void initialize_input_pin(uint8_t address);
 
-  static void initialize_output_pin(const uint8_t address);
-
   static void write_pin(uint8_t address, bool value);
 
   static bool read_pin(uint8_t address);

FlippR-Driver/src/output/DriverBoardPinController.h

@@ -7,6 +7,8 @@
 
 #include "OutputPinController.h"
 
+#include <memory>
+
 namespace flippR_driver
 {
 namespace output
@@ -22,8 +24,16 @@ class DriverBoardPinController : public OutputPinController
 public:
   virtual ~DriverBoardPinController() = default;
 
-  virtual void activate(items::DriverBoardItem &driver_board_item) = 0;
+  DriverBoardPinController(std::shared_ptr<std::mutex> output_item_mutex);
-  virtual void deactivate(items::DriverBoardItem &driver_board_item) = 0;
+
+  void activate(items::DriverBoardItem & driver_board_item);
+  void deactivate(items::DriverBoardItem & driver_board_item);
+
+private:
+  void write_pin(uint8_t pin, bool value) const;
+
+private:
+  std::shared_ptr<std::mutex> output_item_mutex;
 };
 
 }

FlippR-Driver/src/output/OutputDriverFactory.cpp

@@ -45,10 +45,8 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream& output_pin_config,
   json output_config;
   output_pin_config >> output_config;
 
-
-  //TODO new board layout
   json driver_board_config = output_config.at("driver_board");
-  std::shared_ptr<DriverBoardPinController> driver_board_pin_controller(new detail::DriverBoardPinController(parse_pins_driver_board(driver_board_config), output_pin_mutex));
+  std::shared_ptr<DriverBoardPinController> driver_board_pin_controller(new detail::DriverBoardPinController(output_pin_mutex));
   auto solenoids = create_solenoids(solenoid_config, driver_board_pin_controller);
   auto lamps = create_lamps(lamp_config, driver_board_pin_controller);
 
@@ -67,37 +65,6 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream& output_pin_config,
   return std::make_shared<detail::OutputDriver>(std::move(display_controller), solenoids, lamps, sounds, display_map);
 }
 
-std::map<std::string, uint8_t> parse_pins_driver_board(json &driver_board_config)
-{
-  std::map<std::string, uint8_t> pins_driver_board;
-
-  try
-  {
-    pins_driver_board["i2c_address"] = driver_board_config.at("i2c_address").get<uint8_t>();
-    pins_driver_board["pin_base"] = driver_board_config.at("pin_base").get<uint8_t>();
-    pins_driver_board["data"] = driver_board_config.at("data").get<uint8_t>();
-    pins_driver_board["CL"] = driver_board_config.at("CL").get<uint8_t>();
-
-    json pin_select = driver_board_config.at("pin-select");
-    pins_driver_board["pin-select-A"] = pin_select.at("A").get<uint8_t>();
-    pins_driver_board["pin-select-B"] = pin_select.at("B").get<uint8_t>();
-    pins_driver_board["pin-select-C"] = pin_select.at("C").get<uint8_t>();
-
-    json latch_select = driver_board_config.at("latch-select");
-    pins_driver_board["mux1"] = latch_select.at("mux1").get<uint8_t>();
-    pins_driver_board["mux2"] = latch_select.at("mux2").get<uint8_t>();
-    pins_driver_board["latch-select-A"] = latch_select.at("A").get<uint8_t>();
-    pins_driver_board["latch-select-B"] = latch_select.at("B").get<uint8_t>();
-    pins_driver_board["latch-select-C"] = latch_select.at("C").get<uint8_t>();
-  }
-  catch(json::exception &e)
-  {
-    CLOG(ERROR, OUTPUT_LOGGER) << "Output pin config file at driver_board  corrupted: " << e.what();
-    exit(EXIT_FAILURE);
-  }
-  return pins_driver_board;
-}
-
 std::map<std::string, uint8_t> parse_pins_sound_board(json &sound_board_config)
 {
   std::map<std::string, uint8_t> pins_sound;
@@ -166,6 +133,8 @@ std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::is
 
   auto deactivation_time = get_deactivation_time(solenoid_config_json);
 
+  initialize_port_extenders(solenoid_config_json, output_gpio_interface);
+
   json solenoids_json;
 
   try
@@ -291,6 +260,26 @@ std::map<std::string, std::shared_ptr<items::Sound>> create_sounds(std::istream
   return sounds;
 }
 
+void initialize_port_extenders(nlohmann::json &json_stream, std::shared_ptr<DriverBoardPinController> &pin_controller)
+{
+  json port_extenders;
+
+  try
+  {
+    port_extenders = json_stream.at("port_extenders");
+  }
+  catch (json::exception & e)
+  {
+    CLOG(ERROR, OUTPUT_LOGGER) << "Output solenoids config file corrupted: Key \"port_extenders\" of type array needed. \n" << e.what();
+    exit(EXIT_FAILURE);
+  }
+
+  for (auto & extender_json : port_extenders)
+  {
+    pin_controller->initialize_port_expander(extender_json.at("i2c_address").get<uint8_t>(), extender_json.at("pin_base").get<uint8_t>());
+  }
+}
+
 std::chrono::milliseconds get_deactivation_time(nlohmann::json &json)
 {
   try
@@ -309,8 +298,14 @@ std::shared_ptr<items::detail::Solenoid> create_solenoid(nlohmann::json &solenoi
 {
   try
   {
+    uint8_t address = 0;
+    if(solenoid_json.find("extender") != solenoid_json.end())
+    {
+      address += solenoid_json.at("extender").get<uint8_t>();
+    }
+
     std::string name = solenoid_json.at("name");
-    auto address = solenoid_json.at("address").get<uint8_t>();
+    address += solenoid_json.at("address").get<uint8_t>();
 
     if(solenoid_json.find("deactivation_time_milliseconds") != solenoid_json.end())
     {

FlippR-Driver/src/output/OutputDriverFactory.h

@@ -42,13 +42,14 @@ namespace OutputDriverFactory
   std::map<std::string, std::shared_ptr<items::Sound>> create_sounds(std::istream &sound_config, std::shared_ptr<SoundBoardPinController> &pin_controller);
   std::shared_ptr<items::detail::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<SoundBoardPinController> &pin_controller, std::chrono::milliseconds &deactivation_time);
 
+  void initialize_port_extenders(nlohmann::json &json, std::shared_ptr<DriverBoardPinController> &pin_controller);
+
   std::chrono::milliseconds get_deactivation_time(nlohmann::json &json);
 
   std::vector<std::shared_ptr<items::OutputDisplay>> create_displays(std::istream &display_config);
   std::map<uint8_t, std::shared_ptr<items::Display>> map_displays(const std::vector<std::shared_ptr<items::OutputDisplay>> &displays);
   std::shared_ptr<items::OutputDisplay> create_display(nlohmann::json &display_json);
 
-  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

@@ -16,18 +16,17 @@ namespace flippR_driver
 namespace output
 {
 
-void OutputPinController::initialize_i2c_address(uint8_t i2c_address, uint8_t pin_base)
+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(uint8_t pin_base, std::map<std::string, uint8_t>::iterator begin, std::map<std::string, uint8_t>::iterator end)
+void OutputPinController::initialize_port_expander(const uint8_t i2c_address, const uint8_t pin_base)
 {
-  for(; begin != end; begin++)
+  mcp23017Setup(pin_base, i2c_address);
-  {
-    initialize_output_pin(pin_base + begin->second);
-  }
 }
 
+
+
 }
 }

FlippR-Driver/src/output/OutputPinController.h

@@ -27,9 +27,12 @@ class OutputPinController : public PinController
 public:
   virtual ~OutputPinController() = default;
 
+  void initialize_port_expander(const uint8_t i2c_address, const uint8_t pin_base);
+
 protected:
-  static void initialize_i2c_address(uint8_t i2c_address, uint8_t pin_base);
+  static void initialize_i2c_address(const uint8_t i2c_address, const uint8_t pin_base);
-  static void initialize_pins_output(uint8_t pin_base, std::map<std::string, uint8_t>::iterator begin, std::map<std::string, uint8_t>::iterator end);
+  static void initialize_pins_output(const uint8_t pin_base, std::map<std::string, uint8_t>::iterator begin, std::map<std::string, uint8_t>::iterator end);
+
 };
 
 }

FlippR-Driver/src/output/detail/DriverBoardPinController.cpp

@@ -12,19 +12,12 @@ namespace flippR_driver
 {
 namespace output
 {
-namespace detail
+
+DriverBoardPinController::DriverBoardPinController(std::shared_ptr<std::mutex> output_item_mutex) :
+  output_item_mutex(std::move(output_item_mutex))
 {
 
-DriverBoardPinController::DriverBoardPinController(std::map<std::string, uint8_t> pins_driver_board, std::shared_ptr<std::mutex> output_item_mutex) :
+  CLOG(INFO, OUTPUT_LOGGER) << "Created DriverBoardPinController.";
-  pins_driver_board(std::move(pins_driver_board)), output_item_mutex(std::move(output_item_mutex))
-{
-  uint8_t i2c_address = pins_driver_board.at("i2c_address");
-  uint8_t pin_base = pins_driver_board.at("pin_base");
-
-
-  initialize_pins_output(pin_base, pins_driver_board.begin(), pins_driver_board.end());
-
-  CLOG(INFO, OUTPUT_LOGGER) << "Created DriverBoardPinController with i2c_address 0x" << std::hex << i2c_address << " and pin_base " << std::dec << pin_base;
 }
 
 void DriverBoardPinController::activate(items::DriverBoardItem &driver_board_item)
@@ -43,9 +36,8 @@ void DriverBoardPinController::deactivate(items::DriverBoardItem &driver_board_i
 
 void DriverBoardPinController::write_pin(uint8_t pin, bool value) const
 {
-  PinController::write_pin(pins_driver_board.at("pin_base") + pin, value);
+  PinController::write_pin(pin, value);
 }
 
-}
 }
 }

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

@@ -1,46 +0,0 @@
-//
-// Created by rhetenor on 14.12.18.
-//
-
-#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_DRIVERBOARDPINCONTROLLER_H
-#define FLIPPR_DRIVER_OUTPUT_IMPL_DRIVERBOARDPINCONTROLLER_H
-
-#include "output/DriverBoardPinController.h"
-
-#include <map>
-#include <memory>
-#include <mutex>
-
-namespace flippR_driver
-{
-namespace output
-{
-namespace detail
-{
-
-class DriverBoardPinController : public output::DriverBoardPinController
-{
-public:
-  DriverBoardPinController(std::map<std::string, uint8_t> pins_driver_board, std::shared_ptr<std::mutex> output_item_mutex);
-  ~DriverBoardPinController() override = default;
-
-  void activate(items::DriverBoardItem & driver_board_item) override;
-  void deactivate(items::DriverBoardItem & driver_board_item) override;
-
-  void initialize_port_expander(const uint8_t i2c_address, const uint8_t pin_base);
-  void initialize_pin(const uint8_t address);
-
-private:
-  void write_pin(uint8_t pin, bool value) const;
-
-private:
-  std::shared_ptr<std::mutex> output_item_mutex;
-
-  const std::map<std::string, uint8_t> pins_driver_board;
-};
-
-}
-}
-}
-
-#endif //FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H

FlippR-Driver/src/output/items/detail/DriverBoardItem.cpp

@@ -6,9 +6,11 @@
 
 using namespace flippR_driver::output;
 
-items::detail::DriverBoardItem::DriverBoardItem(const uint8_t address, const uint8_t pin_base) :
+items::detail::DriverBoardItem::DriverBoardItem(std::shared_ptr<PinController> pin_controller, const uint8_t address, const uint8_t pin_base) :
   address(pin_base + address)
-{}
+{
+  pin_controller->initialize_output_pin(this->address);
+}
 
 uint8_t items::detail::DriverBoardItem::get_address() const
 {

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

@@ -21,7 +21,7 @@ namespace detail
 class DriverBoardItem : public output::items::DriverBoardItem
 {
 public:
-  DriverBoardItem(const uint8_t address, const uint8_t pin_base);
+  DriverBoardItem(std::shared_ptr<PinController> pin_controller, const uint8_t address, const uint8_t pin_base);
 
   ~DriverBoardItem() override = default;
 

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

@@ -20,7 +20,7 @@ namespace detail
 {
 
 Lamp::Lamp(std::shared_ptr<DriverBoardPinController> pin_controller, const uint8_t address, const uint8_t pin_base, const std::string name) :
-detail::Item(std::move(name)), DriverBoardItem(address, pin_base), pin_controller(std::move(pin_controller)), activated(false)
+detail::Item(std::move(name)), DriverBoardItem(pin_controller, address, pin_base), pin_controller(std::move(pin_controller)), activated(false)
 {
   CLOG(INFO, OUTPUT_LOGGER) << "Created lamp " << name << " with address " << address;
 }

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

@@ -19,7 +19,7 @@ namespace detail
 {
 
 Solenoid::Solenoid(std::shared_ptr<DriverBoardPinController> pin_controller, const uint8_t address, const uint8_t pin_base, const std::string name, std::chrono::milliseconds deactivation_time)
-: detail::Item(std::move(name)), DriverBoardItem(address, pin_base), pin_controller(std::move(pin_controller)), deactivation_time(deactivation_time)
+: detail::Item(std::move(name)), DriverBoardItem(pin_controller, address, pin_base), pin_controller(pin_controller), deactivation_time(deactivation_time)
 {
   CLOG(INFO, OUTPUT_LOGGER) << "Created solenoid " << name << " with address " << address;
 }

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

@@ -21,7 +21,7 @@ namespace detail
 {
 
 Sound::Sound(std::shared_ptr<SoundBoardPinController> pin_controller, const uint8_t address, const uint8_t pin_base, const std::string name, std::chrono::milliseconds deactivation_time, u_int id)
-: detail::Item(std::move(name)), DriverBoardItem(address, pin_base), pin_controller(std::move(pin_controller)), deactivation_time(deactivation_time), id(id)
+: detail::Item(std::move(name)), DriverBoardItem(pin_controller, address, pin_base), pin_controller(std::move(pin_controller)), deactivation_time(deactivation_time), id(id)
 {
   CLOG(INFO, OUTPUT_LOGGER) << "Created sound " << id << " with name " << name << " and address " << address;
 }