renamed impl to detail

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

@@ -0,0 +1,79 @@
+//
+// Created by rhetenor on 14.12.18.
+//
+
+#include <thread>
+#include "DisplayBoardPinController.h"
+
+#include "utility/config.h"
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+DisplayBoardPinController::DisplayBoardPinController(std::map<std::string, uint8_t> pins_display) :
+  pins_display_board(std::move(pins_display))
+{
+
+}
+
+void DisplayBoardPinController::activate_displays() const
+{
+  write_pin(pins_display_board.at("run"), 1);
+}
+
+void DisplayBoardPinController::deactivate_displays() const
+{
+  write_pin(pins_display_board.at("run"), 0);
+}
+
+void DisplayBoardPinController::write_display(const items::OutputDisplay &display) const
+{
+  std::vector<uint8_t> content = display.get_content();
+
+  for(uint8_t i = 0; i < content.size(); i++)
+  {
+    write_display_digit(display.get_address(), content.at(i), i);
+  }
+}
+
+
+void DisplayBoardPinController::write_display_digit(uint8_t display_address, uint8_t content, uint8_t position) const
+{
+  select_display_segment(position);
+
+  select_display_digit(content);
+
+  run_display(display_address);
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(DISPLAY_SLEEP_TIME_MILLI));
+}
+
+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) const
+{
+  write_pin(pins_display_board.at("digit_select_A"), content & 0b0001u);
+  write_pin(pins_display_board.at("digit_select_B"), content & 0b0010u);
+  write_pin(pins_display_board.at("digit_select_C"), content & 0b0100u);
+  write_pin(pins_display_board.at("digit_select_D"), content & 0b1000u);
+}
+
+void DisplayBoardPinController::run_display(uint8_t address) const
+{
+  write_pin(pins_display_board.at("display_select_" + std::to_string(address)), 0);
+
+  write_pin(pins_display_board.at("display_select_" + std::to_string(address)), 1);
+}
+
+}
+}
+}

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

@@ -0,0 +1,45 @@
+//
+// Created by rhetenor on 14.12.18.
+//
+
+#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_DISPLAYPINCONTROLLER_H
+#define FLIPPR_DRIVER_OUTPUT_IMPL_DISPLAYPINCONTROLLER_H
+
+#include "output/DisplayBoardPinController.h"
+
+#include "PinController.h"
+
+#include <map>
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+class DisplayBoardPinController : public output::DisplayBoardPinController, public PinController
+{
+public:
+  explicit DisplayBoardPinController(std::map<std::string, uint8_t> pins_display);
+  ~DisplayBoardPinController() override = default;
+
+  void activate_displays() const override;
+  void deactivate_displays() 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) const;
+  void select_display_segment(uint8_t digit) const;
+  void select_display_digit(uint8_t content) const;
+  void run_display(uint8_t address) const;
+
+private:
+  const std::map<std::string, uint8_t> pins_display_board;
+};
+
+}
+}
+}
+#endif //FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H

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

