refactored outpugpiointerface

FlippR-Driver/src/output/DisplayController.cpp

@@ -6,7 +6,7 @@
  */
 
 #include "DisplayController.h"
-#include "utility/IOutputGPIOInterface.h"
+#include "IOutputGPIOInterface.h"
 
 #include "utility/config.h"
 

FlippR-Driver/src/output/DisplayController.h

@@ -14,7 +14,7 @@
 #include <thread>
 
 #include "items/IDisplay.h"
-#include "utility/IOutputGPIOInterface.h"
+#include "IOutputGPIOInterface.h"
 
 namespace flippR_driver
 {

FlippR-Driver/src/output/IOutputGPIOInterface.h

@@ -0,0 +1,38 @@
+//
+// Created by rhetenor on 10.10.18.
+//
+
+#ifndef flippR_driver_IOUTPUTGPIOINTERFACE_H
+#define flippR_driver_IOUTPUTGPIOINTERFACE_H
+
+#include "IOutputGPIOInterface.h"
+
+#include "output/items/IDriverBoardItem.h"
+#include "output/items/ISoundItem.h"
+#include "output/items/IDisplay.h"
+#include <memory>
+
+namespace flippR_driver
+{
+namespace output
+{
+
+class IOutputGPIOInterface
+{
+public:
+  virtual ~IOutputGPIOInterface(){};
+
+  virtual void activate(output::items::IDriverBoardItem *driver_board_item) = 0;
+  virtual void activate(output::items::ISoundItem *sound) = 0;
+
+  virtual void deactivate(output::items::IDriverBoardItem *driver_board_item) = 0;
+  virtual void deactivate(output::items::ISoundItem *sound) = 0;
+
+  virtual void write_display(std::shared_ptr<output::items::IDisplay> display) = 0;
+  //Display gpio interface!
+
+};
+
+}
+}
+#endif //flippR_driver_IOUTPUTGPIOINTERFACE_H

FlippR-Driver/src/output/OutputDriverFactory.cpp

@@ -8,6 +8,77 @@ namespace flippR_driver
 {
 namespace output
 {
+namespace OutputDriverFactory
+{
+
+namespace
+{
+
+using namespace nlohmann;
+
+std::shared_ptr<OutputGPIOInterface> createOutputGPIOInterface(std::istream &output_gpio_config)
+{
+  json output_config;
+  output_gpio_config >> output_config;
+
+  return std::make_shared<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)
+{
+  std::map<std::string, uint8_t> pins_driver_board;
+
+  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>();
+
+  return pins_driver_board;
+}
+
+std::map<std::string, uint8_t> parse_pins_sound(json &sound_board_config)
+{
+  std::map<std::string, uint8_t> pins_sound;
+
+  pins_sound["i2c_address"] = sound_board_config.at("i2c_address").get<uint8_t>();
+  pins_sound["pin_base"] = sound_board_config.at("pin_base").get<uint8_t>();
+  pins_sound["fire"] = sound_board_config.at("fire").get<uint8_t>();
+
+  json sound_address = sound_board_config.at("sound_address");
+  pins_sound["A"] = sound_address.at("A").get<uint8_t>();
+  pins_sound["B"] = sound_address.at("B").get<uint8_t>();
+  pins_sound["C"] = sound_address.at("C").get<uint8_t>();
+  pins_sound["D"] = sound_address.at("D").get<uint8_t>();
+  pins_sound["E"] = sound_address.at("E").get<uint8_t>();
+  pins_sound["F"] = sound_address.at("F").get<uint8_t>();
+  pins_sound["G"] = sound_address.at("G").get<uint8_t>();
+
+  return pins_sound;
+}
+
+std::map<std::string, uint8_t> parse_pins_display(json &display_board_config)
+{
+  return std::map<std::string, uint8_t>();
+}
 
+}
+
+}
 }
 }

FlippR-Driver/src/output/OutputDriverFactory.h

@@ -8,16 +8,25 @@
 #include <memory>
 
 #include "OutputDriver.h"
+#include "OutputGPIOInterface.h"
 
 namespace flippR_driver
 {
 namespace output
 {
-class OutputDriverFactory
+namespace OutputDriverFactory
 {
-public:
-  static std::shared_ptr <OutputDriver> getOutputDriver(std::ifstream &output_gpio_config, std::ifstream &output_config);
-};
+  static std::shared_ptr<OutputDriver> getOutputDriver(std::istream &output_gpio_config, std::istream &output_config);
+
+  namespace
+  {
+    static std::shared_ptr<OutputGPIOInterface> createOutputGPIOInterface(std::istream &output_gpio_config);
+
+    static std::map<std::string, uint8_t> parse_pins_driver_board(nlohmann::json &driver_board_config);
+    static std::map<std::string, uint8_t> parse_pins_sound(nlohmann::json &sound_board_config);
+    static std::map<std::string, uint8_t> parse_pins_display(nlohmann::json &display_board_config);
+  }
+}
 }
 }
 

