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

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

Browse Source
This commit is contained in:
andi
2018-05-31 19:03:17 +02:00
parent b4dfcd3026 0dfe020934
commit 4b6ba5d3df
11 changed files with 95 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
FlippR-Driver/src/input/Detector.cpp
View File

@@ -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) :
in_gpio_interface(in_gpio_interface), input_events(events), is_running(true), input_event_notifier(input_event_notifier)
Detector::Detector(InputGPIOInterface* input_gpio_interface, std::map<char, Event> events, EventNotifier* 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;
this->in_gpio_interface = NULL;
delete this->input_event_notifier;
this->input_event_notifier = NULL;
delete this->input_gpio_interface;
this->input_gpio_interface = NULL;
delete this->event_notifier;
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);
input_event_notifier->distribute_event(event);
Event& event = events.at(address);
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);
for(int col = 0; col < 8; col++)
if(input_gpio_interface->read_input_data(pin))
{
in_gpio_interface->write_input_col(col);
// 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;
}
address = pin;
return true;
}
}
return false;
}
}

14
FlippR-Driver/src/input/Detector.h
View File

@@ -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;

8
FlippR-Driver/src/input/Event.hpp
View File

@@ -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;
}

21
FlippR-Driver/src/input/EventHandler.hpp
View File

@@ -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) :
detector(detector)
EventHandler(std::shared_ptr<InputDriver> input_driver) :
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->detector = NULL;
this->input_driver->unregister_event_handler(this);
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;
};
}

18
FlippR-Driver/src/input/EventNotifier.cpp
View File

@@ -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);

18
FlippR-Driver/src/input/EventNotifier.h
View File

@@ -18,23 +18,25 @@
namespace Input
{
class InputEventNotifier
class EventNotifier
{
public:
InputEventNotifier();
~InputEventNotifier();
EventNotifier();
~EventNotifier();
void register_input_event_handler(InputEventHandler* handler);
void unregister_input_event_handler(InputEventHandler* handler);
void register_event_handler(EventHandler* 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;
std::set<InputEventHandler*> event_handler;
BlockingQueue<Event> event_queue;
std::set<EventHandler*> event_handler;
bool is_running;
std::thread notify_thread;

10
FlippR-Driver/src/input/InputDriver.hpp
View File

@@ -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_ */

16
FlippR-Driver/src/input/InputDriverFactory.hpp
View File

@@ -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);
}
};
}

6
FlippR-Driver/src/utilities/GPIOInterface.hpp
View File

@@ -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;
};

3
FlippR-Driver/src/utilities/InputGPIOInterface.cpp
View File

@@ -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);
}

8
FlippR-Driver/src/utilities/config.h Normal file
View File

@@ -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"