written output item logic

FlippR-Driver/contrib/uml/output_umldiagramm.xcore

@@ -179,9 +179,9 @@ namespace flippR_driver::utility {
 
 
 namespace flippR_driver::output::items {
-	class OutputItem {
+	class Item {
-		+OutputItem(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin_address, std::string name)
+		+Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin_address, std::string name)
-		+~OutputItem()
+		+~Item()
 		#output_gpio_interface : const std::shared_ptr<utility::IOutputGPIOInterface>
 		+name : const std::string
 		+address : const unsigned int
@@ -248,22 +248,22 @@ namespace flippR_driver::utility {
 
 
 namespace flippR_driver::output::items {
-	IOutputItem <|-- OutputItem
+	IOutputItem <|-- Item
 }
 
 
 namespace flippR_driver::output::items {
-	OutputItem <|-- Lamp
+	Item <|-- Lamp
 }
 
 
 namespace flippR_driver::output::items {
-	OutputItem <|-- Solenoid
+	Item <|-- Solenoid
 }
 
 
 namespace flippR_driver::output::items {
-	OutputItem <|-- Sound
+	Item <|-- Sound
 }
 
 
@@ -281,7 +281,7 @@ flippR_driver::output.DisplayController o-- flippR_driver::utility.IOutputGPIOIn
 flippR_driver::output.OutputDriver o-- flippR_driver::output::items.IDisplay
 
 
-flippR_driver::output::items.OutputItem o-- flippR_driver::utility.IOutputGPIOInterface
+flippR_driver::output::items.Item o-- flippR_driver::utility.IOutputGPIOInterface
 
 
 

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

@@ -22,6 +22,7 @@ public:
 	virtual ~ISound();
 
 	virtual void play() = 0;
+	virtual
 };
 
 }

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

@@ -64,6 +64,7 @@ void Display<DigitCount>::write_content( std::array<char, DigitCount> content)
 <int DigitCount>
 std::vector<char> Display<DigitCount>::get_content()
 {
+  // todo: expensive?
   return std::vector<char>(content, content + DigitCount);
 }
 

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

@@ -0,0 +1,25 @@
+//
+// Created by rhetenor on 23.11.18.
+//
+
+#ifndef FLIPPR_DRIVER_IDRIVERBOARDITEM_H
+#define FLIPPR_DRIVER_IDRIVERBOARDITEM_H
+
+namespace flippR_driver
+{
+namespace output
+{
+namespace items
+{
+
+class IDriverBoardItem : public IItem
+{
+  virtual ~IDriverBoardItem()
+  {};
+};
+
+}
+}
+}
+
+#endif //FLIPPR_DRIVER_IDRIVERBOARDITEM_H

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

@@ -11,20 +11,18 @@ namespace output
 namespace items
 {
 
-OutputItem::OutputItem(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin_address, std::string name) :
+Item::Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address,  std::string name) :
   address(address),
-  i2c_address(i2c_address),
-  data_pin_address(data_pin_address),
   name(name),
   output_gpio_interface(output_gpio_interface)
 {}
 
-void OutputItem::activate()
+void Item::activate()
 {
   output_gpio_interface->activate_output_item(this);
 }
 
-void OutputItem::deactivate()
+void Item::deactivate()
 {
   output_gpio_interface->deactivate_output_item(this);
 }

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

@@ -22,11 +22,11 @@ namespace output
 namespace items
 {
 
-class OutputItem : public IOutputItem
+class Item : public IItem
 {
 public:
-  OutputItem(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name);
+  Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name);
-  virtual ~OutputItem();
+  virtual ~Item();
 
 public:
   const u_int8_t address;

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

@@ -16,18 +16,18 @@ namespace items
 
 Lamp::Lamp(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int i2c_address, unsigned int address, unsigned int data_pin, std::string name)
 :
-OutputItem(output_gpio_interface, address, i2c_address, data_pin, name),
+Item(output_gpio_interface, address, i2c_address, data_pin, name),
 activated(false)
 {}
 
 void Lamp::activate()
 {
-  OutputItem::activate();
+  Item::activate();
 }
 
 void Lamp::deactivate()
 {
-  OutputItem::deactivate();
+  Item::deactivate();
 }
 
 }

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

@@ -18,7 +18,7 @@ namespace output
 namespace items
 {
 
-class Lamp : public OutputItem, ILamp
+class Lamp : public Item, ILamp
 {
 public:
   Lamp(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address,  std::string name);

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

@@ -17,17 +17,17 @@ namespace items
 {
 
 Solenoid::Solenoid(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin, std::string name, std::chrono::milliseconds deactivation_time):
-  OutputItem(output_gpio_interface, address, i2c_address, data_pin, name),
+  Item(output_gpio_interface, address, i2c_address, data_pin, name),
   deactivation_time(deactivation_time)
 {}
 
 void Solenoid::triggerTask()
 {
-  OutputItem::activate();
+  Item::activate();
 
   std::this_thread::sleep_for(deactivation_time);
 
-  OutputItem::deactivate();
+  Item::deactivate();
 }
 
 void Solenoid::trigger()

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

@@ -21,7 +21,7 @@ namespace output
 namespace items
 {
 
-class Solenoid : public OutputItem, ISolenoid
+class Solenoid : public Item, ISolenoid
 {
 public:
   Solenoid(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin, std::string name, std::chrono::milliseconds deactivation_time);

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

@@ -17,7 +17,7 @@ namespace items
 {
 
 Sound::Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin, std::string name, std::chrono::milliseconds deactivation_time) :
-  OutputItem(output_gpio_interface, address, i2c_address, data_pin, name),
+  Item(output_gpio_interface, address, i2c_address, data_pin, name),
   deactivation_time(deactivation_time)
 {}
 
@@ -28,11 +28,11 @@ void Sound::play()
 
 void Sound::playTask()
 {
-  OutputItem::activate();
+  Item::activate();
 
   std::this_thread::sleep_for(deactivation_time);
 
-  OutputItem::deactivate();
+  Item::deactivate();
 }
 
 }

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

@@ -24,7 +24,7 @@ namespace output
 namespace items
 {
 
-class Sound : public ISound, OutputItem
+class Sound : public ISound, Item
 {
 public:
 	Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, unsigned int address, unsigned int i2c_address, unsigned int data_pin, std::string name, std::chrono::milliseconds deactivation_time);

FlippR-Driver/src/utility/OutputGPIOInterface.cpp

@@ -12,6 +12,7 @@ namespace flippR_driver
 namespace utility
 {
 using namespace output::items;
+using namespace nlohmann;
 
 OutputGPIOInterface::OutputGPIOInterface(std::istream &output_config_stream)
 {
@@ -20,7 +21,7 @@ OutputGPIOInterface::OutputGPIOInterface(std::istream &output_config_stream)
 
   parse_output_config(output_config);
 
-  initialize_i2c_addresses(output_config);
+  initialize_i2c_addresses();
 
   initialize_pins();
 }
@@ -34,38 +35,38 @@ void OutputGPIOInterface::parse_output_config(json &output_config)
 
 void OutputGPIOInterface::parse_pins_driver_board(json &driver_board_config)
 {
-  pins_driver_board["i2c_address"] = driver_board_config.at("i2c_address").get<u_int8_t>();
+  this->pins_driver_board["i2c_address"] = driver_board_config.at("i2c_address").get<u_int8_t>();
-  pins_driver_board["pin_base"] = driver_board_config.at("pin_base").get<u_int8_t>();
+  this->pins_driver_board["pin_base"] = driver_board_config.at("pin_base").get<u_int8_t>();
-  pins_driver_board["data"] = driver_board_config.at("data").get<u_int8_t>();
+  this->pins_driver_board["data"] = driver_board_config.at("data").get<u_int8_t>();
-  pins_driver_board["CL"] = driver_board_config.at("CL").get<u_int8_t>();
+  this->pins_driver_board["CL"] = driver_board_config.at("CL").get<u_int8_t>();
 
   json pin_select = driver_board_config.at("pin-select");
-  pins_driver_board["pin-select-A"] = latch_select.at("A").get<u_int8_t>();
+  this->pins_driver_board["pin-select-A"] = pin_select.at("A").get<u_int8_t>();
-  pins_driver_board["pin-select-B"] = latch_select.at("B").get<u_int8_t>();
+  this->pins_driver_board["pin-select-B"] = pin_select.at("B").get<u_int8_t>();
-  pins_driver_board["pin-select-C"] = latch_select.at("C").get<u_int8_t>();
+  this->pins_driver_board["pin-select-C"] = pin_select.at("C").get<u_int8_t>();
 
   json latch_select = driver_board_config.at("latch-select");
-  pins_driver_board["mux1"] = latch_select.at("mux1").get<u_int8_t>();
+  this->pins_driver_board["mux1"] = latch_select.at("mux1").get<u_int8_t>();
-  pins_driver_board["mux2"] = latch_select.at("mux2").get<u_int8_t>();
+  this->pins_driver_board["mux2"] = latch_select.at("mux2").get<u_int8_t>();
-  pins_driver_board["latch-select-A"] = latch_select.at("A").get<u_int8_t>();
+  this->pins_driver_board["latch-select-A"] = latch_select.at("A").get<u_int8_t>();
-  pins_driver_board["latch-select-B"] = latch_select.at("B").get<u_int8_t>();
+  this->pins_driver_board["latch-select-B"] = latch_select.at("B").get<u_int8_t>();
-  pins_driver_board["latch-select-C"] = latch_select.at("C").get<u_int8_t>();
+  this->pins_driver_board["latch-select-C"] = latch_select.at("C").get<u_int8_t>();
 }
 
 void OutputGPIOInterface::parse_pins_sound(json &sound_board_config)
 {
-  pins_sound["i2c_address"] = sound_board_config.at("i2c_address").get<u_int8_t>();
+  this->pins_sound["i2c_address"] = sound_board_config.at("i2c_address").get<u_int8_t>();
-  pins_sound["pin_base"] = sound_board_config.at("pin_base").get<u_int8_t>();
+  this->pins_sound["pin_base"] = sound_board_config.at("pin_base").get<u_int8_t>();
-  pins_sound["fire"] = sound_board_config.at("fire").get<u_int8_t>();
+  this->pins_sound["fire"] = sound_board_config.at("fire").get<u_int8_t>();
 
-  json sound_address = driver_board_config.at("sound_address");
+  json sound_address = sound_board_config.at("sound_address");
-  pins_sound["A"] = sound_address.at("A").get<u_int8_t>();
+  this->pins_sound["A"] = sound_address.at("A").get<u_int8_t>();
-  pins_sound["B"] = sound_address.at("B").get<u_int8_t>();
+  this->pins_sound["B"] = sound_address.at("B").get<u_int8_t>();
-  pins_sound["C"] = sound_address.at("C").get<u_int8_t>();
+  this->pins_sound["C"] = sound_address.at("C").get<u_int8_t>();
-  pins_sound["D"] = sound_address.at("D").get<u_int8_t>();
+  this->pins_sound["D"] = sound_address.at("D").get<u_int8_t>();
-  pins_sound["E"] = sound_address.at("E").get<u_int8_t>();
+  this->pins_sound["E"] = sound_address.at("E").get<u_int8_t>();
-  pins_sound["F"] = sound_address.at("F").get<u_int8_t>();
+  this->pins_sound["F"] = sound_address.at("F").get<u_int8_t>();
-  pins_sound["G"] = sound_address.at("G").get<u_int8_t>();
+  this->pins_sound["G"] = sound_address.at("G").get<u_int8_t>();
 }
 
 void OutputGPIOInterface::parse_pins_display(json &display_board_config)
@@ -77,33 +78,23 @@ 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_board["pin_base"]);
+  initialize_all_pins(pins_sound["pin_base"]);
-  initialize_all_pins(pins_display_board["pin_base"]);
+  initialize_all_pins(pins_display["pin_base"]);
 }
 
 void OutputGPIOInterface::initialize_all_pins(u_int8_t pin_base)
 {
   for(int i = 0; i < 16; i++)
   {
-    initialize_output_pin(pin_base + 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_board["pin_base"], pins_sound_board["i2c_address"]);
+  mcp23017Setup(pins_sound["pin_base"], pins_sound["i2c_address"]);
-  mcp23017Setup(pins_display_board["pin_base"], pins_display_board["i2c_address"]);
+  mcp23017Setup(pins_display["pin_base"], pins_display["i2c_address"]);
-}
-
-void OutputGPIOInterface::activate_output_item(IOutputItem *item)
-{
-  std::lock_guard<std::mutex> guard(output_item_mutex);
-}
-
-void OutputGPIOInterface::deactivate_output_item(IOutputItem *item)
-{
-  std::lock_guard<std::mutex> guard(output_item_mutex);
 }
 
 void OutputGPIOInterface::write_display(IDisplay &display)
@@ -111,5 +102,66 @@ void OutputGPIOInterface::write_display(IDisplay &display)
 
 }
 
+void OutputGPIOInterface::activate(output::items::ISound *sound)
+{
+  write_sound_address(sound->address);
+
+  GPIOInterface::write_pin(pins_sound["fire"], 1);
+}
+
+
+void OutputGPIOInterface::write_sound_address(u_int8_t address)
+{
+
+}
+
+void OutputGPIOInterface::write_driver_board_address(u_int8_t address)
+{
+  // todo schöner machen!
+  int latch = address / 8;
+  int pin = address % 8;
+
+  bool mux1 = latch / 8;
+
+  latch = mux1 ? latch : latch - 8; // substracting 8 if it is on 2nd latch
+
+  // selecting mux
+  write_pin(pins_driver_board["mux1"], mux1);
+  write_pin(pins_driver_board["mux2"], !mux1);
+
+  // selecting latch
+  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)
+
+  // selecting address
+  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::activate(output::items::IDriverBoardItem *driver_board_item)
+{
+  std::lock_guard<std::mutex> guard(output_item_mutex);
+
+  write_driver_board_address(driver_board_item->address);
+
+  write_data(1);
+}
+
+void OutputGPIOInterface::write_data(bool data)
+{
+  write_pin(pins_driver_board["data"], data);
+}
+
+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->address);
+
+  write_data(0);
+}
+
 }
 }

FlippR-Driver/src/utility/OutputGPIOInterface.h

@@ -10,9 +10,13 @@
 
 #include "GPIOInterface.h"
 
-#include "output/items/IOutputItem.h"
+#include "output/items/IItem.h"
+#include "output/items/IDriverBoardItem.h"
+#include "output/items/ISound.h"
 #include "output/items/IDisplay.h"
 
+#include "json/json.hpp"
+
 #include <mcp23017.h>
 #include <mutex>
 #include <map>
@@ -23,7 +27,6 @@ namespace utility
 
 class OutputGPIOInterface : public GPIOInterface
 {
-using namespace nlohmann;
 
 public:
   OutputGPIOInterface(std::istream &output_config_stream);
@@ -31,26 +34,29 @@ public:
   virtual ~OutputGPIOInterface() = default;
 
   void activate(output::items::ISound *sound);
-  void activate(output::items::ILamp *lamp);
+  void activate(output::items::IDriverBoardItem *driver_board_item);
-  void activate(output::items::ISolenoid *solenoid);
 
   void deactivate(output::items::ISound *sound);
-  void deactivate(output::items::ILamp *lamp);
+  void deactivate(output::items::IDriverBoardItem *driver_board_item);
-  void deactivate(output::items::ISolenoid *solenoid);
 
   void write_display(output::items::IDisplay &display);
 
 private:
-  void parse_output_config(json &output_config);
+  void parse_output_config(nlohmann::json &output_config);
-  void parse_pins_driver_board(json &driver_board_config);
+  void parse_pins_driver_board(nlohmann::json &driver_board_config);
-  void parse_pins_sound(json &sound_board_config);
+  void parse_pins_sound(nlohmann::json &sound_board_config);
-  void parse_pins_display(json &display_board_config);
+  void parse_pins_display(nlohmann::json &display_board_config);
 
   void initialize_i2c_addresses();
 
   void initialize_pins();
   void initialize_all_pins(u_int8_t pin_base);
 
+  void write_sound_address(u_int8_t address);
+  void write_driver_board_address(u_int8_t address);
+
+  void write_data(bool data);
+
 private:
   std::mutex output_item_mutex;