asdf

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

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

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

@@ -5,6 +5,10 @@
 #ifndef FLIPPR_DRIVER_IDRIVERBOARDITEM_H
 #define FLIPPR_DRIVER_IDRIVERBOARDITEM_H
 
+#include "IItem.h"
+
+#include <cstdint>
+
 namespace flippR_driver
 {
 namespace output
@@ -14,8 +18,7 @@ namespace items
 
 class IDriverBoardItem : public IItem
 {
-  virtual ~IDriverBoardItem()
+  virtual ~IDriverBoardItem(){};
-  {};
 };
 
 }

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

@@ -8,6 +8,7 @@
 #ifndef _SRC_OUTPUT_ICABINETITEM_H_
 #define _SRC_OUTPUT_ICABINETITEM_H_
 
+#include <cstdint>
 
 namespace flippR_driver
 {
@@ -22,6 +23,8 @@ public:
   virtual ~IItem();
   virtual void activate() = 0;
   virtual void deactivate() = 0;
+
+  virtual uint8_t get_address() = 0;
 };
 
 }

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

@@ -0,0 +1,24 @@
+//
+// Created by rhetenor on 23.11.18.
+//
+
+#ifndef FLIPPR_DRIVER_ISOUNDITEM_H
+#define FLIPPR_DRIVER_ISOUNDITEM_H
+
+#include "IItem.h"
+namespace flippR_driver
+{
+namespace output
+{
+namespace items
+{
+class ISoundItem : public IItem
+{
+
+};
+
+}
+}
+}
+
+#endif //FLIPPR_DRIVER_ISOUNDITEM_H

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

@@ -11,12 +11,17 @@ namespace output
 namespace items
 {
 
-Item::Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address,  std::string name) :
+Item::Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address,  std::string name) :
   address(address),
   name(name),
   output_gpio_interface(output_gpio_interface)
 {}
 
+uint8_t Item::get_address()
+{
+  return this->address;
+}
+
 void Item::activate()
 {
   output_gpio_interface->activate_output_item(this);

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

@@ -25,14 +25,15 @@ namespace items
 class Item : public IItem
 {
 public:
-  Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name);
+  Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name);
   virtual ~Item();
 
-public:
+  virtual uint8_t get_address();
-  const u_int8_t address;
-  const std::string name;
 
 protected:
+  const uint8_t address;
+  const std::string name;
+
   const std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface;
 
 protected:

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

@@ -10,6 +10,7 @@
 
 #include "Item.h"
 #include "output/items/ILamp.h"
