Merge branch 'master' of github.com:swinginbird/flippr-code

FlippR-Driver/src/input/Detector.cpp

@@ -10,11 +10,13 @@
 #include <iostream>
 #include <math.h>
 
+#include "../utilities/config.h"
+
 namespace Input
 {
 
-Detector::Detector(InputGPIOInterface* in_gpio_interface, std::map<char, InputEvent> events, InputEventNotifier* input_event_notifier) :
+Detector::Detector(InputGPIOInterface* input_gpio_interface, std::map<char, Event> events, EventNotifier* event_notifier) :
-  in_gpio_interface(in_gpio_interface), input_events(events), is_running(true), input_event_notifier(input_event_notifier)
+  input_gpio_interface(input_gpio_interface), events(events), is_running(true), event_notifier(event_notifier)
 {
   detect_thread = std::thread(&Detector::detect, this);
 }
@@ -24,13 +26,13 @@ Detector::~Detector()
   is_running = false;
 
   detect_thread.join();
-  delete this->in_gpio_interface;
+  delete this->input_gpio_interface;
-  this->in_gpio_interface = NULL;
+  this->input_gpio_interface = NULL;
-  delete this->input_event_notifier;
+  delete this->event_notifier;
-  this->input_event_notifier = NULL;
+  this->event_notifier = NULL;
 }
 
-// Cycles over all inputs and enqueues an input event if detected.
+// Cycles over all s and enqueues an  event if detected.
 void Detector::detect()
 {
   while(is_running)
@@ -40,12 +42,12 @@ void Detector::detect()
     {
       try
       {
-        InputEvent& event = input_events.at(address);
+        Event& event = events.at(address);
-        input_event_notifier->distribute_event(event);
+        event_notifier->distribute_event(event);
       }
       catch(std::out_of_range& e)
       {
-        // todo log exception!
+        CLOG(WARNING, INPUT_LOGGER) << "Did not found event for address: " << address << " check config-file";
       }
     }
   }
@@ -53,24 +55,16 @@ void Detector::detect()
 
 bool Detector::check_inputs(char& address)
 {
-  for(int row = 0; row < 8; row++)
+  for(int pin = 0; pin < MATRIX_SIZE * MATRIX_SIZE; pin++)
   {
-    in_gpio_interface->write_input_row(row);
+    if(input_gpio_interface->read_input_data(pin))
-
-    for(int col = 0; col < 8; col++)
     {
-      in_gpio_interface->write_input_col(col);
+     address = pin;
-
+     return true;
-      // wait for mux to set address
-      std::this_thread::sleep_for(std::chrono::nanoseconds(SLEEP_DURATION_NANO));
-      if(in_gpio_interface->read_input_data())
-      {
-        address = pow(2, row) + col;
-        return true;
-      }
     }
   }
   return false;
+
 }
 
 }

FlippR-Driver/src/input/Detector.h

@@ -17,6 +17,8 @@
 #include <thread>
 #include <map>
 
+#include "../lib/easylogging/easylogging++.h"
+
 #include "../utilities/InputGPIOInterface.h"
 #include "Event.hpp"
 #include "EventNotifier.h"
