display dependencies

FlippR-Driver/include/output/items/Display.h

@@ -21,7 +21,7 @@ class Display
 public:
   virtual ~Display() = default;
 
-  virtual void write_score(int score) = 0;
+  virtual void write_score(uint score) = 0;
 };
 
 }

FlippR-Driver/include/output/items/EightDigitDisplay.h

@@ -19,7 +19,7 @@ namespace items
 class EightDigitDisplay : public Display
 {
 public:
-  virtual void write_content(std::array<char, 8> content) = 0;
+  virtual void write_content(std::array<char , 8> content) = 0;
 };
 
 }

FlippR-Driver/src/output/DisplayBoardPinController.h

@@ -20,7 +20,7 @@ public:
   virtual void activate_displays() const = 0;
   virtual void deactivate_displays() const = 0;
 
-  virtual void write_display(const items::Display &display) const = 0;
+  virtual void write_display(const items::OutputDisplay &display) const = 0;
 };
 
 }

FlippR-Driver/src/output/OutputDriverFactory.cpp

@@ -54,7 +54,7 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream &output_pin_config,
   auto displays = create_displays(display_config);
 
   // todo
-  std::vector<std::shared_ptr<items::Display>> displays_vec;
+  std::vector<std::shared_ptr<items::OutputDisplay>> displays_vec;
   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)));
 
@@ -256,14 +256,14 @@ std::shared_ptr<items::impl::Sound> create_sound(nlohmann::json &sound_json, std
   }
 }
 
-std::map<uint8_t, std::shared_ptr<items::Display>> create_displays(std::istream &display_config)
+std::map<uint8_t, std::shared_ptr<items::OutputDisplay>> create_displays(std::istream &display_config)
 {
-  std::map<uint8_t, std::shared_ptr<items::Display>> displays;
+  std::map<uint8_t, std::shared_ptr<items::OutputDisplay>> displays;
 
   json display_config_json;
   display_config >> display_config_json;
 
-  json displays_json = display_config_json.at('displays');
+  json displays_json = display_config_json.at("displays");
   for(json &display_json : displays_json)
   {
     auto display = create_display(display_json);
@@ -272,7 +272,7 @@ std::map<uint8_t, std::shared_ptr<items::Display>> create_displays(std::istream
   return displays;
 }
 
-std::shared_ptr<items::Display> create_display(nlohmann::json &display_json)
+std::shared_ptr<items::OutputDisplay> create_display(nlohmann::json &display_json)
 {
   try
   {
@@ -286,19 +286,18 @@ std::shared_ptr<items::Display> create_display(nlohmann::json &display_json)
     }
     else if(digits == 7)
     {
-      return std::make_shared<items::impl::SevenDigitDisplay(address, id);
+      return std::make_shared<items::impl::SevenDigitDisplay>(address, id);
     }
     else
     {
       throw new std::logic_error("Display digits can either be 7 or 8");
     }
-
   }
   catch(json::exception &e)
   {
+    // todo log
     exit(EXIT_FAILURE);
   }
-  return std::shared_ptr<items::Display>();
 }
 
 }

FlippR-Driver/src/output/OutputDriverFactory.h

@@ -36,8 +36,8 @@ namespace OutputDriverFactory
 
     std::chrono::milliseconds get_deactivation_time(nlohmann::json &json);
 
-    std::map<uint8_t, std::shared_ptr<items::Display>> create_displays(std::istream &display_config);
+    std::map<uint8_t, std::shared_ptr<items::OutputDisplay>> create_displays(std::istream &display_config);
-    std::shared_ptr<items::Display> create_display(nlohmann::json &display_json);
+    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);

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

@@ -30,7 +30,7 @@ void DisplayBoardPinController::deactivate_displays() const
   write_pin(pins_display_board.at("run"), 0);
 }
 
-void DisplayBoardPinController::write_display(const items::Display &display) const
+void DisplayBoardPinController::write_display(const items::OutputDisplay &display) const
 {
   std::vector<uint8_t> content = display.get_content();
 
@@ -41,7 +41,7 @@ void DisplayBoardPinController::write_display(const items::Display &display) con
 }
 
 