@@ -0,0 +1,57 @@
+/*
+ * DisplayController.cpp
+ *
+ *  Created on: Aug 7, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#include "DisplayController.h"
+
+#include "utility/config.h"
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+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);
+
+  CLOG(INFO, OUTPUT_LOGGER) << "Created DisplayController and started writing them.";
+}
+
+DisplayController::~DisplayController()
+{
+  this->is_running = false;
+
+  this->display_cycle_thread.join();
+}
+
+void DisplayController::cycle_displays() const
+{
+  while(is_running)
+  {
+    for(auto &display : this->displays)
+    {
+      pin_controller->write_display(*display);
+    }
+  }
+}
+
+void DisplayController::activate_displays() const
+{
+  pin_controller->activate_displays();
+}
+
+void DisplayController::deactivate_displays() const
+{
+  pin_controller->deactivate_displays();
+}
+
+}
+}
+}

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

@@ -0,0 +1,50 @@
+/*
+ * DisplayController.h
+ *
+ *  Created on: Aug 7, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#ifndef _SRC_OUTPUT_DISPLAYCONTROLLER_H_
+#define _SRC_OUTPUT_DISPLAYCONTROLLER_H_
+
+#include "output/DisplayController.h"
+
+#include <vector>
+#include <thread>
+
+#include "output/items/OutputDisplay.h"
+#include "output/DisplayBoardPinController.h"
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+class DisplayController : public output::DisplayController
+{
+public:
+	explicit DisplayController(std::vector<std::shared_ptr<items::OutputDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller);
+	~DisplayController() override;
+
+	void activate_displays() const override;
+	void deactivate_displays() const override;
+
+private:
+	void cycle_displays() const;
+
+private:
+	const std::vector<std::shared_ptr<items::OutputDisplay>> displays;
+
+	const std::shared_ptr<DisplayBoardPinController> pin_controller;
+
+	std::thread display_cycle_thread;
+	bool is_running;
+};
+
+}
+}
+}
+#endif

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

@@ -0,0 +1,90 @@
+//
+// Created by rhetenor on 14.12.18.
+//
+
+#include "DriverBoardPinController.h"
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+DriverBoardPinController::DriverBoardPinController(std::map<std::string, uint8_t> pins_driver_board, std::shared_ptr<std::mutex> output_item_mutex) :
+  pins_driver_board(std::move(pins_driver_board)), output_item_mutex(std::move(output_item_mutex))
+{
+
+}
+
+void DriverBoardPinController::activate(items::DriverBoardItem &driver_board_item)
+{
+  std::lock_guard<std::mutex> guard(*output_item_mutex);
+
+  write_driver_board_address(driver_board_item.get_address());
+
+  write_data(true);
+}
+
+void DriverBoardPinController::deactivate(items::DriverBoardItem &driver_board_item)
+{
+  std::lock_guard<std::mutex> guard(*output_item_mutex);
+
+  write_driver_board_address(driver_board_item.get_address());
+
+  write_data(false);
+}
+
+
+void DriverBoardPinController::write_driver_board_address(uint8_t address) const
+{
+  int latch = address / 8;
+  int pin = address % 8;
+
+  select_mux(latch);
+
+  select_latch(latch);
+
+  select_pin(pin);
+}
+
+void DriverBoardPinController::select_mux(uint8_t latch)const
+{
+  bool mux1 = latch / 8;
+
+  write_pin(pins_driver_board.at("mux1"), mux1);
+  write_pin(pins_driver_board.at("mux2"), !mux1);
+}
+
+void DriverBoardPinController::select_latch(uint8_t latch) const
+{
+  // todo not nice
+  if(latch > 8)
+    latch -= 8;
+
+  write_pin(pins_driver_board.at("latch-select-A"), latch & 0b001u);
+  write_pin(pins_driver_board.at("latch-select-B"), latch & 0b010u);
+  write_pin(pins_driver_board.at("latch-select-C"), latch & 0b100u);
+
+}
+
+void DriverBoardPinController::write_data(bool data) const
+{
+  write_pin(pins_driver_board.at("data"), data);
+}
+
+void DriverBoardPinController::select_pin(uint8_t pin) const
+{
+  write_pin(pins_driver_board.at("pin-select-A"), pin & 0b001u);
+  write_pin(pins_driver_board.at("pin-select-B"), pin & 0b010u);
+  write_pin(pins_driver_board.at("pin-select-C"), pin & 0b100u);
+}
+
+void DriverBoardPinController::write_pin(uint8_t pin, bool value) const
+{
+  PinController::write_pin(pins_driver_board.at("pin_base") + pin, value);
+}
+
+}
+}
+}

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

@@ -0,0 +1,52 @@
+//
+// 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 "output/OutputPinController.h"
+
+#include <output/items/DriverBoardItem.h>
+
+#include <map>
+#include <memory>
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+class DriverBoardPinController : public OutputPinController, 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;
+
+private:
+  void write_driver_board_address(uint8_t address) const;
+  void select_mux(uint8_t latch) const;
+  void select_latch(uint8_t latch) const;
+  void select_pin(uint8_t pin) const;
+  void write_data(bool data) const;
+
+  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/detail/OutputDriver.cpp

@@ -0,0 +1,94 @@
+/*
+ * OutputDriver.cpp
+ *
+ *  Created on: Aug 2, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#include "OutputDriver.h"
+
+#include <boost/range/adaptor/map.hpp>
+#include <boost/range/algorithm/copy.hpp>
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+using namespace items;
+
+OutputDriver::OutputDriver(std::unique_ptr<output::DisplayController> display_controller, std::map<std::string, std::shared_ptr<Solenoid>> solenoids, std::map<std::string, std::shared_ptr<Lamp>> lamps, std::map<std::string, std::shared_ptr<Sound>> sounds, std::map<uint8_t, std::shared_ptr<Display>> displays)
+: display_controller(std::move(display_controller)), solenoids(std::move(solenoids)), lamps(std::move(lamps)), sounds(std::move(sounds)), displays(std::move(displays))
+{}
+
+void OutputDriver::activate_displays() const
+{
+  display_controller->activate_displays();
+}
+
+void OutputDriver::deactivate_displays() const
+{
+  display_controller->deactivate_displays();
+}
+
+std::vector<std::shared_ptr<Sound>> OutputDriver::get_sounds() const
+{
+  std::vector<std::shared_ptr<Sound>> sounds;
+
+  boost::copy(this->sounds | boost::adaptors::map_values, std::back_inserter(sounds));
+
+  return sounds;
+}
+
+std::vector<std::shared_ptr<Display>> OutputDriver::get_displays() const
+{
+  std::vector<std::shared_ptr<Display>> displays;
+
+  boost::copy(this->displays | boost::adaptors::map_values, std::back_inserter(displays));
+
+  return displays;
+}
+
+std::vector<std::shared_ptr<Lamp>> OutputDriver::get_lamps() const
+{
+  std::vector<std::shared_ptr<Lamp>> lamps;
+
+  boost::copy(this->lamps | boost::adaptors::map_values, std::back_inserter(lamps));
+
+  return lamps;
+}
+
+std::vector<std::shared_ptr<Solenoid>> OutputDriver::get_solenoids() const
+{
+  std::vector<std::shared_ptr<Solenoid>> solenoids;
+
+  boost::copy(this->solenoids | boost::adaptors::map_values, std::back_inserter(solenoids));
+
+  return solenoids;
+}
+
+boost::optional<std::shared_ptr<items::Lamp>> OutputDriver::get_lamp(const std::string &name) const
+{
+  return this->lamps.find(name)->second;
+}
+
+boost::optional<std::shared_ptr<items::Solenoid>> OutputDriver::get_solenoid(const std::string &name) const
+{
+  return this->solenoids.find(name)->second;
+}
+
+boost::optional<std::shared_ptr<items::Sound>> OutputDriver::get_sound(const std::string &name) const
+{
+  return this->sounds.find(name)->second;
+}
+
+boost::optional<std::shared_ptr<items::Display>> OutputDriver::get_display(uint8_t number) const
+{
+  return this->displays.find(number)->second;
+}
+
+}
+} /* namespace output */
+}

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

