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

refactored outpugpiointerface

Browse Source
This commit is contained in:
Jonas Zeunert
2018-12-04 16:28:51 +01:00
parent 6b6b185f8e
commit a60fa8bee5
17 changed files with 97 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
FlippR-Driver/src/utility/DisplayGPIOInterface.cpp
View File

@@ -1,27 +0,0 @@
/*
* DisplayGPIOInterface.cpp
*
* Created on: Nov 9, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#include "DisplayGPIOInterface.h"
namespace flippR_driver
{
namespace utility
{
DisplayGPIOInterface::DisplayGPIOInterface()
{
// TODO Auto-generated constructor stub
}
DisplayGPIOInterface::~DisplayGPIOInterface()
{
// TODO Auto-generated destructor stub
}
}
}

27
FlippR-Driver/src/utility/DisplayGPIOInterface.h
View File

@@ -1,27 +0,0 @@
/*
* DisplayGPIOInterface.h
*
* Created on: Nov 9, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#ifndef SRC_UTILITY_DISPLAYGPIOINTERFACE_H_
#define SRC_UTILITY_DISPLAYGPIOINTERFACE_H_
namespace flippR_driver
{
namespace utility
{
class DisplayGPIOInterface
{
public:
DisplayGPIOInterface();
virtual
~DisplayGPIOInterface();
};
}
}
#endif /* SRC_UTILITY_DISPLAYGPIOINTERFACE_H_ */

49
FlippR-Driver/src/utility/GPIOInterface.cpp
View File

