refactor outputdriverfactory

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

@@ -13,6 +13,7 @@
         "address" : 13,
         "extender" : "extender_0"
     },
+    "address_pins" : [ 15, 14, 12, 10, 8, 9, 11 ],
     "sounds" :
     [
       {

FlippR-Driver/src/output/OutputDriverFactory.cpp

@@ -23,7 +23,15 @@ namespace OutputDriverFactory
 {
 
 using namespace nlohmann;
-
+namespace config {
+namespace
+{
+json solenoids;
+json lamps;
+json sounds;
+json displays;
+}
+}
 std::shared_ptr<OutputDriver> get_OutputDriver(std::istream& solenoid_config,
                                                std::istream& lamp_config,
                                                std::istream& sound_config,
@@ -31,38 +39,37 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream& solenoid_config,
 {
   utility::LoggerFactory::CreateOutputLogger();
 
+  solenoid_config >> config::solenoids;
+  lamp_config >> config::lamps;
+  sound_config >> config::sounds;
+  display_config >> config::displays;
+
   auto output_pin_mutex = std::make_shared<std::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 flippers = create_flippers(solenoid_config, driver_board_pin_controller);
-  auto lamps = create_lamps(lamp_config, driver_board_pin_controller);
 
-  uint8_t sound_fire_address = get_sound_fire_address(sound_config);
+  auto solenoids = create_solenoids(driver_board_pin_controller);
+  auto flippers = create_flippers(driver_board_pin_controller);
+  auto lamps = create_lamps(driver_board_pin_controller);
 
-  std::shared_ptr<SoundBoardPinController> sound_board_pin_controller(new detail::SoundBoardPinController(output_pin_mutex, sound_fire_address));
+  auto sound_board_pin_controller = create_SoundBoardPinController();
-  auto sounds = create_sounds(sound_config, sound_board_pin_controller);
+  auto sounds = create_sounds(sound_board_pin_controller);
 
   std::unique_ptr<DisplayBoardPinController> display_board_pin_controller(new detail::DisplayBoardPinController(parse_pins_display_board(display_config)));
-  auto displays = create_displays(display_config);
+  auto displays = create_displays();
   std::unique_ptr<DisplayController> display_controller(new detail::DisplayController(displays, std::move(display_board_pin_controller)));
   auto display_map = map_displays(displays);
 
   return std::make_shared<OutputDriver>(std::move(display_controller), solenoids, lamps, sounds, flippers, display_map);
 }
 
-std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::istream & solenoid_config, std::shared_ptr<DriverBoardPinController> &pin_controller)
+std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::shared_ptr<DriverBoardPinController> &pin_controller)
 {
-  solenoid_config.clear();
+  json port_extenders = get_element("port_extenders", config::solenoids, "");
-  json solenoid_config_json;
-  solenoid_config >> solenoid_config_json;
-
-  json port_extenders = get_element("port_extenders", solenoid_config_json, "");
 
   initialize_port_extenders(port_extenders, pin_controller.get(), "solenoid_config.json");
 
-  json solenoids_json = get_element("solenoids", solenoid_config_json, "solenoid_config.json");
+  json solenoids_json = get_element("solenoids", config::solenoids, "solenoid_config.json");
-  std::chrono::milliseconds deactivation_time{ get_value<int>("deactivation_time_milliseconds", solenoid_config_json, "solenoid_config.json") };
+  std::chrono::milliseconds deactivation_time{ get_value<int>("deactivation_time_milliseconds", config::solenoids, "solenoid_config.json") };
 
   std::map<std::string, std::shared_ptr<items::Solenoid>> solenoids;
   for(auto &solenoid_json : solenoids_json)
@@ -75,8 +82,7 @@ std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::is
 
 std::shared_ptr<items::detail::Solenoid> create_solenoid(nlohmann::json &solenoid_json, nlohmann::json &port_extenders, std::shared_ptr<DriverBoardPinController> &pin_controller, std::chrono::milliseconds deactivation_time)
 {
-  solenoid_json;
+  std::string config_file_name = "config::solenoid.json";
-  std::string config_file_name = "solenoid_config.json";
 
   uint8_t pin_base = get_pin_base(solenoid_json, port_extenders, config_file_name);
 
@@ -91,17 +97,12 @@ std::shared_ptr<items::detail::Solenoid> create_solenoid(nlohmann::json &solenoi
     return std::make_shared<items::detail::Solenoid>(pin_controller, address, pin_base, name, deactivation_time);
 }
 
-std::map<std::string, std::shared_ptr<items::Flipper>> create_flippers(std::istream &solenoid_config, std::shared_ptr<DriverBoardPinController> &pin_controller)
+std::map<std::string, std::shared_ptr<items::Flipper>> create_flippers(std::shared_ptr<DriverBoardPinController> &pin_controller)
 {
-  solenoid_config.clear();
+  json port_extenders = get_element("port_extenders", config::solenoids, "solenoid_config.json");
-  solenoid_config.seekg(0, std::ios::beg);
-  json solenoid_config_json;
-  solenoid_config >> solenoid_config_json;
 
-  json port_extenders = get_element("port_extenders", solenoid_config_json, "solenoid_config.json");
+  json flippers_json = get_element("flippers", config::solenoids, "solenoid_config.json");
-
+  std::chrono::milliseconds deactivation_time{ get_value<int>("deactivation_time_milliseconds", config::solenoids, "solenoid_config.json") };
-  json flippers_json = get_element("flippers", solenoid_config_json, "solenoid_config.json");
-  std::chrono::milliseconds deactivation_time{ get_value<int>("deactivation_time_milliseconds", solenoid_config_json, "solenoid_config.json") };
 
   std::map<std::string, std::shared_ptr<items::Flipper>> flippers;
   for(auto &flipper_json : flippers_json)
@@ -125,17 +126,12 @@ std::shared_ptr<items::detail::Flipper> create_flipper(nlohmann::json &flipper_j
 
 std::map<std::string, std::shared_ptr<items::Lamp>> create_lamps(std::istream &lamp_config, std::shared_ptr<DriverBoardPinController> &pin_controller)
 {
-  lamp_config.clear();
+  json port_extenders = get_element("port_extenders", config::lamps, "lamp_config.json");
-  lamp_config.seekg(0, std::ios::beg);
-  json lamp_config_json;
-  lamp_config >> lamp_config_json;
-
-  json port_extenders = get_element("port_extenders", lamp_config_json, "lamp_config.json");
   initialize_port_extenders(port_extenders, pin_controller.get(), "lamp_config.json");
-  json lamp_json = get_element("lamps", lamp_config_json, "lamp_config.json");
+  json lamps_json = get_element("lamps", config::lamps, "lamp_config.json");
 
   std::map<std::string, std::shared_ptr<items::Lamp>> lamps;
-  for(auto &lamp_json : lamp_json)
+  for(auto &lamp_json : lamps_json)
   {
     auto lamp = create_lamp(lamp_json, port_extenders, pin_controller);
     lamps.emplace(lamp->get_name(), lamp);
@@ -156,15 +152,10 @@ std::shared_ptr<items::detail::Lamp> create_lamp(json &lamp_json, json & port_ex
 
 std::map<std::string, std::shared_ptr<items::Sound>> create_sounds(std::istream &sound_config, std::shared_ptr<SoundBoardPinController> &pin_controller)
 {
-  sound_config.clear();
+  json port_extenders = get_element("port_extenders", config::sounds, "sound_config.json");
-  sound_config.seekg(0, std::ios::beg);
-  json sound_config_json;
-  sound_config >> sound_config_json;
-
-  json port_extenders = get_element("port_extenders", sound_config_json, "sound_config.json");
   initialize_port_extenders(port_extenders, pin_controller.get(), "sound_config.json");
-  std::chrono::milliseconds deactivation_time{ get_value<int>("deactivation_time_milliseconds", sound_config_json, "solenoid_config.json") };
+  std::chrono::milliseconds deactivation_time{ get_value<int>("deactivation_time_milliseconds", config::sounds, "solenoid_config.json") };
-  json sounds_json = get_element("sounds", sound_config_json, "sound_config.json");
+  json sounds_json = get_element("sounds", config::sounds, "sound_config.json");
 
   std::map<std::string, std::shared_ptr<items::Sound>> sounds;
   for(auto &sound_json : sounds_json)
@@ -187,16 +178,11 @@ std::shared_ptr<items::detail::Sound> create_sound(json &sound_json, json &port_
   return std::make_shared<items::detail::Sound>(pin_controller, address, pin_base, name, deactivation_time, id);
 }
 
-uint8_t get_sound_fire_address(std::istream &sound_config)
+uint8_t get_sound_fire_address()
 {
-  sound_config.clear();
+  json port_extenders = get_element("port_extenders", config::sounds, "sound_config.json");
-  sound_config.seekg(0, std::ios::beg);
-  json sound_config_json;
-  sound_config >> sound_config_json;
 
-  json port_extenders = get_element("port_extenders", sound_config_json, "sound_config.json");
+  json fire_pin = get_element("fire_pin", config::sounds, "sound_config.json");
-
-  json fire_pin = get_element("fire_pin", sound_config_json, "sound_config.json");
   auto pin_base = get_pin_base(fire_pin, port_extenders, "sound_config.json");
   auto address = get_value<uint8_t>("address", fire_pin, "sound_config.json");
 
@@ -205,14 +191,9 @@ uint8_t get_sound_fire_address(std::istream &sound_config)
 
 std::map<std::string, uint8_t> parse_pins_display_board(std::istream &display_config)
 {
-  display_config.clear();
-  display_config.seekg(0, std::ios::beg);
   std::string config_file = "display_config.json";
 
-  json display_config_json;
+  json display_board_config = get_element("display_board", config::displays, config_file);
-  display_config >> display_config_json;
-
-  json display_board_config = get_element("display_board", display_config_json, config_file);
 
   std::map<std::string, uint8_t> pins_display;
 
@@ -240,12 +221,7 @@ std::map<std::string, uint8_t> parse_pins_display_board(std::istream &display_co
 
 std::vector<std::shared_ptr<items::OutputDisplay>> create_displays(std::istream &display_config)
 {
-  display_config.clear();
+  json displays_json = get_element("displays", config::displays, "display_config.json");
-  display_config.seekg(0, std::ios::beg);
-  json display_config_json;
-  display_config >> display_config_json;
-
-  json displays_json = get_element("displays", display_config_json, "display_config.json");
 
   std::vector<std::shared_ptr<items::OutputDisplay>> displays;
   for(json &display_json : displays_json)

FlippR-Driver/src/output/OutputDriverFactory.h

@@ -28,21 +28,22 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream& solenoid_config,
                                                   std::istream& sound_config,
                                                   std::istream& display_config);
 
-std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::istream& solenoid_config, std::shared_ptr<DriverBoardPinController> &driverBoardPinController);
+std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::shared_ptr<DriverBoardPinController> &driverBoardPinController);
 std::shared_ptr<items::detail::Solenoid> create_solenoid(nlohmann::json &solenoid_json, nlohmann::json &port_extenders, std::shared_ptr<DriverBoardPinController> &pin_controller, std::chrono::milliseconds deactivation_time);
 
-std::map<std::string, std::shared_ptr<items::Flipper>> create_flippers(std::istream &solenoid_config, std::shared_ptr<DriverBoardPinController> &pin_controller);
+std::map<std::string, std::shared_ptr<items::Flipper>> create_flippers(std::shared_ptr<DriverBoardPinController> &pin_controller);
 std::shared_ptr<items::detail::Flipper> create_flipper(nlohmann::json &flipper_json, nlohmann::json &port_extenders, std::shared_ptr<DriverBoardPinController> &pin_controller);
 
-std::map<std::string, std::shared_ptr<items::Lamp>> create_lamps(std::istream &lamp_config, std::shared_ptr<DriverBoardPinController> &pin_controller);
+std::map<std::string, std::shared_ptr<items::Lamp>> create_lamps(std::shared_ptr<DriverBoardPinController> &pin_controller);
 std::shared_ptr<items::detail::Lamp> create_lamp(nlohmann::json &lamp_json, nlohmann::json & port_extenders, std::shared_ptr<DriverBoardPinController> &pin_controller);
 
-std::map<std::string, std::shared_ptr<items::Sound>> create_sounds(std::istream &sound_config, std::shared_ptr<SoundBoardPinController> &pin_controller);
+std::shared_ptr<SoundBoardPinController> create_SoundBoardPinController();
+std::map<std::string, std::shared_ptr<items::Sound>> create_sounds(std::shared_ptr<SoundBoardPinController> &pin_controller);
 std::shared_ptr<items::detail::Sound> create_sound(nlohmann::json &sound_json, nlohmann::json &port_extenders, std::shared_ptr<SoundBoardPinController> &pin_controller, std::chrono::milliseconds &deactivation_time);
 uint8_t get_sound_fire_address(std::istream &sound_config);
 
 std::map<std::string, uint8_t> parse_pins_display_board(std::istream & display_config);
-std::vector<std::shared_ptr<items::OutputDisplay>> create_displays(std::istream &display_config);
+std::vector<std::shared_ptr<items::OutputDisplay>> create_displays();
 std::shared_ptr<items::OutputDisplay> create_display(nlohmann::json &display_json);
 std::map<uint8_t, std::shared_ptr<items::Display>> map_displays(const std::vector<std::shared_ptr<items::OutputDisplay>> &displays);
 

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

@@ -14,9 +14,12 @@ namespace detail
 {
 
 SoundBoardPinController::SoundBoardPinController(std::shared_ptr<std::mutex> output_item_mutex,
-                                                 const uint8_t &fire_address) :
+                                                 uint8_t pin_base,
+                                                 uint8_t this->fire_address,
+                                                 const std::vector<uint8_t> this->address_pins) :
   output_item_mutex(output_item_mutex),
-  fire_address(fire_address)
+  this->fire_address(this->fire_address),
+  this->address_pins(this->address_pins)
 {
   CLOG(INFO, OUTPUT_LOGGER) << "Created SoundBoardPinController";
 }
@@ -42,28 +45,28 @@ void SoundBoardPinController::deactivate(const items::detail::Sound &sound)
 
 void SoundBoardPinController::write_sound_address(const uint8_t &address) const
 {
-  //  write_pin(pins_sound.at("A"), address & 0b0000001u);
+    write_pin(this->address_pins[0], address & 0b0000001u);
-  //  write_pin(pins_sound.at("B"), address & 0b0000010u);
+    write_pin(this->address_pins[1], address & 0b0000010u);
-  //  write_pin(pins_sound.at("C"), address & 0b0000100u);
+    write_pin(this->address_pins[2], address & 0b0000100u);
-  //  write_pin(pins_sound.at("D"), address & 0b0001000u);
+    write_pin(this->address_pins[3], address & 0b0001000u);
-  //  write_pin(pins_sound.at("E"), address & 0b0010000u);
+    write_pin(this->address_pins[4], address & 0b0010000u);
-  //  write_pin(pins_sound.at("F"), address & 0b0100000u);
+    write_pin(this->address_pins[5], address & 0b0100000u);
-  //  write_pin(pins_sound.at("G"), address & 0b1000000u);
+    write_pin(this->address_pins[6], address & 0b1000000u);
 }
 
 void SoundBoardPinController::fire_sound() const
 {
-  //  PinController::write_pin(pins_sound.at("fire"), true);
+    PinController::write_pin(this->fire_address, true);
-  //
+
-  //  PinController::write_pin(pins_sound.at("fire"), false);
+    PinController::write_pin(this->fire_address, false);
 }
 
 void SoundBoardPinController::write_pin(const uint8_t &pin, const bool &value) const
 {
-  //  PinController::write_pin(pins_sound.at("pin_base") + pin, value);
+    PinController::write_pin(this->pin_base + pin, value);
-  //  PinController::write_pin(pins_sound.at("fire"), true);
+    PinController::write_pin(this->fire_address, true);
-  //
+
-  //  PinController::write_pin(pins_sound.at("fire"), false);
+    PinController::write_pin(this->fire_address, false);
 }
 
 }

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

@@ -19,7 +19,7 @@ namespace detail
 class SoundBoardPinController : public output::SoundBoardPinController
 {
 public:
-  SoundBoardPinController(std::shared_ptr<std::mutex> output_item_mutex, const uint8_t & fire_address);
+  SoundBoardPinController(std::shared_ptr<std::mutex> output_item_mutex, uint8_t pin_base, uint8_t fire_address, const std::vector<uint8_t> address_pins);
   ~SoundBoardPinController() override = default;
 
   void activate(const items::detail::Sound &sound);
@@ -34,7 +34,9 @@ private:
 private:
   std::shared_ptr<std::mutex> output_item_mutex;
 
+  uint8_t pin_base;
   uint8_t fire_address;
+  std::vector<uint8_t> address_pins;
 };
 
 }