@@ -0,0 +1,57 @@
+/*
+ * OutputDriver.h
+ *
+ *  Created on: Aug 2, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#ifndef _SRC_OUTPUT_OUTPUTDRIVER_H_
+#define _SRC_OUTPUT_OUTPUTDRIVER_H_
+
+#include "output/OutputDriver.h"
+#include "output/DisplayController.h"
+
+#include <map>
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+class OutputDriver : public output::OutputDriver
+{
+public:
+  OutputDriver(std::unique_ptr<output::DisplayController> display_controller, std::map<std::string, std::shared_ptr<items::Solenoid>> solenoids, std::map<std::string, std::shared_ptr<items::Lamp>> lamps, std::map<std::string, std::shared_ptr<items::Sound>> sounds, std::map<uint8_t, std::shared_ptr<items::Display>> displays);
+
+  ~OutputDriver() override = default;
+
+  void activate_displays() const override;
+  void deactivate_displays() const override;
+
+  // todo what is flipper_relay ?
+  std::vector<std::shared_ptr<items::Lamp>> get_lamps() const override;
+  std::vector<std::shared_ptr<items::Solenoid>> get_solenoids() const override;
+  std::vector<std::shared_ptr<items::Sound>> get_sounds() const override;
+  std::vector<std::shared_ptr<items::Display>> get_displays() const override;
+
+  boost::optional<std::shared_ptr<items::Lamp>> get_lamp(const std::string &name) const override;
+  boost::optional<std::shared_ptr<items::Solenoid>> get_solenoid(const std::string &name) const override;
+  boost::optional<std::shared_ptr<items::Sound>> get_sound(const std::string &name) const override;
+  boost::optional<std::shared_ptr<items::Display>> get_display(uint8_t number) const override;
+
+private:
+  std::unique_ptr<output::DisplayController> display_controller;
+
+  const std::map<std::string, std::shared_ptr<items::Lamp>> lamps;
+  const std::map<std::string, std::shared_ptr<items::Solenoid>> solenoids;
+  const std::map<std::string, std::shared_ptr<items::Sound>> sounds;
+
+  const std::map<uint8_t, std::shared_ptr<items::Display>> displays;
+};
+
+}
+} /* namespace output */
+}
+#endif

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