+#include "IDriverBoardItem.h"
 
 namespace flippR_driver
 {
@@ -18,10 +19,10 @@ namespace output
 namespace items
 {
 
-class Lamp : public Item, ILamp
+class Lamp : public Item, ILamp, IDriverBoardItem
 {
 public:
-  Lamp(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address,  std::string name);
+  Lamp(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address,  std::string name);
   virtual ~Lamp() = default;
 
   void activate();

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

@@ -10,6 +10,7 @@
 
 #include "output/items/ISolenoid.h"
 #include "Item.h"
+#include "IDriverBoardItem.h"
 
 #include <future>
 #include <chrono>
@@ -21,7 +22,7 @@ namespace output
 namespace items
 {
 
-class Solenoid : public Item, ISolenoid
+class Solenoid : public Item, ISolenoid, IDriverBoardItem
 {
 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

@@ -16,7 +16,7 @@ namespace output
 namespace items
 {
 
-Sound::Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time) :
+Sound::Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time) :
   Item(output_gpio_interface, address, name),
   deactivation_time(deactivation_time)
 {}

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

@@ -9,6 +9,7 @@
 #define _SRC_OUTPUT_SOUND_H_
 
 #include "output/items/ISound.h"
+#include "ISoundItem.h"
 #include "Item.h"
 
 #include <memory>
@@ -24,13 +25,13 @@ namespace output
 namespace items
 {
 
-class Sound : public ISound, Item
+class Sound : public ISound, Item, ISoundItem
 {
 public:
 	u_int id;
 
 public:
-	Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time);
+	Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time);
 	virtual ~Sound() = default;
 
 	virtual void play();

FlippR-Driver/src/utility/OutputGPIOInterface.cpp

@@ -35,38 +35,38 @@ void OutputGPIOInterface::parse_output_config(json &output_config)
 
 void OutputGPIOInterface::parse_pins_driver_board(json &driver_board_config)
 {
-  this->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<uint8_t>();
-  this->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<uint8_t>();
-  this->pins_driver_board["data"] = driver_board_config.at("data").get<u_int8_t>();
+  this->pins_driver_board["data"] = driver_board_config.at("data").get<uint8_t>();
-  this->pins_driver_board["CL"] = driver_board_config.at("CL").get<u_int8_t>();
+  this->pins_driver_board["CL"] = driver_board_config.at("CL").get<uint8_t>();
 
   json pin_select = driver_board_config.at("pin-select");
-  this->pins_driver_board["pin-select-A"] = pin_select.at("A").get<u_int8_t>();
+  this->pins_driver_board["pin-select-A"] = pin_select.at("A").get<uint8_t>();
-  this->pins_driver_board["pin-select-B"] = pin_select.at("B").get<u_int8_t>();
+  this->pins_driver_board["pin-select-B"] = pin_select.at("B").get<uint8_t>();
-  this->pins_driver_board["pin-select-C"] = pin_select.at("C").get<u_int8_t>();
+  this->pins_driver_board["pin-select-C"] = pin_select.at("C").get<uint8_t>();
 
   json latch_select = driver_board_config.at("latch-select");
-  this->pins_driver_board["mux1"] = latch_select.at("mux1").get<u_int8_t>();
+  this->pins_driver_board["mux1"] = latch_select.at("mux1").get<uint8_t>();
-  this->pins_driver_board["mux2"] = latch_select.at("mux2").get<u_int8_t>();
+  this->pins_driver_board["mux2"] = latch_select.at("mux2").get<uint8_t>();
-  this->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<uint8_t>();
-  this->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<uint8_t>();
-  this->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<uint8_t>();
 }
 
 void OutputGPIOInterface::parse_pins_sound(json &sound_board_config)
 {
-  this->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<uint8_t>();
-  this->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<uint8_t>();
-  this->pins_sound["fire"] = sound_board_config.at("fire").get<u_int8_t>();
+  this->pins_sound["fire"] = sound_board_config.at("fire").get<uint8_t>();
 
   json sound_address = sound_board_config.at("sound_address");
-  this->pins_sound["A"] = sound_address.at("A").get<u_int8_t>();
+  this->pins_sound["A"] = sound_address.at("A").get<uint8_t>();
-  this->pins_sound["B"] = sound_address.at("B").get<u_int8_t>();
+  this->pins_sound["B"] = sound_address.at("B").get<uint8_t>();
-  this->pins_sound["C"] = sound_address.at("C").get<u_int8_t>();
+  this->pins_sound["C"] = sound_address.at("C").get<uint8_t>();
-  this->pins_sound["D"] = sound_address.at("D").get<u_int8_t>();
+  this->pins_sound["D"] = sound_address.at("D").get<uint8_t>();
-  this->pins_sound["E"] = sound_address.at("E").get<u_int8_t>();
+  this->pins_sound["E"] = sound_address.at("E").get<uint8_t>();
-  this->pins_sound["F"] = sound_address.at("F").get<u_int8_t>();
+  this->pins_sound["F"] = sound_address.at("F").get<uint8_t>();
-  this->pins_sound["G"] = sound_address.at("G").get<u_int8_t>();
+  this->pins_sound["G"] = sound_address.at("G").get<uint8_t>();
 }
 
 void OutputGPIOInterface::parse_pins_display(json &display_board_config)
@@ -82,7 +82,7 @@ void OutputGPIOInterface::initialize_pins()
   initialize_all_pins(pins_display["pin_base"]);
 }
 
-void OutputGPIOInterface::initialize_all_pins(u_int8_t pin_base)
+void OutputGPIOInterface::initialize_all_pins(uint8_t pin_base)
 {
   for(int i = 0; i < 16; i++)
   {
@@ -106,7 +106,7 @@ void OutputGPIOInterface::activate(output::items::ISound *sound)
 {
   std::lock_guard<std::mutex> guard(output_item_mutex);
 
-  write_sound_address(sound->address);
+  write_sound_address(sound->);
 
   fire_sound(1);
 }
@@ -115,7 +115,7 @@ void OutputGPIOInterface::activate(output::items::IDriverBoardItem *driver_board
 {
   std::lock_guard<std::mutex> guard(output_item_mutex);
 
-  write_driver_board_address(driver_board_item->address);
+  write_driver_board_address(driver_board_item->get_address());
 
   write_data(1);
 }
@@ -124,7 +124,7 @@ void OutputGPIOInterface::deactivate(output::items::IDriverBoardItem *driver_boa
 {
   std::lock_guard<std::mutex> guard(output_item_mutex);
 
-  write_driver_board_address(driver_board_item->address);
+  write_driver_board_address(driver_board_item->get_address());
 
   write_data(0);
 }
@@ -138,7 +138,7 @@ void OutputGPIOInterface::deactivate(output::items::ISound *sound)
   fire_sound(0);
 }
 
-void OutputGPIOInterface::write_driver_board_address(u_int8_t address)
+void OutputGPIOInterface::write_driver_board_address(uint8_t address)
 {
   int latch = address / 8;
   int pin = address % 8;
@@ -150,7 +150,7 @@ void OutputGPIOInterface::write_driver_board_address(u_int8_t address)
   select_pin(pin);
 }
 
-void OutputGPIOInterface::select_mux(u_int8_t latch)
+void OutputGPIOInterface::select_mux(uint8_t latch)
 {
   bool mux1 = latch / 8;
 
@@ -158,7 +158,7 @@ void OutputGPIOInterface::select_mux(u_int8_t latch)
   write_pin(pins_driver_board["mux2"], !mux1);
 }
 
-void OutputGPIOInterface::select_latch(u_int8_t latch)
+void OutputGPIOInterface::select_latch(uint8_t latch)
 {
   // todo not nice
   if(latch > 8)
@@ -175,14 +175,14 @@ void OutputGPIOInterface::write_data(bool data)
   write_pin(pins_driver_board["data"], data);
 }
 
-void OutputGPIOInterface::select_pin(u_int8_t pin)
+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(u_int8_t address)
+void OutputGPIOInterface::write_sound_address(uint8_t address)
 {
   write_pin(pins_sound["A"], address & 0b0000001)
   write_pin(pins_sound["B"], address & 0b0000010)

FlippR-Driver/src/utility/OutputGPIOInterface.h

@@ -12,7 +12,7 @@
 
 #include "output/items/IItem.h"
 #include "output/items/IDriverBoardItem.h"
-#include "output/items/ISound.h"
+#include "output/items/ISoundItem.h"
 #include "output/items/IDisplay.h"
 
 #include "json/json.hpp"
@@ -34,10 +34,10 @@ public:
   virtual ~OutputGPIOInterface() = default;
 
   void activate(output::items::IDriverBoardItem *driver_board_item);
-  void activate(output::items::ISound *sound);
+  void activate(output::items::ISoundItem *sound);
 
   void deactivate(output::items::IDriverBoardItem *driver_board_item);
-  void deactivate(output::items::ISound *sound);
+  void deactivate(output::items::ISoundItem *sound);
 
   void write_display(output::items::IDisplay &display);
 
@@ -50,23 +50,23 @@ private:
   void initialize_i2c_addresses();
 
   void initialize_pins();
-  void initialize_all_pins(u_int8_t pin_base);
+  void initialize_all_pins(uint8_t pin_base);
 
-  void write_driver_board_address(u_int8_t address);
+  void write_driver_board_address(uint8_t address);
-  void select_mux(u_int8_t latch);
+  void select_mux(uint8_t latch);
-  void select_latch(u_int8_t latch);
+  void select_latch(uint8_t latch);
-  void select_pin(u_int8_t pin);
+  void select_pin(uint8_t pin);
   void write_data(bool data);
 
-  void write_sound_address(u_int8_t address);
+  void write_sound_address(uint8_t address);
   void fire_sound(bool fire);
 
 private:
   std::mutex output_item_mutex;
 
-  std::map<std::string, u_int8_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_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, u_int8_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_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, u_int8_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}};
+  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}};
 };
 
 }