rhetenor/flippr-code
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

still great refactor

Browse Source
This commit is contained in:
Jonas Zeunert
2018-12-14 01:58:05 +01:00
parent 2aee0f4f9d
commit 67edde9078
22 changed files with 243 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
FlippR-Driver/contrib/uml/output_umldiagramm.puml
View File

@@ -22,10 +22,10 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output {
class DisplayController {
+DisplayController(std::vector<std::shared_ptr<items::IDisplay> > displays, std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface)
+DisplayController(std::vector<std::shared_ptr<items::IDisplay> > displays, std::shared_ptr<utility::IOutputGPIOInterface> pin_controller)
+~DisplayController()
-is_running : bool
-output_gpio_interface : std::shared_ptr<utility::IOutputGPIOInterface>
-pin_controller : std::shared_ptr<utility::IOutputGPIOInterface>
-display_cycle_thread : std::thread
-displays : std::vector<std::shared_ptr<items::IDisplay> >
-cycle_displays() : void
@@ -152,7 +152,7 @@ namespace flippR_driver::utility {
namespace flippR_driver::output::items {
class Item {
+Item(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name)
+Item(std::shared_ptr<utility::IOutputGPIOInterface> pin_controller, uint8_t address, std::string name)
+~Item()
#gpio_interface : const std::shared_ptr<utility::IOutputGPIOInterface>
#name : const std::string
@@ -164,7 +164,7 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output::items {
class Lamp {
+Lamp(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name)
+Lamp(std::shared_ptr<utility::IOutputGPIOInterface> pin_controller, uint8_t address, std::string name)
+~Lamp()
-activated : bool
+is_activated() : bool
@@ -243,7 +243,7 @@ namespace flippR_driver::utility {
namespace flippR_driver::output::items {
class Solenoid {
+Solenoid(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time)
+Solenoid(std::shared_ptr<utility::IOutputGPIOInterface> pin_controller, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time)
+~Solenoid()
-deactivation_time : std::chrono::milliseconds
-trigger_task : std::future<void>
@@ -255,7 +255,7 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output::items {
class Sound {
+Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id)
+Sound(std::shared_ptr<utility::IOutputGPIOInterface> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id)
+~Sound()
-deactivation_time : std::chrono::milliseconds
-play_task : std::future<void>

16
FlippR-Driver/contrib/uml/uml.puml
View File

@@ -22,10 +22,10 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output {
class DisplayController {
+DisplayController(std::vector<std::shared_ptr<items::IDisplay> > displays, std::shared_ptr<IOutputGPIOInterface> output_gpio_interface)
+DisplayController(std::vector<std::shared_ptr<items::IDisplay> > displays, std::shared_ptr<IOutputGPIOInterface> pin_controller)
+~DisplayController()
-is_running : bool
-output_gpio_interface : std::shared_ptr<IOutputGPIOInterface>
-pin_controller : std::shared_ptr<IOutputGPIOInterface>
-display_cycle_thread : std::thread
-displays : std::vector<std::shared_ptr<items::IDisplay> >
-cycle_displays() : void
@@ -35,7 +35,7 @@ namespace flippR_driver::output {
namespace flippR_driver::output::items {
class DriverBoardItem {
+DriverBoardItem(std::shared_ptr<IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name)
+DriverBoardItem(std::shared_ptr<IOutputGPIOInterface> pin_controller, uint8_t address, std::string name)
+~DriverBoardItem()
}
}
@@ -79,7 +79,7 @@ namespace flippR_driver::output {
namespace flippR_driver::output::items {
class Item {
+Item(std::shared_ptr<IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name)
+Item(std::shared_ptr<IOutputGPIOInterface> pin_controller, uint8_t address, std::string name)
+~Item()
#gpio_interface : const std::shared_ptr<IOutputGPIOInterface>
#name : const std::string
@@ -92,7 +92,7 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output::items {
class Lamp {
+Lamp(std::shared_ptr<IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name)
+Lamp(std::shared_ptr<IOutputGPIOInterface> pin_controller, uint8_t address, std::string name)
+~Lamp()
-activated : bool
+is_activated() : bool
@@ -151,7 +151,7 @@ namespace flippR_driver::output {
namespace flippR_driver::output::items {
class Solenoid {
+Solenoid(std::shared_ptr<IOutputGPIOInterface> output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time)
+Solenoid(std::shared_ptr<IOutputGPIOInterface> pin_controller, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time)
+~Solenoid()
-deactivation_time : std::chrono::milliseconds
-trigger_task : std::future<void>
@@ -163,7 +163,7 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output::items {
class Sound {
+Sound(std::shared_ptr<IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id)
+Sound(std::shared_ptr<IOutputGPIOInterface> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id)
+~Sound()
-deactivation_time : std::chrono::milliseconds
-play_task : std::future<void>
@@ -176,7 +176,7 @@ namespace flippR_driver::output::items {
namespace flippR_driver::output::items {
class SoundItem {
+SoundItem(std::shared_ptr<IOutputGPIOInterface> output_gpio_interface, uint8_t address, std::string name)
+SoundItem(std::shared_ptr<IOutputGPIOInterface> pin_controller, uint8_t address, std::string name)
+~SoundItem()
}
}

2
FlippR-Driver/src/DriverFactory.cpp
View File

@@ -4,7 +4,7 @@
#include "DriverFactory.h"
#include "input/implementation/InputDriverFactory.h"
#include "input/InputDriverFactory.h"
#include "output/OutputDriverFactory.h"
namespace flippR_driver

2
FlippR-Driver/src/input/InputPinController.h
View File

@@ -18,7 +18,7 @@ namespace input
class InputPinController
{
public:
virtual ~InputGPIOInterface() = default;
virtual ~InputPinController() = default;
virtual bool read_data(uint8_t pin) const = 0;
};

28
FlippR-Driver/src/output/DisplayBoardPinController.h Normal file
View File

@@ -0,0 +1,28 @@
//
// Created by rhetenor on 14.12.18.
//
#ifndef FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H
#define FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H
#include "items/IDisplay.h"
namespace flippR_driver
{
namespace output
{
class DisplayBoardPinController
{
public:
virtual ~DisplayBoardPinController() = default;
virtual void activate_displays() = 0;
virtual void deactivate_displays() = 0;
virtual void write_display(items::IDisplay &display) = 0;
};
}
}
#endif //FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H

5
FlippR-Driver/src/output/DisplayPinController.cpp
View File

@@ -1,5 +0,0 @@
//
// Created by rhetenor on 14.12.18.
//
#include "DisplayPinController.h"

13
FlippR-Driver/src/output/DisplayPinController.h
View File

@@ -1,13 +0,0 @@
//
// Created by rhetenor on 14.12.18.
//
#ifndef FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H
#define FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H
class DisplayPinController
{
};
#endif //FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H

6
FlippR-Driver/src/output/DriverBoardPinController.h
View File

@@ -5,6 +5,8 @@
#ifndef FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H
#include <output/items/DriverBoardItem.h>
namespace flippR_driver
{
namespace output
@@ -15,8 +17,8 @@ class DriverBoardPinController
public:
virtual ~DriverBoardPinController() = default;
virtual void activate(items::DriverBoardItem *driver_board_item) = 0;
virtual void deactivate(items::DriverBoardItem *driver_board_item) = 0;
virtual void activate(items::DriverBoardItem &driver_board_item) = 0;
virtual void deactivate(items::DriverBoardItem &driver_board_item) = 0;
};
}

19
FlippR-Driver/src/output/OutputDriverFactory.cpp
View File

@@ -8,6 +8,9 @@
#include "output/impl/OutputDriver.h"
#include "output/impl/OutputPinController.h"
#include "output/impl/DriverBoardPinController.h"
#include "output/impl/SoundBoardPinController.h"
#include "DisplayBoardPinController.h"
namespace flippR_driver
{
@@ -25,7 +28,19 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream &output_pin_config,
{
utility::LoggerFactory::CreateOutputLogger();
std::shared_ptr<OutputPinController> output_gpio_interface = std::shared_ptr<OutputPinController>(create_OutputGPIOInterface(output_pin_config));
std::shared_ptr<std::mutex> output_pin_mutex();
json output_config;
output_pin_config >> output_config;
json driver_board_config = output_config.at("driver_board");
std::shared_ptr<DriverBoardPinController> driver_board_pin_controller(new impl::DriverBoardPinController(parse_pins_driver_board(driver_board_config), output_pin_mutex));
json sound_board_config = output_config.at("sound_board");
std::shared_ptr<SoundBoardPinController> sound_board_pin_controller(new impl::SoundBoardPinController(parse_pins_sound_board(sound_board_config), output_pin_mutex));
json display_board_config = output_config.at("display_board");
std::shared_ptr<DisplayBoardPinController> display_board_pin_controller(new impl::DisplayBoardPinController(parse_pins_display_board(display_board_config)));
auto solenoids = create_solenoids(solenoid_config, output_gpio_interface);
auto lamps = create_lamps(lamp_config, output_gpio_interface);
@@ -77,7 +92,7 @@ std::map<std::string, uint8_t> parse_pins_driver_board(json &driver_board_config
return pins_driver_board;
}
std::map<std::string, uint8_t> parse_pins_sound(json &sound_board_config)
std::map<std::string, uint8_t> parse_pins_sound_board(json &sound_board_config)
{
std::map<std::string, uint8_t> pins_sound;
try

5
FlippR-Driver/src/output/OutputDriverFactory.h
View File

@@ -12,6 +12,7 @@
#include "OutputPinController.h"
#include "json/json.hpp"
#include <memory>
namespace flippR_driver
@@ -39,8 +40,8 @@ namespace OutputDriverFactory
OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_config);
std::map<std::string, uint8_t> parse_pins_driver_board(nlohmann::json &driver_board_config);
std::map<std::string, uint8_t> parse_pins_sound(nlohmann::json &sound_board_config);
std::map<std::string, uint8_t> parse_pins_display(nlohmann::json &display_board_config);
std::map<std::string, uint8_t> parse_pins_sound_board(nlohmann::json &sound_board_config);
std::map<std::string, uint8_t> parse_pins_display_board(nlohmann::json &display_board_config);
}
}
}

34
FlippR-Driver/src/output/OutputPinController.h
View File

@@ -1,34 +0,0 @@
//
// Created by rhetenor on 10.10.18.
//
#ifndef flippR_driver_IOUTPUTGPIOINTERFACE_H
#define flippR_driver_IOUTPUTGPIOINTERFACE_H
#include "OutputPinController.h"
#include "output/items/DriverBoardItem.h"
#include "output/items/Sound.h"
#include "output/items/IDisplay.h"
#include <memory>
namespace flippR_driver
{
namespace output
{
class OutputPinController
{
public:
virtual ~OutputPinController() = default;
virtual void write_display(items::IDisplay &display) = 0;
//Display gpio interface!
};
}
}
#endif //flippR_driver_IOUTPUTGPIOINTERFACE_H

4
FlippR-Driver/src/output/SoundBoardPinController.h
View File

@@ -5,14 +5,14 @@
#ifndef FLIPPR_DRIVER_SOUNDPINCONTROLLER_H
#define FLIPPR_DRIVER_SOUNDPINCONTROLLER_H
#include "OutputPinController.h"
#include <output/items/Sound.h>
namespace flippR_driver
{
namespace output
{
class SoundBoardPinController : public OutputPinController
class SoundBoardPinController
{
public:
virtual void activate(const items::Sound &sound) = 0;

79
FlippR-Driver/src/output/impl/DisplayBoardPinController.cpp Normal file
View File

@@ -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 impl
{
DisplayBoardPinController::DisplayBoardPinController(std::map<std::string, uint8_t> pins_display) :
pins_display_board(std::move(pins_display))
{
}
void DisplayBoardPinController::activate_displays()
{
write_pin(pins_display_board.at("run"), 1);
}
void DisplayBoardPinController::deactivate_displays()
{
write_pin(pins_display_board.at("run"), 0);
}
void DisplayBoardPinController::write_display(items::IDisplay &display)
{
std::vector<char> 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(const uint8_t display_address, const char &content, const uint8_t &position)
{
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(const uint8_t &segment)
{
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(const char &content)
{
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(const uint8_t &address)
{
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);
}
}
}
}

45
FlippR-Driver/src/output/impl/DisplayBoardPinController.h Normal file
View File

@@ -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 impl
{
class DisplayBoardPinController : public output::DisplayBoardPinController, public PinController
{
public:
explicit DisplayBoardPinController(std::map<std::string, uint8_t> pins_display);
~DisplayBoardPinController() override = default;
void activate_displays() override;
void deactivate_displays() override;
void write_display(items::IDisplay &display) override;
private:
void write_display_digit(const uint8_t display_address, const char &content, const uint8_t &position);
void select_display_segment(const uint8_t &digit);
void select_display_digit(const char &content);
void run_display(const uint8_t &address);
private:
const std::map<std::string, uint8_t> pins_display_board;
};
}
}
}
#endif //FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H

6
FlippR-Driver/src/output/impl/DisplayController.cpp
View File

@@ -16,8 +16,8 @@ namespace output
namespace impl
{
DisplayController::DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<OutputPinController> output_gpio_interface)
: displays(std::move(displays)), output_gpio_interface(std::move(output_gpio_interface)), is_running(true)
DisplayController::DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<DisplayBoardPinController> output_gpio_interface)
: displays(std::move(displays)), pin_controller(std::move(output_gpio_interface)), is_running(true)
{
this->display_cycle_thread = std::thread(&DisplayController::cycle_displays, this);
@@ -37,7 +37,7 @@ void DisplayController::cycle_displays()
{
for(auto &display : this->displays)
{
output_gpio_interface->write_display(*display);
pin_controller->write_display(*display);
}
}
}

7
FlippR-Driver/src/output/impl/DisplayController.h
View File

@@ -14,7 +14,7 @@
#include <thread>
#include "output/items/IDisplay.h"
#include "output/OutputPinController.h"
#include "output/DisplayBoardPinController.h"
namespace flippR_driver
{
@@ -26,7 +26,7 @@ namespace impl
class DisplayController : public output::DisplayController
{
public:
explicit DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<OutputPinController> output_gpio_interface);
explicit DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<DisplayBoardPinController> output_gpio_interface);
~DisplayController() override;
private:
@@ -37,11 +37,12 @@ private:
std::thread display_cycle_thread;
std::shared_ptr<OutputPinController> output_gpio_interface;
std::shared_ptr<DisplayBoardPinController> pin_controller;
bool is_running;
};
}
}
}
#endif

19
FlippR-Driver/src/output/impl/DriverBoardPinController.cpp
View File

@@ -11,26 +11,31 @@ namespace output
namespace impl
{
void DriverBoardPinController::activate(items::DriverBoardItem *driver_board_item)
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))
{
std::lock_guard<std::mutex> guard(output_item_mutex);
write_driver_board_address(driver_board_item->get_address());
}
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)
void DriverBoardPinController::deactivate(items::DriverBoardItem &driver_board_item)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
std::lock_guard<std::mutex> guard(*output_item_mutex);
write_driver_board_address(driver_board_item->get_address());
write_driver_board_address(driver_board_item.get_address());
write_data(false);
}
void DriverBoardPinController::write_driver_board_address(uint8_t address)
{
int latch = address / 8;

9
FlippR-Driver/src/output/impl/DriverBoardPinController.h
View File

@@ -5,9 +5,10 @@
#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_DRIVERBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_OUTPUT_IMPL_DRIVERBOARDPINCONTROLLER_H
#include "PinController.h"
#include "output/DriverBoardPinController.h"
#include "OutputPinController.h"
#include <map>
#include <memory>
@@ -18,14 +19,14 @@ namespace output
namespace impl
{
class DriverBoardPinController : public PinController, public output::DriverBoardPinController
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;
virtual void activate(items::DriverBoardItem *driver_board_item) = 0;
virtual void deactivate(items::DriverBoardItem *driver_board_item) = 0;
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);

68
FlippR-Driver/src/output/impl/OutputPinController.cpp
View File

@@ -26,84 +26,24 @@ OutputGPIOInterface::OutputGPIOInterface(std::map<std::string, uint8_t> pins_dri
initialize_pins();
}
void OutputGPIOInterface::initialize_pins()
void OutputGPIOInterface::initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base)
{
// Since this are all outputs we just initialize everything as output conveniently
initialize_all_pins(pins_driver_board.at("pin_base"));
initialize_all_pins(pins_sound.at("pin_base"));
initialize_all_pins(pins_display.at("pin_base"));
mcp23017Setup(pin_base, i2c_address);
}
void OutputGPIOInterface::initialize_all_pins(uint8_t pin_base)
void OutputGPIOInterface::initialize_pins_output(const uint8_t &pin_base)
{
// Since this are all outputs we just initialize everything as output conveniently
for(int i = 0; i < 16; i++)
{
PinController::initialize_output_pin(pin_base + i);
}
}
void OutputGPIOInterface::initialize_i2c_addresses()
{
mcp23017Setup(pins_driver_board.at("pin_base"), pins_driver_board.at("i2c_address"));
mcp23017Setup(pins_sound.at("pin_base"), pins_sound.at("i2c_address"));
mcp23017Setup(pins_display.at("pin_base"), pins_display.at("i2c_address"));
}
void OutputGPIOInterface::write_display(IDisplay &display)
{
std::vector<char> content = display.get_content();
for(uint8_t i = 0; i < content.size(); i++)
{
write_display_digit(display.get_address(), content.at(i), i);
}
}
void OutputGPIOInterface::write_display_digit(const uint8_t display_address, const char &content, const uint8_t &position)
{
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 OutputGPIOInterface::select_display_segment(const uint8_t &segment)
{
write_pin(pins_display.at("segment_select_A"), segment & ~0b001u);
write_pin(pins_display.at("segment_select_B"), segment & ~0b010u);
write_pin(pins_display.at("segment_select_C"), segment & ~0b100u);
}
void OutputGPIOInterface::select_display_digit(const char &content)
{
write_pin(pins_display.at("digit_select_A"), content & 0b0001u);
write_pin(pins_display.at("digit_select_B"), content & 0b0010u);
write_pin(pins_display.at("digit_select_C"), content & 0b0100u);
write_pin(pins_display.at("digit_select_D"), content & 0b1000u);
}
void OutputGPIOInterface::run_display(const uint8_t &address)
{
write_pin(pins_display.at("display_select_" + std::to_string(address)), 0);
write_pin(pins_display.at("display_select_" + std::to_string(address)), 1);
}
void OutputGPIOInterface::activate_displays()
{
write_pin(pins_display.at("run"), 1);
}
void OutputGPIOInterface::deactivate_displays()
{
write_pin(pins_display.at("run"), 0);
}

30
FlippR-Driver/src/output/impl/OutputPinController.h
View File

@@ -14,6 +14,7 @@
#include <mcp23017.h>
#include <mutex>
#include <map>
namespace flippR_driver
{
namespace output
@@ -21,36 +22,17 @@ namespace output
namespace impl
{
class OutputGPIOInterface : public PinController, public output::OutputPinController
class OutputGPIOInterface : public PinController
{
public:
OutputGPIOInterface(, std::map<std::string, uint8_t> pins_sound, std::map<std::string, uint8_t> pins_display);
OutputGPIOInterface();
~OutputGPIOInterface() override = default;
void activate(items::Item *sound) override;
void deactivate(items::Item *sound) override;
void activate_displays();
void deactivate_displays();
void write_display(items::IDisplay &display) override;
private:
void write_display_digit(const uint8_t display_address, const char &content, const uint8_t &position);
void select_display_segment(const uint8_t &digit);
void select_display_digit(const char &content);
void run_display(const uint8_t &address);
void initialize_i2c_addresses();
void initialize_pins();
void initialize_all_pins(uint8_t pin_base);
private:
const std::map<std::string, uint8_t> pins_display;
protected:
static void initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base);
static void initialize_pins_output(const uint8_t &pin_base);
};
}

14
FlippR-Driver/src/output/impl/SoundBoardPinController.cpp
View File

@@ -11,20 +11,26 @@ namespace output
namespace impl
{
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(items::Sound &sound)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
std::lock_guard<std::mutex> guard(*output_item_mutex);
write_sound_address(sound->get_address());
write_sound_address(sound.get_address());
fire_sound(true);
}
void SoundBoardPinController::deactivate(items::Sound &sound)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
std::lock_guard<std::mutex> guard(*output_item_mutex);
write_sound_address(sound->get_address());
write_sound_address(sound.get_address());
fire_sound(false);
}

10
FlippR-Driver/src/output/impl/SoundBoardPinController.h
View File

@@ -5,11 +5,11 @@
#ifndef FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H
#include <map>
#include "output/SoundBoardPinController.h"
#include "PinController.h"
#include "OutputPinController.h"
#include <map>
namespace flippR_driver
{
namespace output
@@ -17,10 +17,10 @@ namespace output
namespace impl
{
class SoundBoardPinController : public PinController, public output::SoundBoardPinController
class SoundBoardPinController : public OutputPinController, public output::SoundBoardPinController
{
public:
SoundBoardPinController();
SoundBoardPinController(std::map<std::string, uint8_t> pins_sound, std::shared_ptr<std::mutex> output_item_mutex);
~SoundBoardPinController() override = default;
void activate(const items::Sound &sound) override;
@@ -31,7 +31,7 @@ private:
void fire_sound(bool fire);
void write_pin(uint8_t pin, bool value);
private:
std::shared_ptr<std::mutex> output_item_mutex;