FlippR-Driver/src/output/OutputGPIOInterface.cpp

@@ -0,0 +1,145 @@
+/*
+ * OutputGPIOInterface.h
+ *
+ *  Created on: May 31, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#include "OutputGPIOInterface.h"
+
+namespace flippR_driver
+{
+namespace output
+{
+using namespace output::items;
+using namespace nlohmann;
+
+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(pins_driver_board), pins_sound(pins_sound), pins_display(pins_display)
+{
+  initialize_i2c_addresses();
+
+  initialize_pins();
+}
+
+void OutputGPIOInterface::initialize_pins()
+{
+  // Since this are all outputs we just initialize everything as output conveniently
+  initialize_all_pins(pins_driver_board["pin_base"]);
+  initialize_all_pins(pins_sound["pin_base"]);
+  initialize_all_pins(pins_display["pin_base"]);
+}
+
+void OutputGPIOInterface::initialize_all_pins(uint8_t pin_base)
+{
+  for(int i = 0; i < 16; i++)
+  {
+    GPIOInterface::initialize_output_pin(pin_base + i);
+  }
+}
+
+void OutputGPIOInterface::initialize_i2c_addresses()
+{
+  mcp23017Setup(pins_driver_board["pin_base"], pins_driver_board["i2c_address"]);
+  mcp23017Setup(pins_sound["pin_base"], pins_sound["i2c_address"]);
+  mcp23017Setup(pins_display["pin_base"], pins_display["i2c_address"]);
+}
+
+void OutputGPIOInterface::activate(output::items::ISoundItem *sound)
+{
+  std::lock_guard<std::mutex> guard(output_item_mutex);
+
+  write_sound_address(sound->get_address());
+
+  fire_sound(1);
+}
+
+void OutputGPIOInterface::activate(output::items::IDriverBoardItem *driver_board_item)
+{
+  std::lock_guard<std::mutex> guard(output_item_mutex);
+
+  write_driver_board_address(driver_board_item->get_address());
+
+  write_data(1);
+}
+
+void OutputGPIOInterface::deactivate(output::items::IDriverBoardItem *driver_board_item)
+{
+  std::lock_guard<std::mutex> guard(output_item_mutex);
+
+  write_driver_board_address(driver_board_item->get_address());
+
+  write_data(0);
+}
+
+void OutputGPIOInterface::deactivate(output::items::ISoundItem *sound)
+{
+  std::lock_guard<std::mutex> guard(output_item_mutex);
+
+  write_sound_address(sound->get_address());
+
+  fire_sound(0);
+}
+
+void OutputGPIOInterface::write_driver_board_address(uint8_t address)
+{
+  int latch = address / 8;
+  int pin = address % 8;
+
+  select_mux(latch);
+
+  select_latch(latch);
+
+  select_pin(pin);
+}
+
+void OutputGPIOInterface::select_mux(uint8_t latch)
+{
+  bool mux1 = latch / 8;
+
+  write_pin(pins_driver_board["mux1"], mux1);
+  write_pin(pins_driver_board["mux2"], !mux1);
+}
+
+void OutputGPIOInterface::select_latch(uint8_t latch)
+{
+  // todo not nice
+  if(latch > 8)
+    latch -= 8;
+
+  write_pin(pins_driver_board["latch-select-A"], latch & 0b001);
+  write_pin(pins_driver_board["latch-select-B"], latch & 0b010);
+  write_pin(pins_driver_board["latch-select-C"], latch & 0b100);
+
+}
+
+void OutputGPIOInterface::write_data(bool data)
+{
+  write_pin(pins_driver_board["data"], data);
+}
+
+void OutputGPIOInterface::select_pin(uint8_t pin)
+{
+  write_pin(pins_driver_board["pin-select-A"], pin & 0b001);
+  write_pin(pins_driver_board["pin-select-B"], pin & 0b010);
+  write_pin(pins_driver_board["pin-select-C"], pin & 0b100);
+}
+
+void OutputGPIOInterface::write_sound_address(uint8_t address)
+{
+  write_pin(pins_sound["A"], address & 0b0000001);
+  write_pin(pins_sound["B"], address & 0b0000010);
+  write_pin(pins_sound["C"], address & 0b0000100);
+  write_pin(pins_sound["D"], address & 0b0001000);
+  write_pin(pins_sound["E"], address & 0b0010000);
+  write_pin(pins_sound["F"], address & 0b0100000);
+  write_pin(pins_sound["G"], address & 0b1000000);
+}
+
+void OutputGPIOInterface::fire_sound(bool fire)
+{
+  GPIOInterface::write_pin(pins_sound["fire"], fire);
+}
+
+}
+}

FlippR-Driver/src/output/OutputGPIOInterface.h

@@ -0,0 +1,68 @@
+/*
+ * OutputGPIOInterface.h
+ *
+ *  Created on: May 31, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
+ */
+
+#ifndef SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
+#define SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
+
+#include "IOutputGPIOInterface.h"
+#include "GPIOInterface.h"
+
+#include "output/items/IItem.h"
+
+#include "json/json.hpp"
+
+#include <mcp23017.h>
+#include <mutex>
+#include <map>
+namespace flippR_driver
+{
+namespace output
+{
+
+class OutputGPIOInterface : public GPIOInterface, IOutputGPIOInterface
+{
+
+public:
+  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);
+
+  virtual ~OutputGPIOInterface() = default;
+
+  virtual void activate(output::items::IDriverBoardItem *driver_board_item);
+  virtual void activate(output::items::ISoundItem *sound);
+
+  virtual void deactivate(output::items::IDriverBoardItem *driver_board_item);
+  virtual void deactivate(output::items::ISoundItem *sound);
+
+  virtual void write_display(output::items::IDisplay *display);
+
+private:
+  void initialize_i2c_addresses();
+
+  void initialize_pins();
+  void initialize_all_pins(uint8_t pin_base);
+
+  void write_driver_board_address(uint8_t address);
+  void select_mux(uint8_t latch);
+  void select_latch(uint8_t latch);
+  void select_pin(uint8_t pin);
+  void write_data(bool data);
+
+  void write_sound_address(uint8_t address);
+  void fire_sound(bool fire);
+
+private:
+  std::mutex output_item_mutex;
+
+  std::map<std::string, uint8_t> pins_driver_board;// {{"i2c_address", 0}, {"pin_base", 0}, {"data", 0}, {"CL", 0}, {"latch-select-A", "0"}, {"latch-select-B", "0"}, {"latch-select-C", 0}, {"mux1", 0}, {"mux2", 0}, {"pin-select-A", 0}, {"pin-select-B", 0}, {"pin-select-C", 0}};
+  std::map<std::string, uint8_t> pins_sound;// {{"i2c_address", 0}, {"pin_base", 0}, {"fire", 0}, {"A", 0}, {"B", "0"}, {"C", "0"}, {"D", 0}, {"E", 0}, {"F", 0}, {"G", 0}};
+  std::map<std::string, uint8_t> pins_display;// {{"i2c_address", 0}, {"pin_base", 0}, {"fire", 0}, {"A", 0}, {"B", "0"}, {"C", "0"}, {"D", 0}, {"E", 0}, {"F", 0}, {"G", 0}};
+};
+
+}
+}
+
+#endif

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

@@ -10,7 +10,7 @@
 
 #include "IItem.h"
 
-#include "utility/IOutputGPIOInterface.h"
+#include "output/IOutputGPIOInterface.h"
 
 #include <memory>
 #include <string>