@@ -0,0 +1,62 @@
+//
+// Created by rhetenor on 14.12.18.
+//
+
+#include "SoundBoardPinController.h"
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+SoundBoardPinController::SoundBoardPinController(std::map<std::string, uint8_t> pins_sound, std::shared_ptr<std::mutex> output_item_mutex) :
+  pins_sound(std::move(pins_sound)), output_item_mutex(std::move(output_item_mutex))
+{
+
+}
+
+void SoundBoardPinController::activate(const items::detail::Sound &sound)
+{
+  std::lock_guard<std::mutex> guard(*output_item_mutex);
+
+  write_sound_address(sound.get_address());
+
+  fire_sound(true);
+}
+
+void SoundBoardPinController::deactivate(const items::detail::Sound &sound)
+{
+  std::lock_guard<std::mutex> guard(*output_item_mutex);
+
+  write_sound_address(sound.get_address());
+
+  fire_sound(false);
+}
+
+
+void SoundBoardPinController::write_sound_address(uint8_t address) const
+{
+  write_pin(pins_sound.at("A"), address & 0b0000001u);
+  write_pin(pins_sound.at("B"), address & 0b0000010u);
+  write_pin(pins_sound.at("C"), address & 0b0000100u);
+  write_pin(pins_sound.at("D"), address & 0b0001000u);
+  write_pin(pins_sound.at("E"), address & 0b0010000u);
+  write_pin(pins_sound.at("F"), address & 0b0100000u);
+  write_pin(pins_sound.at("G"), address & 0b1000000u);
+}
+
+void SoundBoardPinController::fire_sound(bool fire) const
+{
+  PinController::write_pin(pins_sound.at("fire"), fire);
+}
+
+void SoundBoardPinController::write_pin(uint8_t pin, bool value) const
+{
+  PinController::write_pin(pins_sound.at("pin_base") + pin, value);
+}
+
+}
+}
+}

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

@@ -0,0 +1,47 @@
+//
+// Created by rhetenor on 14.12.18.
+//
+
+#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_SOUNDBOARDPINCONTROLLER_H
+#define FLIPPR_DRIVER_OUTPUT_IMPL_SOUNDBOARDPINCONTROLLER_H
+
+#include "output/SoundBoardPinController.h"
+
+#include "output/OutputPinController.h"
+
+#include <output/items/detail/Sound.h>
+
+#include <map>
+namespace flippR_driver
+{
+namespace output
+{
+namespace detail
+{
+
+class SoundBoardPinController : public OutputPinController, public output::SoundBoardPinController
+{
+public:
+  SoundBoardPinController(std::map<std::string, uint8_t> pins_sound, std::shared_ptr<std::mutex> output_item_mutex);
+  ~SoundBoardPinController() override = default;
+
+  void activate(const items::detail::Sound &sound) override;
+  void deactivate(const items::detail::Sound &sound) override;
+
+private:
+  void write_sound_address(uint8_t address) const;
+  void fire_sound(bool fire) const;
+
+  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_sound;
+
+};
+
+}
+}
+}
+#endif //FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H