diff --git a/FlippR-Driver/cli/PrintHandler.cpp b/FlippR-Driver/cli/PrintHandler.cpp index bb7dabf..3e88ac7 100644 --- a/FlippR-Driver/cli/PrintHandler.cpp +++ b/FlippR-Driver/cli/PrintHandler.cpp @@ -5,7 +5,7 @@ #include "PrintHandler.h" #include -PrintHandler::PrintHandler(std::shared_ptr driver) : +PrintHandler::PrintHandler(std::shared_ptr driver) : flippR_driver::input::EventHandler(driver) { diff --git a/FlippR-Driver/cli/PrintHandler.h b/FlippR-Driver/cli/PrintHandler.h index b5d3bc2..a19097f 100644 --- a/FlippR-Driver/cli/PrintHandler.h +++ b/FlippR-Driver/cli/PrintHandler.h @@ -6,13 +6,13 @@ #define flippR_driver_PRINTHANDLER_H #include -#include "../src/input/EventHandler.h" -#include "input/IInputDriver.h" +#include "../src/input/implementation/EventHandler.h" +#include "input/InputDriver.h" class PrintHandler : public flippR_driver::input::EventHandler { public: - PrintHandler(std::shared_ptr driver); + PrintHandler(std::shared_ptr driver); virtual void handle(flippR_driver::input::Event& event) override; }; diff --git a/FlippR-Driver/cli/main.cpp b/FlippR-Driver/cli/main.cpp index 39eb60d..3749c3c 100644 --- a/FlippR-Driver/cli/main.cpp +++ b/FlippR-Driver/cli/main.cpp @@ -7,7 +7,7 @@ #include #include "DriverFactory.h" -#include "input/IInputDriver.h" +#include "input/InputDriver.h" #include "PrintHandler.h" @@ -45,7 +45,7 @@ int main (int argc, char *argv[]) exit(2); } - std::shared_ptr driver = flippR_driver::get_InputDriver(input_config, matrix_config); + std::shared_ptr driver = flippR_driver::get_InputDriver(input_config, matrix_config); PrintHandler* print_handler = new PrintHandler(driver); diff --git a/FlippR-Driver/contrib/json_example/Input_Config.json b/FlippR-Driver/contrib/json_example/Input_Pin_Config.json similarity index 100% rename from FlippR-Driver/contrib/json_example/Input_Config.json rename to FlippR-Driver/contrib/json_example/Input_Pin_Config.json diff --git a/FlippR-Driver/contrib/json_example/Output_Config.json b/FlippR-Driver/contrib/json_example/Output_Pin_Config.json similarity index 61% rename from FlippR-Driver/contrib/json_example/Output_Config.json rename to FlippR-Driver/contrib/json_example/Output_Pin_Config.json index c205b56..e6b4a07 100644 --- a/FlippR-Driver/contrib/json_example/Output_Config.json +++ b/FlippR-Driver/contrib/json_example/Output_Pin_Config.json @@ -1,7 +1,28 @@ { "display_board" : { - + "display_select" : + { + "1" : 0, + "2" : 0, + "3" : 0, + "4" : 0, + "5" : 0, + }, + "segment_select" : + { + "A" : 0, + "B" : 0, + "C" : 0 + }, + "digit_select" : + { + "A": 0, + "B": 0, + "C": 0, + "D": 0 + }, + "run" : 0 }, "driver_board" : { @@ -30,7 +51,7 @@ "i2c_address" : 33, "pin_base" : 81, "fire" : 7, - "sound_address" : + "sound_address_select" : { "A" : 0, "B" : 1, diff --git a/FlippR-Driver/include/DriverFactory.h b/FlippR-Driver/include/DriverFactory.h index 2350915..92b31c1 100644 --- a/FlippR-Driver/include/DriverFactory.h +++ b/FlippR-Driver/include/DriverFactory.h @@ -8,13 +8,13 @@ #include #include -#include "input/IInputDriver.h" -#include "output/IOutputDriver.h" +#include "input/InputDriver.h" +#include "output/OutputDriver.h" namespace flippR_driver { - std::shared_ptr get_InputDriver(std::istream& input_config_stream, std::istream& matrix_config_stream); - std::shared_ptr get_OutputDriver(std::istream &output_pin_config, + std::shared_ptr get_InputDriver(std::istream& input_config_stream, std::istream& matrix_config_stream); + std::shared_ptr get_OutputDriver(std::istream &output_pin_config, std::istream &lamp_config, std::istream &solenoid_config, std::istream &sound_config, diff --git a/FlippR-Driver/include/input/Event.h b/FlippR-Driver/include/input/Event.h index 8ee6dcf..708596c 100644 --- a/FlippR-Driver/include/input/Event.h +++ b/FlippR-Driver/include/input/Event.h @@ -13,30 +13,30 @@ #include namespace flippR_driver { - namespace input { +namespace input { - class Event { - public: - Event(char address, int priority, std::string name); +class Event { +public: + Event(uint8_t address, int priority, std::string name); - friend bool operator==(const Event &left, const Event &right); - - friend bool operator<(const Event &left, const Event &right) { - return left.priority < right.priority; - } - - - public: - std::string name; - uint8_t address; - int priority; - std::chrono::time_point last_activation; - - }; - - bool operator==(const Event &left, const Event &right); + friend bool operator==(const Event &left, const Event &right); + friend bool operator<(const Event &left, const Event &right) { + return left.priority < right.priority; } + +public: + std::string name; + uint8_t address; + int priority; + std::chrono::time_point last_activation; + +}; + +bool operator==(const Event &left, const Event &right); + +} + } #endif /* INPUTEVENT_H_ */ diff --git a/FlippR-Driver/include/input/IEventHandler.h b/FlippR-Driver/include/input/EventHandler.h similarity index 56% rename from FlippR-Driver/include/input/IEventHandler.h rename to FlippR-Driver/include/input/EventHandler.h index 11b3fff..daa73a6 100644 --- a/FlippR-Driver/include/input/IEventHandler.h +++ b/FlippR-Driver/include/input/EventHandler.h @@ -1,5 +1,5 @@ /* - * IEventHandler.h + * EventHandler.h * * Created on: Jun 13, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert @@ -10,12 +10,19 @@ #include "input/Event.h" -class IEventHandler +namespace flippR_driver +{ +namespace input +{ + +class EventHandler { public: - virtual ~IEventHandler(){}; + virtual ~EventHandler() = default; - virtual void handle(flippR_driver::input::Event& event) = 0; + virtual void handle(flippR_driver::input::Event &event) = 0; }; +} +} #endif /* SRC_IEVENTHANDLER_H_ */ diff --git a/FlippR-Driver/include/input/IInputDriver.h b/FlippR-Driver/include/input/IInputDriver.h deleted file mode 100644 index 0fe16cf..0000000 --- a/FlippR-Driver/include/input/IInputDriver.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * IInputDriver.h - * - * Created on: Jun 14, 2018 - * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert - */ - -#ifndef SRC_INPUT_IINPUTDRIVER_H_ -#define SRC_INPUT_IINPUTDRIVER_H_ - -#include -#include - -#include "input/IEventHandler.h" - -namespace flippR_driver -{ -namespace input -{ - class IInputDriver { - public: - virtual ~IInputDriver() {}; - - virtual void register_event_handler(IEventHandler *handler) = 0; - - virtual void unregister_event_handler(IEventHandler *handler) = 0; - - virtual boost::optional> get_event(std::string name) = 0; - }; -} -} -#endif /* SRC_INPUT_IINPUTDRIVER_H_ */ diff --git a/FlippR-Driver/include/input/InputDriver.h b/FlippR-Driver/include/input/InputDriver.h new file mode 100644 index 0000000..9d0a89e --- /dev/null +++ b/FlippR-Driver/include/input/InputDriver.h @@ -0,0 +1,34 @@ +/* + * InputDriver.h + * + * Created on: Jun 14, 2018 + * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert + */ + +#ifndef SRC_INPUT_IINPUTDRIVER_H_ +#define SRC_INPUT_IINPUTDRIVER_H_ + +#include +#include + +#include "input/EventHandler.h" + +namespace flippR_driver +{ +namespace input +{ + +class InputDriver { + public: + virtual ~InputDriver() = default; + + virtual void register_event_handler(EventHandler *handler) = 0; + + virtual void unregister_event_handler(EventHandler *handler) = 0; + + virtual boost::optional> get_event(std::string name) = 0; +}; + +} +} +#endif /* SRC_INPUT_IINPUTDRIVER_H_ */ diff --git a/FlippR-Driver/include/output/IOutputDriver.h b/FlippR-Driver/include/output/OutputDriver.h similarity index 93% rename from FlippR-Driver/include/output/IOutputDriver.h rename to FlippR-Driver/include/output/OutputDriver.h index 7d996e3..cd9bee5 100644 --- a/FlippR-Driver/include/output/IOutputDriver.h +++ b/FlippR-Driver/include/output/OutputDriver.h @@ -1,5 +1,5 @@ /* - * IOutputDriver.h + * OutputDriver.h * * Created on: Aug 2, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert @@ -22,10 +22,10 @@ namespace flippR_driver namespace output { -class IOutputDriver +class OutputDriver { public: - virtual ~IOutputDriver() = default; + virtual ~OutputDriver() = default; virtual std::vector> get_lamps() = 0; virtual std::vector> get_solenoids() = 0; diff --git a/FlippR-Driver/lib/json/json.hpp b/FlippR-Driver/lib/json/json.hpp index c9ef758..13384dc 100644 --- a/FlippR-Driver/lib/json/json.hpp +++ b/FlippR-Driver/lib/json/json.hpp @@ -270,7 +270,7 @@ using enable_if_t = typename std::enable_if::type; template using uncvref_t = typename std::remove_cv::type>::type; -// implementation of C++14 index_sequence and affiliates +// impl of C++14 index_sequence and affiliates // source: https://stackoverflow.com/a/32223343 template struct index_sequence @@ -7369,7 +7369,7 @@ boundaries compute_boundaries(FloatType value) // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1)) static_assert(std::numeric_limits::is_iec559, - "internal error: dtoa_short requires an IEEE-754 floating-point implementation"); + "internal error: dtoa_short requires an IEEE-754 floating-point impl"); constexpr int kPrecision = std::numeric_limits::digits; // = p (includes the hidden bit) constexpr int kBias = std::numeric_limits::max_exponent - 1 + (kPrecision - 1); diff --git a/FlippR-Driver/src/DriverFactory.cpp b/FlippR-Driver/src/DriverFactory.cpp index 578516e..4047ee7 100644 --- a/FlippR-Driver/src/DriverFactory.cpp +++ b/FlippR-Driver/src/DriverFactory.cpp @@ -4,17 +4,17 @@ #include "DriverFactory.h" -#include "input/InputDriverFactory.h" +#include "input/implementation/InputDriverFactory.h" #include "output/OutputDriverFactory.h" namespace flippR_driver { - std::shared_ptr get_InputDriver(std::istream& input_config_stream, std::istream& matrix_config_stream) + std::shared_ptr get_InputDriver(std::istream& input_config_stream, std::istream& matrix_config_stream) { return input::InputDriverFactory::get_InputDriver(input_config_stream, matrix_config_stream); } - std::shared_ptr get_OutputDriver(std::istream &output_pin_config, + std::shared_ptr get_OutputDriver(std::istream &output_pin_config, std::istream &lamp_config, std::istream &solenoid_config, std::istream &sound_config, diff --git a/FlippR-Driver/src/GPIOInterface.cpp b/FlippR-Driver/src/PinController.cpp similarity index 51% rename from FlippR-Driver/src/GPIOInterface.cpp rename to FlippR-Driver/src/PinController.cpp index 0f48ec0..71c40bb 100644 --- a/FlippR-Driver/src/GPIOInterface.cpp +++ b/FlippR-Driver/src/PinController.cpp @@ -1,11 +1,11 @@ /* - * GPIOInterface.cpp + * PinController.cpp * * Created on: Jun 15, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#include "GPIOInterface.h" +#include "PinController.h" #include "utility/config.h" @@ -15,29 +15,29 @@ namespace flippR_driver { -std::once_flag GPIOInterface::GPIO_LIB_INITIALIZED; +std::once_flag PinController::GPIO_LIB_INITIALIZED; -GPIOInterface::GPIOInterface() +PinController::PinController() { std::call_once(GPIO_LIB_INITIALIZED, wiringPiSetup); } -void GPIOInterface::initialize_input_pin(uint8_t address) +void PinController::initialize_input_pin(uint8_t address) { pinMode(address, INPUT); } -void GPIOInterface::initialize_output_pin(uint8_t address) +void PinController::initialize_output_pin(uint8_t address) { pinMode(address, OUTPUT); } -void GPIOInterface::write_pin(uint8_t address, uint8_t data) +void PinController::write_pin(uint8_t address, bool value) { - digitalWrite(address, data); + digitalWrite(address, value); } -bool GPIOInterface::read_pin(uint8_t address) +bool PinController::read_pin(uint8_t address) { return PULLDOWN == digitalRead(address); } diff --git a/FlippR-Driver/src/GPIOInterface.h b/FlippR-Driver/src/PinController.h similarity index 79% rename from FlippR-Driver/src/GPIOInterface.h rename to FlippR-Driver/src/PinController.h index 9580fe1..05e2ba1 100644 --- a/FlippR-Driver/src/GPIOInterface.h +++ b/FlippR-Driver/src/PinController.h @@ -1,5 +1,5 @@ /* - * GPIOInterface.hpp + * PinController.hpp * * Responsible for communicating with the actual GPIO hardware. * @@ -18,18 +18,18 @@ namespace flippR_driver { -class GPIOInterface +class PinController { public: - GPIOInterface(); - virtual ~GPIOInterface() = default; + PinController(); + virtual ~PinController() = default; protected: static void initialize_input_pin(uint8_t address); static void initialize_output_pin(uint8_t address); - static void write_pin(uint8_t address, uint8_t data); + static void write_pin(uint8_t address, bool value); static bool read_pin(uint8_t address); diff --git a/FlippR-Driver/src/input/Detector.h b/FlippR-Driver/src/input/Detector.h index 7432eaa..dbb0da2 100644 --- a/FlippR-Driver/src/input/Detector.h +++ b/FlippR-Driver/src/input/Detector.h @@ -1,55 +1,27 @@ /* * Detector.h * - * Responsible for detecting InputEvents. - * - * Creates two Threads; - * One cycles over the inputs gpios and pushes detected input events to a queue. - * The other cycles over the queue and notifies input event handlers. - * - * Created on: Apr 5, 2018 + * Created on: Jun 13, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#ifndef DETECTOR_H_ -#define DETECTOR_H_ +#ifndef SRC_INPUT_DETECTOR_H_ +#define SRC_INPUT_DETECTOR_H_ -#include -#include -#include - -#include "IInputGPIOInterface.h" - -#include "IDetector.h" -#include "DistributingEvent.h" -#include "IEventNotifier.h" - namespace flippR_driver { namespace input { -class Detector : public IDetector +class Detector { public: - Detector(std::unique_ptr input_gpio_interface, std::vector> events); - ~Detector() override; - -private: - void detect(); - void check_inputs(); - -private: - const std::unique_ptr input_gpio_interface; - - const std::vector> events; - - bool is_running; - std::thread detect_thread; + virtual ~Detector() = default; }; } + } -#endif +#endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/DistributingEvent.cpp b/FlippR-Driver/src/input/DistributingEvent.cpp index 2445576..6bc2472 100644 --- a/FlippR-Driver/src/input/DistributingEvent.cpp +++ b/FlippR-Driver/src/input/DistributingEvent.cpp @@ -4,20 +4,26 @@ #include "DistributingEvent.h" -flippR_driver::input::DistributingEvent::DistributingEvent(char address, int priority, std::string name, - std::chrono::milliseconds bounce_time, std::shared_ptr event_notifier): - Event(address, priority, std::move(name)), - bounce_time(bounce_time), - event_notifier(std::move(event_notifier)), - activation_state(NOT_ACTIVATED) +namespace flippR_driver +{ +namespace input +{ + +DistributingEvent::DistributingEvent(char address, int priority, std::string name, + std::chrono::milliseconds bounce_time, std::shared_ptr event_notifier) +: +Event(address, priority, std::move(name)), +bounce_time(bounce_time), +event_notifier(std::move(event_notifier)), +activation_state(NOT_ACTIVATED) {} -void flippR_driver::input::DistributingEvent::distribute() +void DistributingEvent::distribute() { event_notifier->distribute_event(*this); } -void flippR_driver::input::DistributingEvent::active() +void DistributingEvent::active() { if(!is_bouncing()) { @@ -35,7 +41,7 @@ void flippR_driver::input::DistributingEvent::active() } } -bool flippR_driver::input::DistributingEvent::is_bouncing() +bool DistributingEvent::is_bouncing() { std::chrono::time_point now = std::chrono::high_resolution_clock::now(); std::chrono::milliseconds elapsed_time = std::chrono::duration_cast(now - last_activation); @@ -43,7 +49,7 @@ bool flippR_driver::input::DistributingEvent::is_bouncing() return elapsed_time < bounce_time; } -void flippR_driver::input::DistributingEvent::inactive() +void DistributingEvent::inactive() { if(activation_state == ACTIVATED) { @@ -52,3 +58,5 @@ void flippR_driver::input::DistributingEvent::inactive() } } +} +} \ No newline at end of file diff --git a/FlippR-Driver/src/input/DistributingEvent.h b/FlippR-Driver/src/input/DistributingEvent.h index 915ade7..3f82bab 100644 --- a/FlippR-Driver/src/input/DistributingEvent.h +++ b/FlippR-Driver/src/input/DistributingEvent.h @@ -6,17 +6,18 @@ #define flippR_driver_DISTRIBUTINGEVENT_H #include "input/Event.h" -#include "IEventNotifier.h" +#include "input/EventNotifier.h" namespace flippR_driver { namespace input { + class DistributingEvent : public Event { public: DistributingEvent(char address, int priority, std::string name, - std::chrono::milliseconds bounce_time, std::shared_ptr event_notifier); + std::chrono::milliseconds bounce_time, std::shared_ptr event_notifier); void active(); void inactive(); @@ -37,11 +38,12 @@ private: ACTIVATED }; - const std::shared_ptr event_notifier; + const std::shared_ptr event_notifier; ActivationState activation_state; }; + } } diff --git a/FlippR-Driver/src/input/Event.cpp b/FlippR-Driver/src/input/Event.cpp index b88823d..5aaa93f 100644 --- a/FlippR-Driver/src/input/Event.cpp +++ b/FlippR-Driver/src/input/Event.cpp @@ -13,8 +13,7 @@ namespace flippR_driver namespace input { -// todo unsigned char address -Event::Event(char address, int priority, std::string name) : +Event::Event(uint8_t address, int priority, std::string name) : address(address), priority(priority), name(name) { CLOG_IF(VLOG_IS_ON(0), INFO, INPUT_LOGGER) << "Created event: " << name << ", address: " << address; diff --git a/FlippR-Driver/src/input/EventNotifier.h b/FlippR-Driver/src/input/EventNotifier.h index 97eb2ac..b68af86 100644 --- a/FlippR-Driver/src/input/EventNotifier.h +++ b/FlippR-Driver/src/input/EventNotifier.h @@ -1,57 +1,33 @@ /* - * InputEventNotifier.h + * EventNotifier.h * - * Created on: May 17, 2018 + * Created on: Jun 13, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#ifndef SRC_INPUT_EVENTNOTIFIER_H_ -#define SRC_INPUT_EVENTNOTIFIER_H_ +#ifndef SRC_INPUT_IEVENTNOTIFIER_H_ +#define SRC_INPUT_IEVENTNOTIFIER_H_ -#include "IEventNotifier.h" - -#include -#include -#include - -#include "utility/BlockingQueue.hpp" -#include "utility/IBlockingQueue.h" #include "input/Event.h" #include "input/EventHandler.h" - -#define HANDLER_TIMEOUT 2000 +#include namespace flippR_driver { namespace input { -class EventNotifier : public IEventNotifier +class EventNotifier { - public: - explicit EventNotifier(utility::IBlockingQueue* queue); - ~EventNotifier() override; + virtual ~EventNotifier() = default; - void register_event_handler(IEventHandler* handler) override; - void unregister_event_handler(IEventHandler* handler) override; + virtual void register_event_handler(EventHandler* handler) = 0; + virtual void unregister_event_handler(EventHandler* handler) = 0; - void distribute_event(Event &event) override; - -private: - void notify(); - -private: - utility::IBlockingQueue* event_queue; - std::set event_handlers; - - bool is_running; - std::thread notify_thread; - std::mutex event_handler_mutex; + virtual void distribute_event(Event &event) = 0; }; -} - - } -#endif +} +#endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/IDetector.h b/FlippR-Driver/src/input/IDetector.h deleted file mode 100644 index c62f560..0000000 --- a/FlippR-Driver/src/input/IDetector.h +++ /dev/null @@ -1,27 +0,0 @@ -/* - * IDetector.h - * - * Created on: Jun 13, 2018 - * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert - */ - -#ifndef SRC_INPUT_IDETECTOR_H_ -#define SRC_INPUT_IDETECTOR_H_ - - -namespace flippR_driver -{ -namespace input -{ - -class IDetector -{ - -public: - virtual ~IDetector() = default; -}; - -} - -} -#endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/IEventNotifier.h b/FlippR-Driver/src/input/IEventNotifier.h deleted file mode 100644 index b368e67..0000000 --- a/FlippR-Driver/src/input/IEventNotifier.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * IEventNotifier.h - * - * Created on: Jun 13, 2018 - * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert - */ - -#ifndef SRC_INPUT_IEVENTNOTIFIER_H_ -#define SRC_INPUT_IEVENTNOTIFIER_H_ - -#include "input/Event.h" -#include "input/IEventHandler.h" -#include - -namespace flippR_driver -{ -namespace input -{ - -class IEventNotifier -{ -public: - virtual ~IEventNotifier() = default; - - virtual void register_event_handler(IEventHandler* handler) = 0; - virtual void unregister_event_handler(IEventHandler* handler) = 0; - - virtual void distribute_event(Event &event) = 0; -}; - -} -} -#endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/InputDriver.h b/FlippR-Driver/src/input/InputDriver.h deleted file mode 100644 index 8296e2b..0000000 --- a/FlippR-Driver/src/input/InputDriver.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * InputDriver.hpp - * - * Created on: May 31, 2018 - * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert - */ -#ifndef SRC_INPUT_INPUTDRIVER_H_ -#define SRC_INPUT_INPUTDRIVER_H_ - -#include "input/IInputDriver.h" - -#include - -#include "IEventNotifier.h" -#include "IDetector.h" - -namespace flippR_driver -{ -namespace input -{ - -class InputDriver : public IInputDriver -{ - -public: - - InputDriver(std::shared_ptr event_notifier, std::unique_ptr detector, std::map> events); - void register_event_handler(IEventHandler* handler) override; - void unregister_event_handler(IEventHandler* handler) override; - - boost::optional> get_event(std::string name) override; - -private: - const std::shared_ptr event_notifier; - const std::unique_ptr detector; - - const std::map> events; -}; - -} - -} -#endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/InputDriverFactory.cpp b/FlippR-Driver/src/input/InputDriverFactory.cpp index e6ae654..0d32c3f 100644 --- a/FlippR-Driver/src/input/InputDriverFactory.cpp +++ b/FlippR-Driver/src/input/InputDriverFactory.cpp @@ -12,9 +12,9 @@ #include "utility/LoggerFactory.h" -#include "InputDriver.h" -#include "EventNotifier.h" -#include "Detector.h" +#include "input/impl/InputDriver.h" +#include "input/impl/EventNotifier.h" +#include "input/impl/Detector.h" namespace flippR_driver { @@ -26,63 +26,64 @@ namespace InputDriverFactory using namespace nlohmann; using namespace flippR_driver::utility; -std::shared_ptr get_InputDriver(std::istream &input_pin_stream, std::istream &matrix_config_stream) +std::shared_ptr get_InputDriver(std::istream &input_pin_stream, std::istream &matrix_config_stream) { LoggerFactory::CreateInputLogger(); IBlockingQueue *event_queue = new BlockingQueue; - std::shared_ptr event_notifier(new EventNotifier(event_queue)); + std::shared_ptr event_notifier(new impl::EventNotifier(event_queue)); std::vector> events; std::map> name_event_map; create_events(matrix_config_stream, events, name_event_map, event_notifier); - std::unique_ptr input_gpio_interface(new InputGPIOInterface(create_pin_map(input_pin_stream))); - std::unique_ptr detector(new Detector(std::move(input_gpio_interface), events)); + std::unique_ptr input_gpio_interface(new impl::InputPinController(create_pin_map(input_pin_stream))); + std::unique_ptr detector(new impl::Detector(std::move(input_gpio_interface), events)); - return std::make_shared(event_notifier, std::move(detector), name_event_map); + return std::make_shared(event_notifier, std::move(detector), name_event_map); } namespace { void create_events(std::istream &matrix_config_stream, std::vector> &events, std::map> &name_event_map, - std::shared_ptr event_notifier) + std::shared_ptr event_notifier) { json matrix_config; matrix_config_stream >> matrix_config; - int global_bounce_time = matrix_config.at("global_bounce_time").get(); - auto &json_events = matrix_config.at("input_matrix"); - for(auto &json_event : json_events) + try { + int global_bounce_time = matrix_config.at("global_bounce_time").get(); + auto &json_events = matrix_config.at("input_matrix"); + + for(auto &json_event : json_events) + { std::shared_ptr event = create_event(json_event, event_notifier, global_bounce_time); events.push_back(event); name_event_map.emplace(event->name, event); - } - } - - std::shared_ptr create_event(json &json_event, std::shared_ptr event_notifier, int bounce_time) - { - try - { - std::string name = json_event.at("name"); - char address = json_event.at("address").get(); - int priority = json_event.at("priority").get(); - - set_individual_bounce_time(json_event, bounce_time); - - return std::make_shared(address, priority, name, std::chrono::milliseconds(bounce_time), event_notifier); + } } catch(json::exception &e) { - CLOG(ERROR, INPUT_LOGGER) << "Matrix config-file corrupted: " << e.what(); + CLOG(ERROR, INPUT_LOGGER) << "Event matrix config file corrupted: " << e.what(); exit(EXIT_FAILURE); } } + std::shared_ptr create_event(json &json_event, std::shared_ptr event_notifier, int bounce_time) + { + std::string name = json_event.at("name"); + char address = json_event.at("address").get(); + int priority = json_event.at("priority").get(); + + set_individual_bounce_time(json_event, bounce_time); + + return std::make_shared(address, priority, name, std::chrono::milliseconds(bounce_time), event_notifier); + } + void set_individual_bounce_time(json &json_event, int &bounce_time) { auto it_bounce_time = json_event.find("bounce_time"); @@ -114,14 +115,9 @@ namespace input_pin_map["data_address"] = pin_config.at("data").get(); } - catch(json::type_error &e) + catch(json::exception &e) { - CLOG(ERROR, INPUT_LOGGER) << "Input json corrupted! " << e.what(); - exit(EXIT_FAILURE); - } - catch(json::out_of_range &e) - { - CLOG(ERROR, INPUT_LOGGER) << "Input json corrupted! " << e.what(); + CLOG(ERROR, INPUT_LOGGER) << "Input pin config file corrupted! " << e.what(); exit(EXIT_FAILURE); } diff --git a/FlippR-Driver/src/input/InputDriverFactory.h b/FlippR-Driver/src/input/InputDriverFactory.h index a98017c..7c3be8c 100644 --- a/FlippR-Driver/src/input/InputDriverFactory.h +++ b/FlippR-Driver/src/input/InputDriverFactory.h @@ -11,10 +11,10 @@ #include #include "json/json.hpp" -#include "input/IInputDriver.h" +#include "input/InputDriver.h" #include "DistributingEvent.h" -#include "InputGPIOInterface.h" -#include "IEventNotifier.h" +#include "input/impl/InputPinController.h" +#include "input/EventNotifier.h" namespace flippR_driver { @@ -22,16 +22,16 @@ namespace input { namespace InputDriverFactory { - std::shared_ptr get_InputDriver(std::istream &input_pin_stream, std::istream &matrix_config_stream); + std::shared_ptr get_InputDriver(std::istream &input_pin_stream, std::istream &matrix_config_stream); namespace { static void create_events(std::istream &matrix_config, std::vector> &events, std::map> &name_event_map, - std::shared_ptr event_notifier); + std::shared_ptr event_notifier); - static std::shared_ptr create_event(nlohmann::json &json_event, std::shared_ptr event_notifier, int bounce_time); + static std::shared_ptr create_event(nlohmann::json &json_event, std::shared_ptr event_notifier, int bounce_time); static void set_individual_bounce_time(nlohmann::json &json_event, int &bounce_time); static std::map create_pin_map(std::istream &input_pin_stream); diff --git a/FlippR-Driver/src/input/IInputGPIOInterface.h b/FlippR-Driver/src/input/InputPinController.h similarity index 76% rename from FlippR-Driver/src/input/IInputGPIOInterface.h rename to FlippR-Driver/src/input/InputPinController.h index f2b4a5b..fb59a96 100644 --- a/FlippR-Driver/src/input/IInputGPIOInterface.h +++ b/FlippR-Driver/src/input/InputPinController.h @@ -1,5 +1,5 @@ /* - * InputGPIOInterface.h + * InputPinController.h * * Created on: May 31, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert @@ -15,10 +15,10 @@ namespace flippR_driver namespace input { -class IInputGPIOInterface +class InputPinController { public: - virtual ~IInputGPIOInterface() = default; + virtual ~InputGPIOInterface() = default; virtual bool read_data(uint8_t pin) const = 0; }; diff --git a/FlippR-Driver/src/input/Detector.cpp b/FlippR-Driver/src/input/impl/Detector.cpp similarity index 70% rename from FlippR-Driver/src/input/Detector.cpp rename to FlippR-Driver/src/input/impl/Detector.cpp index 798b22a..419d1b0 100644 --- a/FlippR-Driver/src/input/Detector.cpp +++ b/FlippR-Driver/src/input/impl/Detector.cpp @@ -15,9 +15,12 @@ namespace flippR_driver { namespace input { +namespace impl +{ -Detector::Detector(std::unique_ptr input_gpio_interface, std::vector> events) : - input_gpio_interface(std::move(input_gpio_interface)), events(std::move(events)), is_running(true) +Detector::Detector(std::unique_ptr input_gpio_interface, std::vector> events) +: +input_gpio_interface(std::move(input_gpio_interface)), events(std::move(events)), is_running(true) { this->detect_thread = std::thread(&Detector::detect, this); @@ -41,7 +44,7 @@ void Detector::detect() void Detector::check_inputs() { - for(auto& event : events) + for(auto &event : events) { input_gpio_interface->read_data(event->address) ? event->active() : event->inactive(); } @@ -49,3 +52,4 @@ void Detector::check_inputs() } } +} diff --git a/FlippR-Driver/src/input/impl/Detector.h b/FlippR-Driver/src/input/impl/Detector.h new file mode 100644 index 0000000..9abd55a --- /dev/null +++ b/FlippR-Driver/src/input/impl/Detector.h @@ -0,0 +1,58 @@ +/* + * Detector.h + * + * Responsible for detecting InputEvents. + * + * Creates two Threads; + * One cycles over the inputs gpios and pushes detected input events to a queue. + * The other cycles over the queue and notifies input event handlers. + * + * Created on: Apr 5, 2018 + * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert + */ + +#ifndef INPUT_IMPL_DETECTOR_H_ +#define INPUT_IMPL_DETECTOR_H_ + + +#include +#include +#include + +#include "input/InputPinController.h" + +#include "input/Detector.h" +#include "input/DistributingEvent.h" +#include "input/EventNotifier.h" + +namespace flippR_driver +{ +namespace input +{ +namespace impl +{ + +class Detector : public input::Detector +{ + +public: + Detector(std::unique_ptr input_gpio_interface, std::vector> events); + ~Detector() override; + +private: + void detect(); + void check_inputs(); + +private: + const std::unique_ptr input_gpio_interface; + + const std::vector> events; + + bool is_running; + std::thread detect_thread; +}; + +} +} +} +#endif diff --git a/FlippR-Driver/src/input/EventHandler.cpp b/FlippR-Driver/src/input/impl/EventHandler.cpp similarity index 74% rename from FlippR-Driver/src/input/EventHandler.cpp rename to FlippR-Driver/src/input/impl/EventHandler.cpp index 9002bdd..8dc5f03 100644 --- a/FlippR-Driver/src/input/EventHandler.cpp +++ b/FlippR-Driver/src/input/impl/EventHandler.cpp @@ -4,16 +4,18 @@ * Created on: Jun 14, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#include "input/EventHandler.h" +#include "EventHandler.h" #include "utility/config.h" namespace flippR_driver { namespace input { +namespace impl +{ -EventHandler::EventHandler(std::shared_ptr input_driver) : - input_driver(std::move(input_driver)) +EventHandler::EventHandler(std::shared_ptr input_driver) : +input_driver(std::move(input_driver)) { this->input_driver->register_event_handler(this); @@ -26,10 +28,11 @@ EventHandler::~EventHandler() } // This function is intended to be non pure, if it is called when the derived class doesn't exist anymore -void EventHandler::handle(Event& event) +void EventHandler::handle(Event &event) { CLOG(WARNING, INPUT_LOGGER) << "Called EventHandler parent class"; } } } +} diff --git a/FlippR-Driver/src/input/EventHandler.h b/FlippR-Driver/src/input/impl/EventHandler.h similarity index 53% rename from FlippR-Driver/src/input/EventHandler.h rename to FlippR-Driver/src/input/impl/EventHandler.h index 7fd1fcf..44fa696 100644 --- a/FlippR-Driver/src/input/EventHandler.h +++ b/FlippR-Driver/src/input/impl/EventHandler.h @@ -9,32 +9,35 @@ * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#ifndef INPUTEVENTHANDLER_H_ -#define INPUTEVENTHANDLER_H_ +#ifndef INPUT_IMPL_EVENTHANDLER_H_ +#define INPUT_IMPL_EVENTHANDLER_H_ -#include "input/IInputDriver.h" +#include "input/InputDriver.h" -#include "input/IEventHandler.h" +#include "input/EventHandler.h" #include "input/Event.h" namespace flippR_driver { namespace input { +namespace impl +{ + class EventHandler; -class EventHandler : public IEventHandler +class EventHandler : public input::EventHandler { public: - explicit EventHandler(std::shared_ptr input_driver); + explicit EventHandler(std::shared_ptr input_driver); ~EventHandler() override; - void handle(Event& event) override; + void handle(Event &event) override; private: - const std::shared_ptr input_driver; + const std::shared_ptr input_driver; }; } - +} } #endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/EventNotifier.cpp b/FlippR-Driver/src/input/impl/EventNotifier.cpp similarity index 74% rename from FlippR-Driver/src/input/EventNotifier.cpp rename to FlippR-Driver/src/input/impl/EventNotifier.cpp index 6fc06b1..2f74d47 100644 --- a/FlippR-Driver/src/input/EventNotifier.cpp +++ b/FlippR-Driver/src/input/impl/EventNotifier.cpp @@ -15,10 +15,12 @@ namespace flippR_driver { namespace input { +namespace impl +{ -EventNotifier::EventNotifier(utility::IBlockingQueue* queue) : - is_running(true), - event_queue(queue) +EventNotifier::EventNotifier(utility::IBlockingQueue *queue) : +is_running(true), +event_queue(queue) { this->notify_thread = std::thread(&EventNotifier::notify, this); @@ -37,13 +39,13 @@ EventNotifier::~EventNotifier() delete this->event_queue; } -void EventNotifier::register_event_handler(IEventHandler* handler) +void EventNotifier::register_event_handler(EventHandler *handler) { std::lock_guard event_handler_guard(event_handler_mutex); this->event_handlers.insert(handler); } -void EventNotifier::unregister_event_handler(IEventHandler* handler) +void EventNotifier::unregister_event_handler(EventHandler *handler) { std::lock_guard event_handler_guard(event_handler_mutex); this->event_handlers.erase(handler); @@ -63,19 +65,19 @@ void EventNotifier::notify() // TODO schoener machen if(event.name == "END") { - return; + return; } // getting a guard and calling all registered handlers std::lock_guard event_handler_guard(this->event_handler_mutex); for(auto handler : this->event_handlers) { - boost::thread handler_caller(boost::bind(&IEventHandler::handle, handler, event)); + boost::thread handler_caller(boost::bind(&EventHandler::handle, handler, event)); - if(!handler_caller.timed_join(boost::posix_time::milliseconds(HANDLER_TIMEOUT))) + if(!handler_caller.timed_join(boost::posix_time::milliseconds(INPUT_HANDLER_TIMEOUT_MILLI))) { CLOG(WARNING, INPUT_LOGGER) << "Handler " << typeid(handler).name() << " didn't finish in " - << HANDLER_TIMEOUT << " milliseconds. Aborting Execution!"; + << INPUT_HANDLER_TIMEOUT_MILLI << " milliseconds. Aborting Execution!"; } } } @@ -83,3 +85,4 @@ void EventNotifier::notify() } } +} diff --git a/FlippR-Driver/src/input/impl/EventNotifier.h b/FlippR-Driver/src/input/impl/EventNotifier.h new file mode 100644 index 0000000..9c04fe0 --- /dev/null +++ b/FlippR-Driver/src/input/impl/EventNotifier.h @@ -0,0 +1,58 @@ +/* + * InputEventNotifier.h + * + * Created on: May 17, 2018 + * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert + */ + +#ifndef INPUT_IMPL_EVENTNOTIFIER_H_ +#define INPUT_IMPL_EVENTNOTIFIER_H_ + +#include "input/EventNotifier.h" + +#include "input/Event.h" +#include "input/EventHandler.h" + +#include "utility/BlockingQueue.hpp" +#include "utility/IBlockingQueue.h" + +#include +#include +#include + + +namespace flippR_driver +{ +namespace input +{ +namespace impl +{ + +class EventNotifier : public input::EventNotifier +{ + +public: + explicit EventNotifier(utility::IBlockingQueue *queue); + ~EventNotifier() override; + + void register_event_handler(EventHandler *handler) override; + void unregister_event_handler(EventHandler *handler) override; + + void distribute_event(Event &event) override; + +private: + void notify(); + +private: + utility::IBlockingQueue *event_queue; + std::set event_handlers; + + bool is_running; + std::thread notify_thread; + std::mutex event_handler_mutex; +}; + +} +} +} +#endif diff --git a/FlippR-Driver/src/input/InputDriver.cpp b/FlippR-Driver/src/input/impl/InputDriver.cpp similarity index 73% rename from FlippR-Driver/src/input/InputDriver.cpp rename to FlippR-Driver/src/input/impl/InputDriver.cpp index 01519f8..835bb67 100644 --- a/FlippR-Driver/src/input/InputDriver.cpp +++ b/FlippR-Driver/src/input/impl/InputDriver.cpp @@ -12,20 +12,22 @@ namespace flippR_driver { namespace input { +namespace impl +{ -InputDriver::InputDriver(std::shared_ptr event_notifier, std::unique_ptr detector, +InputDriver::InputDriver(std::shared_ptr event_notifier, std::unique_ptr detector, std::map> events) : event_notifier(std::move(event_notifier)), detector(std::move(detector)), events(std::move(events)) { CLOG(INFO, INPUT_LOGGER) << "Created InputDriver"; } -void InputDriver::register_event_handler(IEventHandler *handler) +void InputDriver::register_event_handler(EventHandler *handler) { this->event_notifier->register_event_handler(handler); } -void InputDriver::unregister_event_handler(IEventHandler *handler) +void InputDriver::unregister_event_handler(EventHandler *handler) { this->event_notifier->unregister_event_handler(handler); } @@ -40,9 +42,10 @@ boost::optional> InputDriver::get_event(std::string name) { CLOG_N_TIMES(1, WARNING, OUTPUT_LOGGER) << "Did not found event " << name << " please check config file!"; } - return boost::optional>{}; + return boost::optional> {}; } } } +} diff --git a/FlippR-Driver/src/input/impl/InputDriver.h b/FlippR-Driver/src/input/impl/InputDriver.h new file mode 100644 index 0000000..d081831 --- /dev/null +++ b/FlippR-Driver/src/input/impl/InputDriver.h @@ -0,0 +1,45 @@ +/* + * InputDriver.hpp + * + * Created on: May 31, 2018 + * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert + */ +#ifndef INPUT_IMPL_INPUTDRIVER_H_ +#define INPUT_IMPL_INPUTDRIVER_H_ + +#include "input/InputDriver.h" + +#include + +#include "input/EventNotifier.h" +#include "input/Detector.h" + +namespace flippR_driver +{ +namespace input +{ +namespace impl +{ + +class InputDriver : public input::InputDriver +{ + +public: + + InputDriver(std::shared_ptr event_notifier, std::unique_ptr detector, std::map> events); + void register_event_handler(EventHandler *handler) override; + void unregister_event_handler(EventHandler *handler) override; + + boost::optional> get_event(std::string name) override; + +private: + const std::shared_ptr event_notifier; + const std::unique_ptr detector; + + const std::map> events; +}; + +} +} +} +#endif \ No newline at end of file diff --git a/FlippR-Driver/src/input/InputGPIOInterface.cpp b/FlippR-Driver/src/input/impl/InputPinController.cpp similarity index 78% rename from FlippR-Driver/src/input/InputGPIOInterface.cpp rename to FlippR-Driver/src/input/impl/InputPinController.cpp index 75460bd..3a20c9d 100644 --- a/FlippR-Driver/src/input/InputGPIOInterface.cpp +++ b/FlippR-Driver/src/input/impl/InputPinController.cpp @@ -1,11 +1,11 @@ /* - * InputGPIOInterface.cpp + * InputPinController.cpp * * Created on: May 31, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#include "InputGPIOInterface.h" +#include "InputPinController.h" #include @@ -17,17 +17,18 @@ namespace flippR_driver { namespace input { +namespace impl +{ using namespace nlohmann; - -InputGPIOInterface::InputGPIOInterface(std::map pins) - : pins(std::move(pins)) +InputPinController::InputPinController(std::map pins) +: pins(std::move(pins)) { init_pins(); } -bool InputGPIOInterface::read_data(uint8_t pin) const +bool InputPinController::read_data(uint8_t pin) const { // setting address to read write_row(pin / INPUT_MATRIX_SIZE); @@ -39,21 +40,21 @@ bool InputGPIOInterface::read_data(uint8_t pin) const return read_pin(this->pins.at("data_address")); } -void InputGPIOInterface::write_row(u_int8_t data) const +void InputPinController::write_row(u_int8_t data) const { write_pin(this->pins.at("row_address_A"), data & 0b001u); write_pin(this->pins.at("row_address_B"), data & 0b010u); write_pin(this->pins.at("row_address_C"), data & 0b100u); } -void InputGPIOInterface::write_col(uint8_t data) const +void InputPinController::write_col(uint8_t data) const { write_pin(this->pins.at("col_address_A"), data & 0b001u); write_pin(this->pins.at("col_address_B"), data & 0b010u); write_pin(this->pins.at("col_address_C"), data & 0b100u); } -void InputGPIOInterface::init_pins() const +void InputPinController::init_pins() const { initialize_output_pin(this->pins.at("col_address_A")); initialize_output_pin(this->pins.at("col_address_B")); @@ -68,3 +69,4 @@ void InputGPIOInterface::init_pins() const } } +} diff --git a/FlippR-Driver/src/input/InputGPIOInterface.h b/FlippR-Driver/src/input/impl/InputPinController.h similarity index 66% rename from FlippR-Driver/src/input/InputGPIOInterface.h rename to FlippR-Driver/src/input/impl/InputPinController.h index 83fc672..447e319 100644 --- a/FlippR-Driver/src/input/InputGPIOInterface.h +++ b/FlippR-Driver/src/input/impl/InputPinController.h @@ -1,5 +1,5 @@ /* - * InputGPIOInterface.h + * InputPinController.h * * Created on: May 31, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert @@ -8,22 +8,24 @@ #ifndef SRC_UTILITIES_INPUTGPIOINTERFACE_H_ #define SRC_UTILITIES_INPUTGPIOINTERFACE_H_ -#include "IInputGPIOInterface.h" +#include "input/InputPinController.h" #include #include -#include "GPIOInterface.h" +#include "PinController.h" namespace flippR_driver { namespace input { +namespace impl +{ -class InputGPIOInterface : public IInputGPIOInterface, public GPIOInterface +class InputPinController : public input::InputPinController, public PinController { public: - explicit InputGPIOInterface(std::map pins); + explicit InputPinController(std::map pins); bool read_data(uint8_t pin) const override; private: @@ -36,6 +38,7 @@ private: }; +} } } #endif \ No newline at end of file diff --git a/FlippR-Driver/src/output/DisplayController.h b/FlippR-Driver/src/output/DisplayController.h index af0ec19..60f95f8 100644 --- a/FlippR-Driver/src/output/DisplayController.h +++ b/FlippR-Driver/src/output/DisplayController.h @@ -1,45 +1,24 @@ /* * DisplayController.h * - * Created on: Aug 7, 2018 + * Created on: Aug 2, 2018 * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#ifndef _SRC_OUTPUT_DISPLAYCONTROLLER_H_ -#define _SRC_OUTPUT_DISPLAYCONTROLLER_H_ - -#include "IDisplayController.h" - -#include -#include - -#include "items/IDisplay.h" -#include "IOutputGPIOInterface.h" - +#ifndef _SRC_OUTPUT_IDISPLAYCONTROLLER_H_ +#define _SRC_OUTPUT_IDISPLAYCONTROLLER_H_ namespace flippR_driver { namespace output { -class DisplayController : public IDisplayController +class DisplayController { + public: - explicit DisplayController(std::vector> displays, std::shared_ptr output_gpio_interface); - ~DisplayController() override; - -private: - void cycle_displays(); - -private: - std::vector> displays; - - std::thread display_cycle_thread; - - std::shared_ptr output_gpio_interface; - - bool is_running; + virtual ~DisplayController () = default; }; -} +} /* namespace output */ } #endif diff --git a/FlippR-Driver/src/output/DisplayPinController.cpp b/FlippR-Driver/src/output/DisplayPinController.cpp new file mode 100644 index 0000000..54de1ad --- /dev/null +++ b/FlippR-Driver/src/output/DisplayPinController.cpp @@ -0,0 +1,5 @@ +// +// Created by rhetenor on 14.12.18. +// + +#include "DisplayPinController.h" diff --git a/FlippR-Driver/src/output/DisplayPinController.h b/FlippR-Driver/src/output/DisplayPinController.h new file mode 100644 index 0000000..87459f0 --- /dev/null +++ b/FlippR-Driver/src/output/DisplayPinController.h @@ -0,0 +1,13 @@ +// +// Created by rhetenor on 14.12.18. +// + +#ifndef FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H +#define FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H + +class DisplayPinController +{ + +}; + +#endif //FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H diff --git a/FlippR-Driver/src/output/DriverBoardPinController.h b/FlippR-Driver/src/output/DriverBoardPinController.h new file mode 100644 index 0000000..b943a97 --- /dev/null +++ b/FlippR-Driver/src/output/DriverBoardPinController.h @@ -0,0 +1,24 @@ +// +// Created by rhetenor on 13.12.18. +// + +#ifndef FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H +#define FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H + +namespace flippR_driver +{ +namespace output +{ + +class DriverBoardPinController +{ +public: + virtual ~DriverBoardPinController() = default; + + virtual void activate(items::DriverBoardItem *driver_board_item) = 0; + virtual void deactivate(items::DriverBoardItem *driver_board_item) = 0; +}; + +} +} +#endif //FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H diff --git a/FlippR-Driver/src/output/IDisplayController.h b/FlippR-Driver/src/output/IDisplayController.h deleted file mode 100644 index a376370..0000000 --- a/FlippR-Driver/src/output/IDisplayController.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * IDisplayController.h - * - * Created on: Aug 2, 2018 - * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert - */ - -#ifndef _SRC_OUTPUT_IDISPLAYCONTROLLER_H_ -#define _SRC_OUTPUT_IDISPLAYCONTROLLER_H_ -namespace flippR_driver -{ -namespace output -{ - -class IDisplayController -{ - -public: - virtual ~IDisplayController () = default; -}; - -} /* namespace output */ -} -#endif diff --git a/FlippR-Driver/src/output/OutputDriverFactory.cpp b/FlippR-Driver/src/output/OutputDriverFactory.cpp index b5e6001..3e6742e 100644 --- a/FlippR-Driver/src/output/OutputDriverFactory.cpp +++ b/FlippR-Driver/src/output/OutputDriverFactory.cpp @@ -4,8 +4,10 @@ #include "OutputDriverFactory.h" -#include "OutputDriver.h" -#include "OutputGPIOInterface.h" +#include "utility/LoggerFactory.h" + +#include "output/impl/OutputDriver.h" +#include "output/impl/OutputPinController.h" namespace flippR_driver { @@ -19,9 +21,11 @@ namespace using namespace nlohmann; -std::shared_ptr get_OutputDriver(std::istream &output_pin_config, std::istream &solenoid_config, std::istream &lamp_config, std::istream &sound_config, std::istream &display_config) +std::shared_ptr get_OutputDriver(std::istream &output_pin_config, std::istream &solenoid_config, std::istream &lamp_config, std::istream &sound_config, std::istream &display_config) { - std::shared_ptr output_gpio_interface = std::shared_ptr(create_OutputGPIOInterface(output_pin_config)); + utility::LoggerFactory::CreateOutputLogger(); + + std::shared_ptr output_gpio_interface = std::shared_ptr(create_OutputGPIOInterface(output_pin_config)); auto solenoids = create_solenoids(solenoid_config, output_gpio_interface); auto lamps = create_lamps(lamp_config, output_gpio_interface); @@ -32,7 +36,7 @@ std::shared_ptr get_OutputDriver(std::istream &output_pin_config, return std::make_shared(solenoids, lamps, sounds, displays); } -IOutputGPIOInterface* create_OutputGPIOInterface(std::istream &output_pin_config) +OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_config) { json output_config; output_pin_config >> output_config; @@ -46,52 +50,74 @@ std::map parse_pins_driver_board(json &driver_board_config { std::map pins_driver_board; - pins_driver_board["i2c_address"] = driver_board_config.at("i2c_address").get(); - pins_driver_board["pin_base"] = driver_board_config.at("pin_base").get(); - pins_driver_board["data"] = driver_board_config.at("data").get(); - pins_driver_board["CL"] = driver_board_config.at("CL").get(); + try + { + pins_driver_board["i2c_address"] = driver_board_config.at("i2c_address").get(); + pins_driver_board["pin_base"] = driver_board_config.at("pin_base").get(); + pins_driver_board["data"] = driver_board_config.at("data").get(); + pins_driver_board["CL"] = driver_board_config.at("CL").get(); - json pin_select = driver_board_config.at("pin-select"); - pins_driver_board["pin-select-A"] = pin_select.at("A").get(); - pins_driver_board["pin-select-B"] = pin_select.at("B").get(); - pins_driver_board["pin-select-C"] = pin_select.at("C").get(); - - json latch_select = driver_board_config.at("latch-select"); - pins_driver_board["mux1"] = latch_select.at("mux1").get(); - pins_driver_board["mux2"] = latch_select.at("mux2").get(); - pins_driver_board["latch-select-A"] = latch_select.at("A").get(); - pins_driver_board["latch-select-B"] = latch_select.at("B").get(); - pins_driver_board["latch-select-C"] = latch_select.at("C").get(); + json pin_select = driver_board_config.at("pin-select"); + pins_driver_board["pin-select-A"] = pin_select.at("A").get(); + pins_driver_board["pin-select-B"] = pin_select.at("B").get(); + pins_driver_board["pin-select-C"] = pin_select.at("C").get(); + json latch_select = driver_board_config.at("latch-select"); + pins_driver_board["mux1"] = latch_select.at("mux1").get(); + pins_driver_board["mux2"] = latch_select.at("mux2").get(); + pins_driver_board["latch-select-A"] = latch_select.at("A").get(); + pins_driver_board["latch-select-B"] = latch_select.at("B").get(); + pins_driver_board["latch-select-C"] = latch_select.at("C").get(); + } + catch(json::exception &e) + { + CLOG(ERROR, OUTPUT_LOGGER) << "Output pin config file at driver_board corrupted: " << e.what(); + exit(EXIT_FAILURE); + } return pins_driver_board; } std::map parse_pins_sound(json &sound_board_config) { std::map pins_sound; + try + { + pins_sound["i2c_address"] = sound_board_config.at("i2c_address").get(); + pins_sound["pin_base"] = sound_board_config.at("pin_base").get(); + pins_sound["fire"] = sound_board_config.at("fire").get(); - pins_sound["i2c_address"] = sound_board_config.at("i2c_address").get(); - pins_sound["pin_base"] = sound_board_config.at("pin_base").get(); - pins_sound["fire"] = sound_board_config.at("fire").get(); - - json sound_address = sound_board_config.at("sound_address"); - pins_sound["A"] = sound_address.at("A").get(); - pins_sound["B"] = sound_address.at("B").get(); - pins_sound["C"] = sound_address.at("C").get(); - pins_sound["D"] = sound_address.at("D").get(); - pins_sound["E"] = sound_address.at("E").get(); - pins_sound["F"] = sound_address.at("F").get(); - pins_sound["G"] = sound_address.at("G").get(); - + json sound_address = sound_board_config.at("sound_address_select"); + pins_sound["A"] = sound_address.at("A").get(); + pins_sound["B"] = sound_address.at("B").get(); + pins_sound["C"] = sound_address.at("C").get(); + pins_sound["D"] = sound_address.at("D").get(); + pins_sound["E"] = sound_address.at("E").get(); + pins_sound["F"] = sound_address.at("F").get(); + pins_sound["G"] = sound_address.at("G").get(); + } + catch(json::exception &e) + { + CLOG(ERROR, OUTPUT_LOGGER) << "Output pin config file at sound_board corrupted: " << e.what(); + exit(EXIT_FAILURE); + } return pins_sound; } std::map parse_pins_display(json &display_board_config) { - return std::map(); + std::map pins_display; + try + { + pins_display["run"] = display_board_config.at("run"); + } + catch(json::exception &e) + { + CLOG(ERROR, OUTPUT_LOGGER) << "Output pin config file at display_board corrupted: " << e.what(); + exit(EXIT_FAILURE); + } } -std::map> create_solenoids(std::istream &solenoid_config, std::shared_ptr output_gpio_interface) +std::map> create_solenoids(std::istream &solenoid_config, std::shared_ptr output_gpio_interface) { std::map> solenoids; @@ -108,7 +134,7 @@ std::map> create_solenoids(std::i return solenoids; } -std::map> create_lamps(std::istream &lamp_config, std::shared_ptr output_gpio_interface) +std::map> create_lamps(std::istream &lamp_config, std::shared_ptr output_gpio_interface) { std::map> lamps; @@ -124,7 +150,7 @@ std::map> create_lamps(std::istream & return lamps; } -std::map> create_sounds(std::istream &sound_config, std::shared_ptr output_gpio_interface) +std::map> create_sounds(std::istream &sound_config, std::shared_ptr output_gpio_interface) { std::map> sounds; @@ -156,7 +182,7 @@ std::chrono::milliseconds get_deactivation_time(nlohmann::json &json) } } -std::shared_ptr create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr output_gpio_interface, std::chrono::milliseconds deactivation_time) +std::shared_ptr create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr output_gpio_interface, std::chrono::milliseconds deactivation_time) { try { @@ -177,7 +203,7 @@ std::shared_ptr create_solenoid(nlohmann::json &solenoid_json, } } -std::shared_ptr create_lamp(nlohmann::json &lamp_json, std::shared_ptr output_gpio_interface) +std::shared_ptr create_lamp(nlohmann::json &lamp_json, std::shared_ptr output_gpio_interface) { try { @@ -192,7 +218,7 @@ std::shared_ptr create_lamp(nlohmann::json &lamp_json, std::shared_ } } -std::shared_ptr create_sound(nlohmann::json &sound_json, std::shared_ptr &output_gpio_interface, std::chrono::milliseconds deactivation_time) +std::shared_ptr create_sound(nlohmann::json &sound_json, std::shared_ptr &output_gpio_interface, std::chrono::milliseconds deactivation_time) { try { diff --git a/FlippR-Driver/src/output/OutputDriverFactory.h b/FlippR-Driver/src/output/OutputDriverFactory.h index e6f3d07..d1244b5 100644 --- a/FlippR-Driver/src/output/OutputDriverFactory.h +++ b/FlippR-Driver/src/output/OutputDriverFactory.h @@ -5,11 +5,11 @@ #ifndef flippR_driver_OUTPUTDRIVERFACTORY_H #define flippR_driver_OUTPUTDRIVERFACTORY_H -#include "output/IOutputDriver.h" +#include "output/OutputDriver.h" #include "output/items/Solenoid.h" #include "output/items/Lamp.h" #include "output/items/Sound.h" -#include "IOutputGPIOInterface.h" +#include "OutputPinController.h" #include "json/json.hpp" #include @@ -20,24 +20,24 @@ namespace output { namespace OutputDriverFactory { - std::shared_ptr get_OutputDriver(std::istream &output_pin_config, std::istream &solenoid_config, std::istream &lamp_config, std::istream &sound_config, std::istream &display_config); + std::shared_ptr get_OutputDriver(std::istream &output_pin_config, std::istream &solenoid_config, std::istream &lamp_config, std::istream &sound_config, std::istream &display_config); namespace { - std::map> create_solenoids(std::istream &solenoid_config, std::shared_ptr output_gpio_interface); - std::shared_ptr create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr output_gpio_interface, std::chrono::milliseconds deactivation_time); + std::map> create_solenoids(std::istream &solenoid_config, std::shared_ptr output_gpio_interface); + std::shared_ptr create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr output_gpio_interface, std::chrono::milliseconds deactivation_time); - std::map> create_lamps(std::istream &lamp_config, std::shared_ptr output_gpio_interface); - std::shared_ptr create_lamp(nlohmann::json &lamp_json, std::shared_ptr output_gpio_interface); + std::map> create_lamps(std::istream &lamp_config, std::shared_ptr output_gpio_interface); + std::shared_ptr create_lamp(nlohmann::json &lamp_json, std::shared_ptr output_gpio_interface); - std::map> create_sounds(std::istream &sound_config, std::shared_ptr output_gpio_interface); - std::shared_ptr create_sound(nlohmann::json &sound_json, std::shared_ptr output_gpio_interface, std::chrono::milliseconds deactivation_time); + std::map> create_sounds(std::istream &sound_config, std::shared_ptr output_gpio_interface); + std::shared_ptr create_sound(nlohmann::json &sound_json, std::shared_ptr output_gpio_interface, std::chrono::milliseconds deactivation_time); std::chrono::milliseconds get_deactivation_time(nlohmann::json &json); - std::map> create_displays(std::istream &display_config, std::shared_ptr output_gpio_interface); + std::map> create_displays(std::istream &display_config, std::shared_ptr output_gpio_interface); - IOutputGPIOInterface* create_OutputGPIOInterface(std::istream &output_pin_config); + OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_config); std::map parse_pins_driver_board(nlohmann::json &driver_board_config); std::map parse_pins_sound(nlohmann::json &sound_board_config); std::map parse_pins_display(nlohmann::json &display_board_config); diff --git a/FlippR-Driver/src/output/IOutputGPIOInterface.h b/FlippR-Driver/src/output/OutputPinController.h similarity index 56% rename from FlippR-Driver/src/output/IOutputGPIOInterface.h rename to FlippR-Driver/src/output/OutputPinController.h index 2a7ec8f..47db80d 100644 --- a/FlippR-Driver/src/output/IOutputGPIOInterface.h +++ b/FlippR-Driver/src/output/OutputPinController.h @@ -5,7 +5,7 @@ #ifndef flippR_driver_IOUTPUTGPIOINTERFACE_H #define flippR_driver_IOUTPUTGPIOINTERFACE_H -#include "IOutputGPIOInterface.h" +#include "OutputPinController.h" #include "output/items/DriverBoardItem.h" #include "output/items/Sound.h" @@ -18,16 +18,11 @@ namespace flippR_driver namespace output { -class IOutputGPIOInterface +class OutputPinController { public: - virtual ~IOutputGPIOInterface() = default; + virtual ~OutputPinController() = default; - virtual void activate(items::DriverBoardItem *driver_board_item) = 0; - virtual void activate(items::Item *sound) = 0; - - virtual void deactivate(items::DriverBoardItem *driver_board_item) = 0; - virtual void deactivate(items::Item *sound) = 0; virtual void write_display(items::IDisplay &display) = 0; //Display gpio interface! diff --git a/FlippR-Driver/src/output/SoundBoardPinController.h b/FlippR-Driver/src/output/SoundBoardPinController.h new file mode 100644 index 0000000..f2127df --- /dev/null +++ b/FlippR-Driver/src/output/SoundBoardPinController.h @@ -0,0 +1,25 @@ +// +// Created by rhetenor on 14.12.18. +// + +#ifndef FLIPPR_DRIVER_SOUNDPINCONTROLLER_H +#define FLIPPR_DRIVER_SOUNDPINCONTROLLER_H + +#include "OutputPinController.h" + +namespace flippR_driver +{ +namespace output +{ + +class SoundBoardPinController : public OutputPinController +{ +public: + virtual void activate(const items::Sound &sound) = 0; + virtual void deactivate(const items::Sound &sound) = 0; +}; + +} +} + +#endif //FLIPPR_DRIVER_SOUNDPINCONTROLLER_H diff --git a/FlippR-Driver/src/output/DisplayController.cpp b/FlippR-Driver/src/output/impl/DisplayController.cpp similarity index 78% rename from FlippR-Driver/src/output/DisplayController.cpp rename to FlippR-Driver/src/output/impl/DisplayController.cpp index 50b9917..96e8b94 100644 --- a/FlippR-Driver/src/output/DisplayController.cpp +++ b/FlippR-Driver/src/output/impl/DisplayController.cpp @@ -13,9 +13,11 @@ namespace flippR_driver { namespace output { +namespace impl +{ -DisplayController::DisplayController(std::vector> displays, std::shared_ptr output_gpio_interface) - : displays(std::move(displays)), output_gpio_interface(std::move(output_gpio_interface)), is_running(true) +DisplayController::DisplayController(std::vector> displays, std::shared_ptr output_gpio_interface) +: displays(std::move(displays)), output_gpio_interface(std::move(output_gpio_interface)), is_running(true) { this->display_cycle_thread = std::thread(&DisplayController::cycle_displays, this); @@ -42,3 +44,4 @@ void DisplayController::cycle_displays() } } +} diff --git a/FlippR-Driver/src/output/impl/DisplayController.h b/FlippR-Driver/src/output/impl/DisplayController.h new file mode 100644 index 0000000..4868fc7 --- /dev/null +++ b/FlippR-Driver/src/output/impl/DisplayController.h @@ -0,0 +1,47 @@ +/* + * 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 +#include + +#include "output/items/IDisplay.h" +#include "output/OutputPinController.h" + +namespace flippR_driver +{ +namespace output +{ +namespace impl +{ + +class DisplayController : public output::DisplayController +{ +public: + explicit DisplayController(std::vector> displays, std::shared_ptr output_gpio_interface); + ~DisplayController() override; + +private: + void cycle_displays(); + +private: + std::vector> displays; + + std::thread display_cycle_thread; + + std::shared_ptr output_gpio_interface; + + bool is_running; +}; + +} +} +#endif diff --git a/FlippR-Driver/src/output/impl/DriverBoardPinController.cpp b/FlippR-Driver/src/output/impl/DriverBoardPinController.cpp new file mode 100644 index 0000000..df3c235 --- /dev/null +++ b/FlippR-Driver/src/output/impl/DriverBoardPinController.cpp @@ -0,0 +1,85 @@ +// +// Created by rhetenor on 14.12.18. +// + +#include "DriverBoardPinController.h" + +namespace flippR_driver +{ +namespace output +{ +namespace impl +{ + +void DriverBoardPinController::activate(items::DriverBoardItem *driver_board_item) +{ + std::lock_guard 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 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) +{ + int latch = address / 8; + int pin = address % 8; + + select_mux(latch); + + select_latch(latch); + + select_pin(pin); +} + +void DriverBoardPinController::select_mux(uint8_t latch) +{ + 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) +{ + // 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) +{ + write_pin(pins_driver_board.at("data"), data); +} + +void DriverBoardPinController::select_pin(uint8_t pin) +{ + 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) +{ + PinController::write_pin(pins_driver_board.at("pin_base") + pin, value); +} + +} +} +} \ No newline at end of file diff --git a/FlippR-Driver/src/output/impl/DriverBoardPinController.h b/FlippR-Driver/src/output/impl/DriverBoardPinController.h new file mode 100644 index 0000000..d2615c8 --- /dev/null +++ b/FlippR-Driver/src/output/impl/DriverBoardPinController.h @@ -0,0 +1,49 @@ +// +// Created by rhetenor on 14.12.18. +// + +#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_DRIVERBOARDPINCONTROLLER_H +#define FLIPPR_DRIVER_OUTPUT_IMPL_DRIVERBOARDPINCONTROLLER_H + +#include "PinController.h" +#include "output/DriverBoardPinController.h" + +#include +#include + +namespace flippR_driver +{ +namespace output +{ +namespace impl +{ + +class DriverBoardPinController : public PinController, public output::DriverBoardPinController +{ +public: + DriverBoardPinController(std::map pins_driver_board, std::shared_ptr output_item_mutex); + ~DriverBoardPinController() override = default; + + virtual void activate(items::DriverBoardItem *driver_board_item) = 0; + virtual void deactivate(items::DriverBoardItem *driver_board_item) = 0; + +private: + 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_pin(uint8_t pin, bool value); + +private: + std::shared_ptr output_item_mutex; + + const std::map pins_driver_board; +}; + +} +} +} + +#endif //FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H diff --git a/FlippR-Driver/src/output/OutputDriver.cpp b/FlippR-Driver/src/output/impl/OutputDriver.cpp similarity index 97% rename from FlippR-Driver/src/output/OutputDriver.cpp rename to FlippR-Driver/src/output/impl/OutputDriver.cpp index dc99682..b7a18fe 100644 --- a/FlippR-Driver/src/output/OutputDriver.cpp +++ b/FlippR-Driver/src/output/impl/OutputDriver.cpp @@ -14,6 +14,8 @@ namespace flippR_driver { namespace output { +namespace impl +{ using namespace items; @@ -21,7 +23,6 @@ OutputDriver::OutputDriver(std::map> sol : solenoids(std::move(solenoids)), lamps(std::move(lamps)), sounds(std::move(sounds)), displays(std::move(displays)) {} - std::vector> OutputDriver::get_sounds() { std::vector> sounds; @@ -60,7 +61,7 @@ std::vector> OutputDriver::get_solenoids() boost::optional> OutputDriver::get_lamp(std::string name) { -return this->lamps.find(name)->second; + return this->lamps.find(name)->second; } boost::optional> OutputDriver::get_solenoid(std::string name) @@ -78,6 +79,6 @@ boost::optional> OutputDriver::get_display(char return this->displays.find(number)->second; } - +} } /* namespace output */ } diff --git a/FlippR-Driver/src/output/OutputDriver.h b/FlippR-Driver/src/output/impl/OutputDriver.h similarity index 85% rename from FlippR-Driver/src/output/OutputDriver.h rename to FlippR-Driver/src/output/impl/OutputDriver.h index 7212cbe..fca6bdf 100644 --- a/FlippR-Driver/src/output/OutputDriver.h +++ b/FlippR-Driver/src/output/impl/OutputDriver.h @@ -8,7 +8,7 @@ #ifndef _SRC_OUTPUT_OUTPUTDRIVER_H_ #define _SRC_OUTPUT_OUTPUTDRIVER_H_ -#include "output/IOutputDriver.h" +#include "output/OutputDriver.h" #include @@ -16,11 +16,13 @@ namespace flippR_driver { namespace output { +namespace impl +{ -class OutputDriver : public IOutputDriver +class OutputDriver : public output::OutputDriver { public: - OutputDriver(std::map> solenoids, std::map> lamps, std::map> sounds, std::map> displays); + OutputDriver(std::map> solenoids, std::map> lamps, std::map> sounds, std::map> displays); ~OutputDriver() override = default; // todo what is flipper_relay ? @@ -38,10 +40,11 @@ private: const std::map> lamps; const std::map> solenoids; const std::map> sounds; - + const std::map> displays; }; +} } /* namespace output */ } #endif diff --git a/FlippR-Driver/src/output/OutputGPIOInterface.cpp b/FlippR-Driver/src/output/impl/OutputPinController.cpp similarity index 53% rename from FlippR-Driver/src/output/OutputGPIOInterface.cpp rename to FlippR-Driver/src/output/impl/OutputPinController.cpp index fe0df6c..dde128d 100644 --- a/FlippR-Driver/src/output/OutputGPIOInterface.cpp +++ b/FlippR-Driver/src/output/impl/OutputPinController.cpp @@ -5,7 +5,7 @@ * Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert */ -#include "OutputGPIOInterface.h" +#include "OutputPinController.h" #include "utility/config.h" @@ -13,6 +13,9 @@ namespace flippR_driver { namespace output { +namespace impl +{ + using namespace output::items; OutputGPIOInterface::OutputGPIOInterface(std::map pins_driver_board, std::map pins_sound, std::map pins_display) @@ -35,7 +38,7 @@ void OutputGPIOInterface::initialize_all_pins(uint8_t pin_base) { for(int i = 0; i < 16; i++) { - GPIOInterface::initialize_output_pin(pin_base + i); + PinController::initialize_output_pin(pin_base + i); } } @@ -46,101 +49,7 @@ void OutputGPIOInterface::initialize_i2c_addresses() mcp23017Setup(pins_display.at("pin_base"), pins_display.at("i2c_address")); } -void OutputGPIOInterface::activate(items::Item *sound) -{ - std::lock_guard guard(output_item_mutex); - write_sound_address(sound->get_address()); - - fire_sound(true); -} - -void OutputGPIOInterface::activate(items::DriverBoardItem *driver_board_item) -{ - std::lock_guard guard(output_item_mutex); - - write_driver_board_address(driver_board_item->get_address()); - - write_data(true); -} - -void OutputGPIOInterface::deactivate(items::DriverBoardItem *driver_board_item) -{ - std::lock_guard guard(output_item_mutex); - - write_driver_board_address(driver_board_item->get_address()); - - write_data(false); -} - -void OutputGPIOInterface::deactivate(items::Item *sound) -{ - std::lock_guard guard(output_item_mutex); - - write_sound_address(sound->get_address()); - - fire_sound(false); -} - -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.at("mux1"), mux1); - write_pin(pins_driver_board.at("mux2"), !mux1); -} - -void OutputGPIOInterface::select_latch(uint8_t latch) -{ - // 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 OutputGPIOInterface::write_data(bool data) -{ - write_pin(pins_driver_board.at("data"), data); -} - -void OutputGPIOInterface::select_pin(uint8_t pin) -{ - 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 OutputGPIOInterface::write_sound_address(uint8_t address) -{ - 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 OutputGPIOInterface::fire_sound(bool fire) -{ - GPIOInterface::write_pin(pins_sound.at("fire"), fire); -} void OutputGPIOInterface::write_display(IDisplay &display) { @@ -161,7 +70,7 @@ void OutputGPIOInterface::write_display_digit(const uint8_t display_address, con run_display(display_address); - std::this_thread::sleep_for(std::chrono::milliseconds(DISPLAY_SLEEP_TIME_MILLISECONDS)); + std::this_thread::sleep_for(std::chrono::milliseconds(DISPLAY_SLEEP_TIME_MILLI)); } void OutputGPIOInterface::select_display_segment(const uint8_t &segment) @@ -196,5 +105,7 @@ void OutputGPIOInterface::deactivate_displays() write_pin(pins_display.at("run"), 0); } + + } } diff --git a/FlippR-Driver/src/output/OutputGPIOInterface.h b/FlippR-Driver/src/output/impl/OutputPinController.h similarity index 55% rename from FlippR-Driver/src/output/OutputGPIOInterface.h rename to FlippR-Driver/src/output/impl/OutputPinController.h index 69a96af..b3fb4ee 100644 --- a/FlippR-Driver/src/output/OutputGPIOInterface.h +++ b/FlippR-Driver/src/output/impl/OutputPinController.h @@ -8,8 +8,8 @@ #ifndef SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_ #define SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_ -#include "IOutputGPIOInterface.h" -#include "GPIOInterface.h" +#include "output/OutputPinController.h" +#include "PinController.h" #include #include @@ -18,19 +18,19 @@ namespace flippR_driver { namespace output { +namespace impl +{ -class OutputGPIOInterface : public GPIOInterface, public IOutputGPIOInterface +class OutputGPIOInterface : public PinController, public output::OutputPinController { public: - OutputGPIOInterface(std::map pins_driver_board, std::map pins_sound, std::map pins_display); + OutputGPIOInterface(, std::map pins_sound, std::map pins_display); ~OutputGPIOInterface() override = default; - void activate(items::DriverBoardItem *driver_board_item) override; void activate(items::Item *sound) override; - void deactivate(items::DriverBoardItem *driver_board_item) override; void deactivate(items::Item *sound) override; void activate_displays(); @@ -48,23 +48,12 @@ private: 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; - const std::map pins_driver_board; - const std::map pins_sound; const std::map pins_display; }; +} } } diff --git a/FlippR-Driver/src/output/impl/SoundBoardPinController.cpp b/FlippR-Driver/src/output/impl/SoundBoardPinController.cpp new file mode 100644 index 0000000..ef746c3 --- /dev/null +++ b/FlippR-Driver/src/output/impl/SoundBoardPinController.cpp @@ -0,0 +1,56 @@ +// +// Created by rhetenor on 14.12.18. +// + +#include "SoundBoardPinController.h" + +namespace flippR_driver +{ +namespace output +{ +namespace impl +{ + +void SoundBoardPinController::activate(items::Sound &sound) +{ + std::lock_guard guard(output_item_mutex); + + write_sound_address(sound->get_address()); + + fire_sound(true); +} + +void SoundBoardPinController::deactivate(items::Sound &sound) +{ + std::lock_guard guard(output_item_mutex); + + write_sound_address(sound->get_address()); + + fire_sound(false); +} + + +void SoundBoardPinController::write_sound_address(uint8_t address) +{ + 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) +{ + PinController::write_pin(pins_sound.at("fire"), fire); +} + +void SoundBoardPinController::write_pin(uint8_t pin, bool value) +{ + PinController::write_pin(pins_sound.at("pin_base") + pin, value); +} + +} +} +} diff --git a/FlippR-Driver/src/output/impl/SoundBoardPinController.h b/FlippR-Driver/src/output/impl/SoundBoardPinController.h new file mode 100644 index 0000000..bedb306 --- /dev/null +++ b/FlippR-Driver/src/output/impl/SoundBoardPinController.h @@ -0,0 +1,45 @@ +// +// Created by rhetenor on 14.12.18. +// + +#ifndef FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H +#define FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H + +#include +#include "output/SoundBoardPinController.h" + +#include "PinController.h" + +namespace flippR_driver +{ +namespace output +{ +namespace impl +{ + +class SoundBoardPinController : public PinController, public output::SoundBoardPinController +{ +public: + SoundBoardPinController(); + ~SoundBoardPinController() override = default; + + void activate(const items::Sound &sound) override; + void deactivate(const items::Sound &sound) override; + +private: + void write_sound_address(uint8_t address); + void fire_sound(bool fire); + + void write_pin(uint8_t pin, bool value); + +private: + std::shared_ptr output_item_mutex; + + const std::map pins_sound; + +}; + +} +} +} +#endif //FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H diff --git a/FlippR-Driver/src/output/items/DriverBoardItem.h b/FlippR-Driver/src/output/items/DriverBoardItem.h index 91ccc94..ff16abe 100644 --- a/FlippR-Driver/src/output/items/DriverBoardItem.h +++ b/FlippR-Driver/src/output/items/DriverBoardItem.h @@ -19,10 +19,10 @@ namespace items class DriverBoardItem : public Item { public: - DriverBoardItem(std::shared_ptr output_gpio_interface, uint8_t address, std::string name) : + DriverBoardItem(std::shared_ptr output_gpio_interface, uint8_t address, std::string name) : Item(std::move(output_gpio_interface), address, std::move(name)) {} - ~DriverBoardItem() override = default; + ~DriverBoardItem() override = default; }; } diff --git a/FlippR-Driver/src/output/items/Item.cpp b/FlippR-Driver/src/output/items/Item.cpp index eb171ca..b1fbaf5 100644 --- a/FlippR-Driver/src/output/items/Item.cpp +++ b/FlippR-Driver/src/output/items/Item.cpp @@ -12,7 +12,7 @@ namespace output namespace items { -Item::Item(std::shared_ptr output_gpio_interface, uint8_t address, std::string name) : +Item::Item(std::shared_ptr output_gpio_interface, uint8_t address, std::string name) : address(address), name(std::move(name)), gpio_interface(std::move(output_gpio_interface)) diff --git a/FlippR-Driver/src/output/items/Item.h b/FlippR-Driver/src/output/items/Item.h index ccfac8a..072c0a4 100644 --- a/FlippR-Driver/src/output/items/Item.h +++ b/FlippR-Driver/src/output/items/Item.h @@ -18,7 +18,7 @@ namespace flippR_driver namespace output { -class IOutputGPIOInterface; +class OutputPinController; namespace items { @@ -26,7 +26,7 @@ namespace items class Item : public IItem { public: - Item(std::shared_ptr output_gpio_interface, uint8_t address, std::string name); + Item(std::shared_ptr output_gpio_interface, uint8_t address, std::string name); ~Item() override = default; uint8_t get_address() override; @@ -36,7 +36,7 @@ protected: const uint8_t address; const std::string name; - const std::shared_ptr gpio_interface; + const std::shared_ptr gpio_interface; }; diff --git a/FlippR-Driver/src/output/items/Lamp.cpp b/FlippR-Driver/src/output/items/Lamp.cpp index 91e4389..f9a9ca3 100644 --- a/FlippR-Driver/src/output/items/Lamp.cpp +++ b/FlippR-Driver/src/output/items/Lamp.cpp @@ -7,7 +7,7 @@ #include "Lamp.h" -#include "output/IOutputGPIOInterface.h" +#include "output/OutputPinController.h" namespace flippR_driver { namespace output @@ -15,7 +15,7 @@ namespace output namespace items { -Lamp::Lamp(std::shared_ptr output_gpio_interface, uint8_t address, std::string name) : +Lamp::Lamp(std::shared_ptr output_gpio_interface, uint8_t address, std::string name) : DriverBoardItem(std::move(output_gpio_interface), address, std::move(name)), activated(false) {} diff --git a/FlippR-Driver/src/output/items/Lamp.h b/FlippR-Driver/src/output/items/Lamp.h index 854a6a1..5eae076 100644 --- a/FlippR-Driver/src/output/items/Lamp.h +++ b/FlippR-Driver/src/output/items/Lamp.h @@ -21,7 +21,7 @@ namespace items class Lamp : public DriverBoardItem, public ILamp { public: - Lamp(std::shared_ptr output_gpio_interface, uint8_t address, std::string name); + Lamp(std::shared_ptr output_gpio_interface, uint8_t address, std::string name); ~Lamp() override = default; void activate() override; diff --git a/FlippR-Driver/src/output/items/Solenoid.cpp b/FlippR-Driver/src/output/items/Solenoid.cpp index 32585c5..0e60ed3 100644 --- a/FlippR-Driver/src/output/items/Solenoid.cpp +++ b/FlippR-Driver/src/output/items/Solenoid.cpp @@ -7,7 +7,7 @@ #include "Solenoid.h" -#include "output/IOutputGPIOInterface.h" +#include "output/OutputPinController.h" namespace flippR_driver { @@ -16,7 +16,7 @@ namespace output namespace items { -Solenoid::Solenoid(std::shared_ptr output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time): +Solenoid::Solenoid(std::shared_ptr output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time): DriverBoardItem(std::move(output_gpio_interface), address, std::move(name)), deactivation_time(deactivation_time) {} diff --git a/FlippR-Driver/src/output/items/Solenoid.h b/FlippR-Driver/src/output/items/Solenoid.h index d0ff6ec..ad51702 100644 --- a/FlippR-Driver/src/output/items/Solenoid.h +++ b/FlippR-Driver/src/output/items/Solenoid.h @@ -24,7 +24,7 @@ namespace items class Solenoid : public DriverBoardItem, public ISolenoid { public: - Solenoid(std::shared_ptr output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time); + Solenoid(std::shared_ptr output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time); ~Solenoid() override = default; void trigger() override; diff --git a/FlippR-Driver/src/output/items/Sound.cpp b/FlippR-Driver/src/output/items/Sound.cpp index caf03c3..118e340 100644 --- a/FlippR-Driver/src/output/items/Sound.cpp +++ b/FlippR-Driver/src/output/items/Sound.cpp @@ -7,7 +7,7 @@ #include "Sound.h" -#include "output/IOutputGPIOInterface.h" +#include "output/OutputPinController.h" namespace flippR_driver { @@ -16,7 +16,7 @@ namespace output namespace items { -Sound::Sound(std::shared_ptr output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id) : +Sound::Sound(std::shared_ptr output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id) : Item(std::move(output_gpio_interface), address, std::move(name)), deactivation_time(deactivation_time), id(id) {} diff --git a/FlippR-Driver/src/output/items/Sound.h b/FlippR-Driver/src/output/items/Sound.h index bb29386..4954669 100644 --- a/FlippR-Driver/src/output/items/Sound.h +++ b/FlippR-Driver/src/output/items/Sound.h @@ -29,7 +29,7 @@ public: u_int id; public: - Sound(std::shared_ptr output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id); + Sound(std::shared_ptr output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id); ~Sound() override = default; void play() override; diff --git a/FlippR-Driver/src/utility/InputSocketHandler.h b/FlippR-Driver/src/utility/InputSocketHandler.h index a5aab61..448f422 100644 --- a/FlippR-Driver/src/utility/InputSocketHandler.h +++ b/FlippR-Driver/src/utility/InputSocketHandler.h @@ -7,14 +7,14 @@ #include "SocketHandler.h" -#include "input/IEventHandler.h" +#include "input/EventHandler.h" #include namespace flippR_driver { namespace utility { -class InputSocketHandler : public SocketHandler, public IEventHandler +class InputSocketHandler : public SocketHandler, public EventHandler { public: explicit InputSocketHandler(boost::asio::io_service &service, std::string socket_file = "/var/run/user/" + std::to_string(getuid()) diff --git a/FlippR-Driver/src/utility/config.h b/FlippR-Driver/src/utility/config.h index 834062d..82089ac 100644 --- a/FlippR-Driver/src/utility/config.h +++ b/FlippR-Driver/src/utility/config.h @@ -14,7 +14,8 @@ #define INPUT_MATRIX_SIZE 8 #define INPUT_SLEEP_DURATION_NANO 800 +#define INPUT_HANDLER_TIMEOUT_MILLI 2000 #define PULLDOWN false -#define DISPLAY_SLEEP_TIME_MILLISECONDS 1 +#define DISPLAY_SLEEP_TIME_MILLI 1 diff --git a/FlippR-Driver/tests/catch.hpp b/FlippR-Driver/tests/catch.hpp index 362f869..1de749e 100644 --- a/FlippR-Driver/tests/catch.hpp +++ b/FlippR-Driver/tests/catch.hpp @@ -3373,7 +3373,7 @@ namespace Catch { virtual void skipTest( TestCaseInfo const& testInfo ) = 0; - // Default empty implementation provided + // Default empty impl provided virtual void fatalErrorEncountered( StringRef name ); virtual bool isMulti() const;