@@ -26,17 +28,17 @@
 namespace Input
 {
 
-class InputEventHandler
+class EventHandler
 {
 public:
-  void handle(InputEvent& event);
+  void handle(Event& event);
 };
 
 class Detector
 {
 
 public:
-  Detector(InputGPIOInterface* in_gpio_interface, std::map<char, InputEvent> events, InputEventNotifier* input_event_notifier);
+  Detector(InputGPIOInterface* input_gpio_interface, std::map<char, Event> events, EventNotifier* event_notifier);
   ~Detector();
 
 private:
@@ -44,11 +46,11 @@ private:
   bool check_inputs(char& address);
 
 private:
-  InputGPIOInterface* in_gpio_interface;
+  InputGPIOInterface* input_gpio_interface;
 
-  std::map<char, InputEvent> input_events;
+  std::map<char, Event> events;
 
-  InputEventNotifier* input_event_notifier;
+  EventNotifier* event_notifier;
 
   bool is_running;
   std::thread detect_thread;

FlippR-Driver/src/input/Event.hpp

@@ -14,17 +14,17 @@
 namespace Input
 {
 
-class InputEvent
+class Event
 {
 public:
-  InputEvent(char address, char priority, std::string name) : address(address), priority(priority), name(name){}
+  Event(char address, char priority, std::string name) : address(address), priority(priority), name(name){}
 
-  bool operator==(const InputEvent& other)
+  bool operator==(const Event& other)
   {
     return this->name == other.name;
   }
 
-  bool operator<(const InputEvent& other)
+  bool operator<(const Event& other)
   {
     return this->priority < other.priority;
   }

FlippR-Driver/src/input/EventHandler.hpp

@@ -12,31 +12,32 @@
 #ifndef INPUTEVENTHANDLER_H_
 #define INPUTEVENTHANDLER_H_
 
-#include "Detector.h"
+#include "InputDriver.hpp"
 #include "Event.hpp"
+#include "Detector.h"
 
 namespace Input
 {
 
-class InputEventHandler
+class EventHandler
 {
 public:
-  InputEventHandler(std::shared_ptr<Detector> detector) :
+  EventHandler(std::shared_ptr<InputDriver> input_driver) :
-  detector(detector)
+  input_driver(input_driver)
   {
-    this->detector->register_input_event_handler(this);
+    this->input_driver->register_event_handler(this);
   }
 
-  virtual ~InputEventHandler()
+  virtual ~EventHandler()
   {
-    this->detector->unregister_input_event_handler(this);
+    this->input_driver->unregister_event_handler(this);
-    this->detector = NULL;
+    this->input_driver = NULL;
   }
 
-  virtual void handle(InputEvent& event);
+  virtual void handle(Event& event);
 
 private:
-  std::shared_ptr<Detector> detector;
+  std::shared_ptr<InputDriver> input_driver;
 };
 
 }

FlippR-Driver/src/input/EventNotifier.cpp

@@ -1,5 +1,5 @@
 /*
- * InputEventNotifier.cpp
+ * EventNotifier.cpp
  *
  *  Created on: May 17, 2018
  *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert, Rafael Vinci, Dr. Franca Rupprecht
@@ -10,41 +10,41 @@
 namespace Input
 {
 
-InputEventNotifier::InputEventNotifier()
+EventNotifier::EventNotifier()
 : is_running(true)
 {
-  notify_thread = std::thread(&InputEventNotifier::notify, this);
+  notify_thread = std::thread(&EventNotifier::notify, this);
 }
 
-InputEventNotifier::~InputEventNotifier()
+EventNotifier::~EventNotifier()
 {
   is_running = false;
 
   notify_thread.join();
 }
 
-void InputEventNotifier::register_input_event_handler(InputEventHandler* handler)
+void EventNotifier::register_event_handler(EventHandler* handler)
 {
   std::lock_guard<std::mutex> event_handler_guard(event_handler_mutex);
   event_handler.insert(handler);
 }
 
-void InputEventNotifier::unregister_input_event_handler(InputEventHandler* handler)
+void EventNotifier::unregister_event_handler(EventHandler* handler)
 {
   std::lock_guard<std::mutex> event_handler_guard(event_handler_mutex);
   event_handler.erase(handler);
 }
 
-void InputEventNotifier::distribute_event(InputEvent& event)
+void EventNotifier::distribute_event(Event& event)
 {
   event_queue.push(event);
 }
 
-void InputEventNotifier::notify()
+void EventNotifier::notify()
 {
   while(is_running)
   {
-    InputEvent event = event_queue.pop();
+    Event event = event_queue.pop();
 
     // getting a guard and calling all registered handlers
     std::lock_guard<std::mutex> event_handler_guard(event_handler_mutex);

FlippR-Driver/src/input/EventNotifier.h

@@ -18,23 +18,25 @@
 
 namespace Input
 {
-class InputEventNotifier
+
+class EventNotifier
 {
+
 public:
-  InputEventNotifier();
+  EventNotifier();
-  ~InputEventNotifier();
+  ~EventNotifier();
 
-  void register_input_event_handler(InputEventHandler* handler);
+  void register_event_handler(EventHandler* handler);
-  void unregister_input_event_handler(InputEventHandler* handler);
+  void unregister_event_handler(EventHandler* handler);
 
-  void distribute_event(InputEvent& event);
+  void distribute_event(Event& event);
 
 private:
   void notify();
 
 private:
-  BlockingQueue<InputEvent> event_queue;
+  BlockingQueue<Event> event_queue;
-  std::set<InputEventHandler*> event_handler;
+  std::set<EventHandler*> event_handler;
 
   bool is_running;
   std::thread notify_thread;

FlippR-Driver/src/input/InputDriver.hpp

@@ -8,8 +8,16 @@
 #ifndef SRC_INPUT_INPUTDRIVER_HPP_
 #define SRC_INPUT_INPUTDRIVER_HPP_
 
+#include "EventHandler.hpp"
+namespace Input
+{
 
+class InputDriver
+{
+  void register_event_handler(EventHandler* handler);
+  void unregister_event_handler(EventHandler* handler);
+};
 
-
+}
 
 #endif /* SRC_INPUT_INPUTDRIVER_HPP_ */

FlippR-Driver/src/input/InputDriverFactory.hpp

@@ -13,11 +13,16 @@
 #include "Detector.h"
 
 #include "../utilities/InputGPIOInterface.h"
+#include "../utilities/config.h"
 #include "../lib/json/json.hpp"
+#include "../lib/easylogging/easylogging++.h"
 #include "EventNotifier.h"
 
 using namespace nlohmann;
 
+
+INITIALIZE_EASYLOGGINGPP
+
 namespace Input
 {
 class InputFactory
@@ -54,6 +59,17 @@ private:
     return input_events;
   }
 
+  static void ConfigureLogger()
+  {
+    el::Loggers::getLogger(INPUT_LOGGER);
+
+    //TODO may configure?
+    el::Configurations defaultConf;
+    defaultConf.setToDefault();
+
+    el::Loggers::reconfigureLogger(INPUT_LOGGER,defaultConf);
+  }
+
 };
 }
 

FlippR-Driver/src/utilities/GPIOInterface.hpp

@@ -15,11 +15,8 @@
 
 #include <fstream>
 
-#include "../lib/json/json.hpp"
 #include "../lib/wiringPi/wiringPi.h"
 
-using namespace nlohmann;
-
 class GPIOInterface
 {
 public:
@@ -35,9 +32,6 @@ public:
   {
     return digitalRead(address);
   }
-
-protected:
-  json config;
 };
 
 

FlippR-Driver/src/utilities/InputGPIOInterface.cpp

@@ -20,6 +20,9 @@ bool InputGPIOInterface::read_input_data(char pin)
   write_input_row(pin / MATRIX_SIZE);
   write_input_col(pin % MATRIX_SIZE);
 
+  // wait for mux to set address
+  std::this_thread::sleep_for(std::chrono::nanoseconds(SLEEP_DURATION_NANO));
+
   return read_pin(this->input_data_address);
 }
 

FlippR-Driver/src/utilities/config.h

@@ -0,0 +1,8 @@
+/*
+ * BlockingQueue.hpp
+ *
+ *  Created on: May 17, 2018
+ *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert, Rafael Vinci, Dr. Franca Rupprecht
+ */
+
+#define INPUT_LOGGER "input_logger"