@@ -1,49 +0,0 @@
/*
* GPIOInterface.cpp
*
* Created on: Jun 15, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#include "GPIOInterface.h"
#include "config.h"
#include "wiringPi/wiringPi.h"
#include "json/json.hpp"
namespace flippR_driver
{
namespace utility
{
std::once_flag GPIOInterface::GPIO_LIB_INITIALIZED;
GPIOInterface::GPIOInterface()
{
std::call_once(GPIO_LIB_INITIALIZED, wiringPiSetup);
}
void GPIOInterface::initialize_input_pin(char address)
{
pinMode(address, INPUT);
}
void GPIOInterface::initialize_output_pin(char address)
{
pinMode(address, OUTPUT);
}
void GPIOInterface::write_pin(char address, char data)
{
digitalWrite(address, data);
}
bool GPIOInterface::read_pin(char address)
{
return PULLDOWN == digitalRead(address);
}
}
}

49
FlippR-Driver/src/utility/GPIOInterface.h
View File

@@ -1,49 +0,0 @@
/*
* GPIOInterface.hpp
*
* Responsible for communicating with the actual GPIO hardware.
*
* Gets a JSON file with following style:
* TODO
*
* Created on: May 6, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#ifndef SRC_UTILITIES_GPIOINTERFACE_H_
#define SRC_UTILITIES_GPIOINTERFACE_H_
#include <mutex>
#include <fstream>
namespace flippR_driver
{
namespace utility
{
class GPIOInterface
{
public:
GPIOInterface();
virtual ~GPIOInterface() {};
protected:
static void initialize_input_pin(char address);
static void initialize_output_pin(char address);
static void write_pin(char address, char data);
static bool read_pin(char address);
public:
static std::once_flag GPIO_LIB_INITIALIZED;
private:
unsigned int pin_base;
};
}
}
#endif

28
FlippR-Driver/src/utility/IInputGPIOInterface.h
View File

@@ -1,28 +0,0 @@
/*
* InputGPIOInterface.h
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#ifndef SRC_UTILITIES_IINPUTGPIOINTERFACE_H_
#define SRC_UTILITIES_IINPUTGPIOINTERFACE_H_
namespace flippR_driver
{
namespace utility
{
class IInputGPIOInterface
{
public:
virtual ~IInputGPIOInterface()
{};
virtual bool read_data(char pin) = 0;
};
}
}
#endif

38
FlippR-Driver/src/utility/IOutputGPIOInterface.h
View File

@@ -1,38 +0,0 @@
//
// Created by rhetenor on 10.10.18.
//
#ifndef flippR_driver_IOUTPUTGPIOINTERFACE_H
#define flippR_driver_IOUTPUTGPIOINTERFACE_H
#include "IOutputGPIOInterface.h"
#include "output/items/IDriverBoardItem.h"
#include "output/items/ISoundItem.h"
#include "output/items/IDisplay.h"
#include <memory>
namespace flippR_driver
{
namespace utility
{
class IOutputGPIOInterface
{
public:
virtual ~IOutputGPIOInterface(){};
virtual void activate(output::items::IDriverBoardItem *driver_board_item) = 0;
virtual void activate(output::items::ISoundItem *sound) = 0;
virtual void deactivate(output::items::IDriverBoardItem *driver_board_item) = 0;
virtual void deactivate(output::items::ISoundItem *sound) = 0;
virtual void write_display(std::shared_ptr<output::items::IDisplay> display) = 0;
//Display gpio interface!
};
}
}
#endif //flippR_driver_IOUTPUTGPIOINTERFACE_H

99
FlippR-Driver/src/utility/InputGPIOInterface.cpp
View File

@@ -1,99 +0,0 @@
/*
* InputGPIOInterface.cpp
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#include <fstream>
#include <thread>
#include "InputGPIOInterface.h"
#include "json/json.hpp"
#include "easylogging/easylogging++.h"
#include "config.h"
#include <string>
namespace flippR_driver
{
namespace utility
{
using namespace nlohmann;
InputGPIOInterface::InputGPIOInterface(std::istream &input_config)
{
init_members(input_config);
init_pins();
}
bool InputGPIOInterface::read_data(char pin)
{
// setting address to read
write_row(pin / INPUT_MATRIX_SIZE);
write_col(pin % INPUT_MATRIX_SIZE);
// wait for mux to set address
std::this_thread::sleep_for(std::chrono::nanoseconds(INPUT_SLEEP_DURATION_NANO));
return read_pin(this->data_address);
}
void InputGPIOInterface::write_row(char data)
{
write_pin(this->row_address_A, data & 0b001);
write_pin(this->row_address_B, data & 0b010);
write_pin(this->row_address_C, data & 0b100);
}
void InputGPIOInterface::write_col(char data)
{
write_pin(this->col_address_A, data & 0b001);
write_pin(this->col_address_B, data & 0b010);
write_pin(this->col_address_C, data & 0b100);
}
void InputGPIOInterface::init_members(std::istream &input_config_stream)
{
json input_config;
input_config_stream >> input_config;
try
{
json row_json = input_config.at("row");
row_address_A = row_json.at("A").get<json::number_integer_t>();
row_address_B = row_json.at("B").get<json::number_integer_t>();
row_address_C = row_json.at("C").get<json::number_integer_t>();
json col_json = input_config.at("col");
col_address_A = col_json.at("A").get<json::number_integer_t>();
col_address_B = col_json.at("B").get<json::number_integer_t>();
col_address_C = col_json.at("C").get<json::number_integer_t>();
data_address = input_config.at("data").get<json::number_integer_t>();
}
catch(json::type_error &e)
{
CLOG(ERROR, INPUT_LOGGER) << e.what();
}
catch(json::out_of_range &e)
{
CLOG(ERROR, INPUT_LOGGER) << e.what();
}
}
void InputGPIOInterface::init_pins()
{
initialize_output_pin(col_address_A);
initialize_output_pin(col_address_B);
initialize_output_pin(col_address_C);
initialize_output_pin(row_address_A);
initialize_output_pin(row_address_B);
initialize_output_pin(row_address_C);
initialize_input_pin(data_address);
}
}
}

44
FlippR-Driver/src/utility/InputGPIOInterface.h
View File

@@ -1,44 +0,0 @@
/*
* InputGPIOInterface.h
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#ifndef SRC_UTILITIES_INPUTGPIOINTERFACE_H_
#define SRC_UTILITIES_INPUTGPIOINTERFACE_H_
#include <exception>
#include "IInputGPIOInterface.h"
#include "GPIOInterface.h"
namespace flippR_driver
{
namespace utility
{
class InputGPIOInterface : public IInputGPIOInterface, GPIOInterface
{
public:
InputGPIOInterface(std::istream &input_config);
bool read_data(char pin);
private:
void init_members(std::istream &input_config_stream);
void init_pins();
void write_row(char data);
void write_col(char data);
private:
char row_address_A;
char row_address_B;
char row_address_C;
char col_address_A;
char col_address_B;
char col_address_C;
char data_address;
};
}
}
#endif

197
FlippR-Driver/src/utility/OutputGPIOInterface.cpp
View File

@@ -1,197 +0,0 @@
/*
* OutputGPIOInterface.h
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#include "OutputGPIOInterface.h"
namespace flippR_driver
{
namespace utility
{
using namespace output::items;
using namespace nlohmann;
OutputGPIOInterface::OutputGPIOInterface(std::istream &output_config_stream)
{
json output_config;
output_config_stream >> output_config;
parse_output_config(output_config);
initialize_i2c_addresses();
initialize_pins();
}
void OutputGPIOInterface::parse_output_config(json &output_config)
{
parse_pins_driver_board(output_config.at("driver_board"));
parse_pins_sound(output_config.at("sound_board"));
parse_pins_sound(output_config.at("display_board"));
}
void OutputGPIOInterface::parse_pins_driver_board(json &driver_board_config)
{
this->pins_driver_board["i2c_address"] = driver_board_config.at("i2c_address").get<uint8_t>();
this->pins_driver_board["pin_base"] = driver_board_config.at("pin_base").get<uint8_t>();
this->pins_driver_board["data"] = driver_board_config.at("data").get<uint8_t>();
this->pins_driver_board["CL"] = driver_board_config.at("CL").get<uint8_t>();
json pin_select = driver_board_config.at("pin-select");
this->pins_driver_board["pin-select-A"] = pin_select.at("A").get<uint8_t>();
this->pins_driver_board["pin-select-B"] = pin_select.at("B").get<uint8_t>();
this->pins_driver_board["pin-select-C"] = pin_select.at("C").get<uint8_t>();
json latch_select = driver_board_config.at("latch-select");
this->pins_driver_board["mux1"] = latch_select.at("mux1").get<uint8_t>();
this->pins_driver_board["mux2"] = latch_select.at("mux2").get<uint8_t>();
this->pins_driver_board["latch-select-A"] = latch_select.at("A").get<uint8_t>();
this->pins_driver_board["latch-select-B"] = latch_select.at("B").get<uint8_t>();
this->pins_driver_board["latch-select-C"] = latch_select.at("C").get<uint8_t>();
}
void OutputGPIOInterface::parse_pins_sound(json &sound_board_config)
{
this->pins_sound["i2c_address"] = sound_board_config.at("i2c_address").get<uint8_t>();
this->pins_sound["pin_base"] = sound_board_config.at("pin_base").get<uint8_t>();
this->pins_sound["fire"] = sound_board_config.at("fire").get<uint8_t>();
json sound_address = sound_board_config.at("sound_address");
this->pins_sound["A"] = sound_address.at("A").get<uint8_t>();
this->pins_sound["B"] = sound_address.at("B").get<uint8_t>();
this->pins_sound["C"] = sound_address.at("C").get<uint8_t>();
this->pins_sound["D"] = sound_address.at("D").get<uint8_t>();
this->pins_sound["E"] = sound_address.at("E").get<uint8_t>();
this->pins_sound["F"] = sound_address.at("F").get<uint8_t>();
this->pins_sound["G"] = sound_address.at("G").get<uint8_t>();
}
void OutputGPIOInterface::parse_pins_display(json &display_board_config)
{
}
void OutputGPIOInterface::initialize_pins()
{
// Since this are all outputs we just initialize everything as output conveniently
initialize_all_pins(pins_driver_board["pin_base"]);
initialize_all_pins(pins_sound["pin_base"]);
initialize_all_pins(pins_display["pin_base"]);
}
void OutputGPIOInterface::initialize_all_pins(uint8_t pin_base)
{
for(int i = 0; i < 16; i++)
{
GPIOInterface::initialize_output_pin(pin_base + i);
}
}
void OutputGPIOInterface::initialize_i2c_addresses()
{
mcp23017Setup(pins_driver_board["pin_base"], pins_driver_board["i2c_address"]);
mcp23017Setup(pins_sound["pin_base"], pins_sound["i2c_address"]);
mcp23017Setup(pins_display["pin_base"], pins_display["i2c_address"]);
}
void OutputGPIOInterface::activate(output::items::ISoundItem *sound)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
write_sound_address(sound->get_address());
fire_sound(1);
}
void OutputGPIOInterface::activate(output::items::IDriverBoardItem *driver_board_item)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
write_driver_board_address(driver_board_item->get_address());
write_data(1);
}
void OutputGPIOInterface::deactivate(output::items::IDriverBoardItem *driver_board_item)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
write_driver_board_address(driver_board_item->get_address());
write_data(0);
}
void OutputGPIOInterface::deactivate(output::items::ISoundItem *sound)
{
std::lock_guard<std::mutex> guard(output_item_mutex);
write_sound_address(sound->get_address());
fire_sound(0);
}
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["mux1"], mux1);
write_pin(pins_driver_board["mux2"], !mux1);
}
void OutputGPIOInterface::select_latch(uint8_t latch)
{
// todo not nice
if(latch > 8)
latch -= 8;
write_pin(pins_driver_board["latch-select-A"], latch & 0b001);
write_pin(pins_driver_board["latch-select-B"], latch & 0b010);
write_pin(pins_driver_board["latch-select-C"], latch & 0b100);
}
void OutputGPIOInterface::write_data(bool data)
{
write_pin(pins_driver_board["data"], data);
}
void OutputGPIOInterface::select_pin(uint8_t pin)
{
write_pin(pins_driver_board["pin-select-A"], pin & 0b001);
write_pin(pins_driver_board["pin-select-B"], pin & 0b010);
write_pin(pins_driver_board["pin-select-C"], pin & 0b100);
}
void OutputGPIOInterface::write_sound_address(uint8_t address)
{
write_pin(pins_sound["A"], address & 0b0000001);
write_pin(pins_sound["B"], address & 0b0000010);
write_pin(pins_sound["C"], address & 0b0000100);
write_pin(pins_sound["D"], address & 0b0001000);
write_pin(pins_sound["E"], address & 0b0010000);
write_pin(pins_sound["F"], address & 0b0100000);
write_pin(pins_sound["G"], address & 0b1000000);
}
void OutputGPIOInterface::fire_sound(bool fire)
{
GPIOInterface::write_pin(pins_sound["fire"], fire);
}
}
}

73
FlippR-Driver/src/utility/OutputGPIOInterface.h
View File

@@ -1,73 +0,0 @@
/*
* OutputGPIOInterface.h
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#ifndef SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
#define SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
#include "IOutputGPIOInterface.h"
#include "GPIOInterface.h"
#include "output/items/IItem.h"
#include "json/json.hpp"
#include <mcp23017.h>
#include <mutex>
#include <map>
namespace flippR_driver
{
namespace utility
{
class OutputGPIOInterface : public GPIOInterface, IOutputGPIOInterface
{
public:
OutputGPIOInterface(std::istream &output_config_stream);
virtual ~OutputGPIOInterface() = default;
virtual void activate(output::items::IDriverBoardItem *driver_board_item);
virtual void activate(output::items::ISoundItem *sound);
virtual void deactivate(output::items::IDriverBoardItem *driver_board_item);
virtual void deactivate(output::items::ISoundItem *sound);
virtual void write_display(output::items::IDisplay *display);
private:
void parse_output_config(nlohmann::json &output_config);
void parse_pins_driver_board(nlohmann::json &driver_board_config);
void parse_pins_sound(nlohmann::json &sound_board_config);
void parse_pins_display(nlohmann::json &display_board_config);
void initialize_i2c_addresses();
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;
std::map<std::string, uint8_t> pins_driver_board;// {{"i2c_address", 0}, {"pin_base", 0}, {"data", 0}, {"CL", 0}, {"latch-select-A", "0"}, {"latch-select-B", "0"}, {"latch-select-C", 0}, {"mux1", 0}, {"mux2", 0}, {"pin-select-A", 0}, {"pin-select-B", 0}, {"pin-select-C", 0}};
std::map<std::string, uint8_t> pins_sound;// {{"i2c_address", 0}, {"pin_base", 0}, {"fire", 0}, {"A", 0}, {"B", "0"}, {"C", "0"}, {"D", 0}, {"E", 0}, {"F", 0}, {"G", 0}};
std::map<std::string, uint8_t> pins_display;// {{"i2c_address", 0}, {"pin_base", 0}, {"fire", 0}, {"A", 0}, {"B", "0"}, {"C", "0"}, {"D", 0}, {"E", 0}, {"F", 0}, {"G", 0}};
};
}
}
#endif