-void DisplayBoardPinController::write_display_digit(uint8_t display_address, uint8_t content, uint8_t position)
+void DisplayBoardPinController::write_display_digit(uint8_t display_address, uint8_t content, uint8_t position) const
 {
   select_display_segment(position);
 
@@ -52,14 +52,14 @@ void DisplayBoardPinController::write_display_digit(uint8_t display_address, uin
   std::this_thread::sleep_for(std::chrono::milliseconds(DISPLAY_SLEEP_TIME_MILLI));
 }
 
-void DisplayBoardPinController::select_display_segment(uint8_t segment)
+void DisplayBoardPinController::select_display_segment(uint8_t segment) const
 {
   write_pin(pins_display_board.at("segment_select_A"), segment & ~0b001u);
   write_pin(pins_display_board.at("segment_select_B"), segment & ~0b010u);
   write_pin(pins_display_board.at("segment_select_C"), segment & ~0b100u);
 }
 
-void DisplayBoardPinController::select_display_digit(uint8_t content)
+void DisplayBoardPinController::select_display_digit(uint8_t content) const
 {
   write_pin(pins_display_board.at("digit_select_A"), content & 0b0001u);
   write_pin(pins_display_board.at("digit_select_B"), content & 0b0010u);
@@ -67,7 +67,7 @@ void DisplayBoardPinController::select_display_digit(uint8_t content)
   write_pin(pins_display_board.at("digit_select_D"), content & 0b1000u);
 }
 
-void DisplayBoardPinController::run_display(uint8_t address)
+void DisplayBoardPinController::run_display(uint8_t address) const
 {
   write_pin(pins_display_board.at("display_select_" + std::to_string(address)), 0);
 

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

@@ -27,13 +27,13 @@ public:
   void activate_displays() const override;
   void deactivate_displays() const override;
 
-  void write_display(const items::Display &display) const override;
+  void write_display(const items::OutputDisplay &display) const override;
 
 private:
-  void write_display_digit(uint8_t display_address, uint8_t content, uint8_t position);
+  void write_display_digit(uint8_t display_address, uint8_t content, uint8_t position) const;
-  void select_display_segment(uint8_t digit);
+  void select_display_segment(uint8_t digit) const;
-  void select_display_digit(uint8_t content);
+  void select_display_digit(uint8_t content) const;
-  void run_display(uint8_t address);
+  void run_display(uint8_t address) const;
 
 private:
   const std::map<std::string, uint8_t> pins_display_board;

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

@@ -16,7 +16,7 @@ namespace output
 namespace impl
 {
 
-DisplayController::DisplayController(std::vector<std::shared_ptr<items::Display>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller)
+DisplayController::DisplayController(std::vector<std::shared_ptr<items::OutputDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller)
 : 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::Display>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller);
+	explicit DisplayController(std::vector<std::shared_ptr<items::OutputDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller);
 	~DisplayController() override;
 
 	void activate_displays() const override;
@@ -36,7 +36,7 @@ private:
 	void cycle_displays() const;
 
 private:
-	const std::vector<std::shared_ptr<items::Display>> displays;
+	const std::vector<std::shared_ptr<items::OutputDisplay>> displays;
 
 	const std::shared_ptr<DisplayBoardPinController> pin_controller;
 

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

@@ -10,6 +10,7 @@
 
 #include <vector>
 #include <cstdint>
+#include <output/items/Display.h>
 
 namespace flippR_driver
 {
@@ -18,13 +19,14 @@ namespace output
 namespace items
 {
 
-class OutputDisplay
+class OutputDisplay : Display
 {
 
 public:
 	virtual ~OutputDisplay() = default;
 
 	virtual uint8_t get_address() const = 0;
+	virtual uint8_t get_id() const = 0;
 	virtual std::vector<uint8_t> get_content() const = 0;
 };
 

FlippR-Driver/src/output/items/impl/Display.h

@@ -28,20 +28,23 @@ public:
   Display(uint8_t address, uint8_t id);
   virtual ~Display() = default;
 
-  virtual void write_score(int score);
+  virtual void write_score(uint score);
-  virtual void write_content(std::array<uint8_t, DigitCount> content);
+  virtual void write_content(std::array<char, DigitCount> content);
 
   std::vector<uint8_t> get_content() const override;
   uint8_t get_address() const override;
+  uint8_t get_id() const override;
+
+private:
+  std::string fit_string(std::string &score_string);
 
 public:
-  std::array<uint8_t, DigitCount> content;
+  std::array<char, DigitCount> content;
 
 private:
   const uint8_t id;
   const uint8_t address;
 
-  std::string fit_string(std::string &score_string);
 };
 
 }

FlippR-Driver/src/output/items/impl/Display.hpp

@@ -24,19 +24,17 @@ Display<DigitCount>::Display(uint8_t address, uint8_t id) :
 }
 
 template<int DigitCount>
-int Display<DigitCount>::getID()
+uint8_t Display<DigitCount>::get_id() const
 {
   return this->id;
 }
 
 template<int DigitCount>
-void Display<DigitCount>::write_score(int score)
+void Display<DigitCount>::write_score(uint score)
 {
   auto score_string = std::to_string(score);
 
-  auto score_c_string = this->fit_string(score_string).c_str();
+  std::copy(score_string.begin(), score_string.end(), std::begin(this->content));
-
-  std::copy(std::begin(score_c_string), std::end(score_c_string), std::begin(this->content));
 }
 
 template<int DigitCount>
@@ -57,16 +55,16 @@ std::string Display<DigitCount>::fit_string(std::string& score_string)
 }
 
 template<int DigitCount>
-void Display<DigitCount>::write_content( std::array<uint8_t, DigitCount> content)
+void Display<DigitCount>::write_content( std::array<char, DigitCount> content)
 {
   this->content = content;
 }
 
-<int DigitCount>
+template <int DigitCount>
-std::vector<uint8_t> Display<DigitCount>::get_content()
+std::vector<uint8_t> Display<DigitCount>::get_content() const
 {
   // todo: expensive?
-  return std::vector<uint8_t>(content, content + DigitCount);
+  return std::vector<uint8_t>(content.begin(), content.end());
 }
 
 }

FlippR-Driver/src/output/items/impl/EightDigitDisplay.h

@@ -24,6 +24,17 @@ public:
   EightDigitDisplay(uint8_t address, uint8_t id) :
     Display<8>(address, id) {}
 
+  void write_score(uint score) override
+  {
+    Display<8>::write_score(score);
+  }
+
+  void write_content(std::array<char, 8> content) override
+  {
+    Display<8>::write_content(content);
+  }
+
+
   ~EightDigitDisplay() override = default;
 
 };

FlippR-Driver/src/output/items/impl/SevenDigitDisplay.h

@@ -24,6 +24,16 @@ public:
   SevenDigitDisplay(uint8_t address, uint8_t id) :
     Display<7>(address, id) {}
 
+  void write_score(uint score) override
+  {
+    Display<7>::write_score(score);
+  }
+
+  void write_content(std::array<char, 7> content) override
+  {
+    Display<7>::write_content(content);
+  }
+
   ~SevenDigitDisplay() override = default;
 
 };