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

implementing displays and refactor fail

Browse Source
This commit is contained in:
Jonas Zeunert
2018-12-14 14:20:11 +01:00
parent f9edf2f8cc
commit 49cd625808
20 changed files with 100 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
FlippR-Driver/contrib/json_example/output/Display_Config.json Normal file
View File

@@ -0,0 +1,10 @@
{
"displays" :
[
{
"digits" : 8,
"id" : 1,
"address" : 1
}
]
}

2
FlippR-Driver/include/output/OutputDriver.h
View File

@@ -10,7 +10,7 @@
#include "output/items/impl/Lamp.h" #include "output/items/impl/Lamp.h"
#include "output/items/Solenoid.h" #include "output/items/Solenoid.h"
#include "output/items/Display.h" #include "output/items/OutputDisplay.h"
#include "output/items/Sound.h" #include "output/items/Sound.h"
#include <vector> #include <vector>

5
FlippR-Driver/include/output/items/OutputDisplay.h → FlippR-Driver/include/output/items/Display.h
View File

@@ -15,12 +15,11 @@ namespace output
namespace items namespace items
{ {
class IOutputDisplay class Display
{ {
public: public:
virtual ~IOutputDisplay() virtual ~IOutputDisplay() = default;
{};
virtual void write_score(int score) = 0; virtual void write_score(int score) = 0;
}; };

4
FlippR-Driver/include/output/items/EightDigitDisplay.h
View File

@@ -5,7 +5,7 @@
#ifndef FLIPPR_DRIVER_IEIGHTDIGITDISPLAY_H #ifndef FLIPPR_DRIVER_IEIGHTDIGITDISPLAY_H
#define FLIPPR_DRIVER_IEIGHTDIGITDISPLAY_H #define FLIPPR_DRIVER_IEIGHTDIGITDISPLAY_H
#include "OutputDisplay.h" #include "Display.h"
#include <array> #include <array>
@@ -16,7 +16,7 @@ namespace output
namespace items namespace items
{ {
class IEightDigitDisplay : public IOutputDisplay class EightDigitDisplay : public Display
{ {
public: public:
virtual void write_content(std::array<char, 8> content) = 0; virtual void write_content(std::array<char, 8> content) = 0;

4
FlippR-Driver/include/output/items/SevenDigitDisplay.h
View File

@@ -5,7 +5,7 @@
#ifndef FLIPPR_DRIVER_ISEVENDIGITDISPLAY_H #ifndef FLIPPR_DRIVER_ISEVENDIGITDISPLAY_H
#define FLIPPR_DRIVER_ISEVENDIGITDISPLAY_H #define FLIPPR_DRIVER_ISEVENDIGITDISPLAY_H
#include "OutputDisplay.h" #include "Display.h"
#include <array> #include <array>
@@ -16,7 +16,7 @@ namespace output
namespace items namespace items
{ {
class ISevenDigitDisplay : public IOutputDisplay class SevenDigitDisplay : public Display
{ {
public: public:
virtual void write_content(std::array<char, 7> content) = 0; virtual void write_content(std::array<char, 7> content) = 0;

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

@@ -20,7 +20,7 @@ class InputPinController
public: public:
virtual ~InputPinController() = default; virtual ~InputPinController() = default;
virtual bool read_data(uint8_tpin) const = 0; virtual bool read_data(uint8_t pin) const = 0;
}; };
} }

6
FlippR-Driver/src/input/impl/InputPinController.cpp
View File

@@ -28,7 +28,7 @@ InputPinController::InputPinController(std::map<std::string, uint8_t> pins)
init_pins(); init_pins();
} }
bool InputPinController::read_data(uint8_tpin) const bool InputPinController::read_data(uint8_t pin) const
{ {
// setting address to read // setting address to read
write_row(pin / INPUT_MATRIX_SIZE); write_row(pin / INPUT_MATRIX_SIZE);
@@ -40,14 +40,14 @@ bool InputPinController::read_data(uint8_tpin) const
return read_pin(this->pins.at("data_address")); return read_pin(this->pins.at("data_address"));
} }
void InputPinController::write_row(uint8_tdata) const void InputPinController::write_row(uint8_t data) const
{ {
write_pin(this->pins.at("row_address_A"), data & 0b001u); 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_B"), data & 0b010u);
write_pin(this->pins.at("row_address_C"), data & 0b100u); write_pin(this->pins.at("row_address_C"), data & 0b100u);
} }
void InputPinController::write_col(uint8_tdata) 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_A"), data & 0b001u);
write_pin(this->pins.at("col_address_B"), data & 0b010u); write_pin(this->pins.at("col_address_B"), data & 0b010u);

6
FlippR-Driver/src/input/impl/InputPinController.h
View File

@@ -26,12 +26,12 @@ class InputPinController : public input::InputPinController, public PinControlle
{ {
public: public:
explicit InputPinController(std::map<std::string, uint8_t> pins); explicit InputPinController(std::map<std::string, uint8_t> pins);
bool read_data(uint8_tpin) const override; bool read_data(uint8_t pin) const override;
private: private:
void init_pins() const; void init_pins() const;
void write_row(uint8_tdata) const; void write_row(uint8_t data) const;
void write_col(uint8_tdata) const; void write_col(uint8_t data) const;
private: private:
const std::map<std::string, uint8_t> pins; const std::map<std::string, uint8_t> pins;

2
FlippR-Driver/src/output/DisplayBoardPinController.h
View File

@@ -5,7 +5,7 @@
#ifndef FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H #ifndef FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H
#define FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H #define FLIPPR_DRIVER_DISPLAYPINCONTROLLER_H
#include "output/items/Display.h" #include "output/items/OutputDisplay.h"
namespace flippR_driver namespace flippR_driver
{ {

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

@@ -135,11 +135,12 @@ std::map<std::string, std::shared_ptr<items::Solenoid>> create_solenoids(std::is
{ {
std::map<std::string, std::shared_ptr<items::Solenoid>> solenoids; std::map<std::string, std::shared_ptr<items::Solenoid>> solenoids;
json solenoids_json; json solenoid_config_json;
solenoid_config >> solenoids_json; solenoid_config >> solenoid_config_json;
auto deactivation_time = get_deactivation_time(solenoids_json); auto deactivation_time = get_deactivation_time(solenoid_config_json);
json solenoids_json = solenoid_config_json.at("solenoids");
for(auto &solenoid_json : solenoids_json) for(auto &solenoid_json : solenoids_json)
{ {
auto solenoid = create_solenoid(solenoid_json, output_gpio_interface, deactivation_time); auto solenoid = create_solenoid(solenoid_json, output_gpio_interface, deactivation_time);
@@ -153,9 +154,10 @@ std::map<std::string, std::shared_ptr<items::Lamp>> create_lamps(std::istream &l
{ {
std::map<std::string, std::shared_ptr<items::Lamp>> lamps; std::map<std::string, std::shared_ptr<items::Lamp>> lamps;
json lamps_json; json lamp_config_json;
lamp_config >> lamps_json; lamp_config >> lamp_config_json;
json lamps_json = lamp_config_json.at("lamps");
for(auto &lamp_json : lamps_json) for(auto &lamp_json : lamps_json)
{ {
auto lamp = create_lamp(lamp_json, output_gpio_interface); auto lamp = create_lamp(lamp_json, output_gpio_interface);
@@ -169,11 +171,12 @@ std::map<std::string, std::shared_ptr<items::Sound>> create_sounds(std::istream
{ {
std::map<std::string, std::shared_ptr<items::Sound>> sounds; std::map<std::string, std::shared_ptr<items::Sound>> sounds;
json sounds_json; json sounds_config_json;
sound_config >> sounds_json; sound_config >> sounds_config_json;
auto deactivation_time = get_deactivation_time(sounds_json); auto deactivation_time = get_deactivation_time(sounds_config_json);
json sounds_json = sounds_config_json.at("sounds"); // todo catch
for(auto &sound_json : sounds_json) for(auto &sound_json : sounds_json)
{ {
auto sound = create_sound(sound_json, output_gpio_interface, deactivation_time); auto sound = create_sound(sound_json, output_gpio_interface, deactivation_time);
@@ -190,7 +193,7 @@ std::chrono::milliseconds get_deactivation_time(nlohmann::json &json)
auto deactivation_time = json.at("deactivation_time_milliseconds").get<uint>(); auto deactivation_time = json.at("deactivation_time_milliseconds").get<uint>();
return std::chrono::milliseconds(deactivation_time); return std::chrono::milliseconds(deactivation_time);
} }
catch(json::type_error &e) catch(json::exception &e)
{ {
// todo log and exit // todo log and exit
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@@ -211,7 +214,7 @@ std::shared_ptr<items::impl::Solenoid> create_solenoid(nlohmann::json &solenoid_
return std::make_shared<items::impl::Solenoid>(pin_controller, address, name, deactivation_time); return std::make_shared<items::impl::Solenoid>(pin_controller, address, name, deactivation_time);
} }
catch(json::type_error &e) catch(json::exception &e)
{ {
// todo log and exit // todo log and exit
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@@ -226,7 +229,7 @@ std::shared_ptr<items::impl::Lamp> create_lamp(nlohmann::json &lamp_json, std::s
auto address = lamp_json.at("address").get<uint8_t>(); auto address = lamp_json.at("address").get<uint8_t>();
return std::make_shared<items::impl::Lamp>(pin_controller, address, name); return std::make_shared<items::impl::Lamp>(pin_controller, address, name);
} }
catch(json::type_error &e) catch(json::exception &e)
{ {
// todo log and exit // todo log and exit
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@@ -242,7 +245,7 @@ std::shared_ptr<items::impl::Sound> create_sound(nlohmann::json &sound_json, std
auto address = sound_json.at("address").get<uint8_t>(); auto address = sound_json.at("address").get<uint8_t>();
return std::make_shared<items::impl::Sound>(pin_controller, address, description, deactivation_time, id); return std::make_shared<items::impl::Sound>(pin_controller, address, description, deactivation_time, id);
} }
catch(json::type_error &e) catch(json::exception &e)
{ {
// todo log and exit // todo log and exit
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@@ -253,9 +256,39 @@ std::map<uint8_t, std::shared_ptr<items::Display>> create_displays(std::istream
{ {
std::map<uint8_t, std::shared_ptr<items::Display>> displays; std::map<uint8_t, std::shared_ptr<items::Display>> displays;
json display_config_json;
display_config >> display_config_json;
json displays_json = display_config_json.at('displays');
for(json &display_json : displays_json)
{
auto display = create_display(display_json);
}
return displays; return displays;
} }
std::shared_ptr<items::Display> create_display(nlohmann::json &display_json)
{
try
{
auto id = display_json.at("id").get<uint8_t>();
auto address = display_json.at("address").get<uint8_t>();
auto digits = display_json.at("digits").get<uint8_t>();
if(digits == 8)
{
return std::make_shared<items::impl::EightDigitDisplay>(address, id);
}
}
catch(json::exception &e)
{
exit(EXIT_FAILURE);
}
return std::shared_ptr<items::Display>();
}
} }
} }
} }

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

@@ -37,6 +37,7 @@ namespace OutputDriverFactory
std::chrono::milliseconds get_deactivation_time(nlohmann::json &json); std::chrono::milliseconds get_deactivation_time(nlohmann::json &json);
std::map<uint8_t, std::shared_ptr<items::Display>> create_displays(std::istream &display_config); std::map<uint8_t, std::shared_ptr<items::Display>> create_displays(std::istream &display_config);
std::shared_ptr<items::Display> create_display(nlohmann::json &display_json);
std::map<std::string, uint8_t> parse_pins_driver_board(nlohmann::json &driver_board_config); std::map<std::string, uint8_t> parse_pins_driver_board(nlohmann::json &driver_board_config);
std::map<std::string, uint8_t> parse_pins_sound_board(nlohmann::json &sound_board_config); std::map<std::string, uint8_t> parse_pins_sound_board(nlohmann::json &sound_board_config);

4
FlippR-Driver/src/output/OutputPinController.cpp
View File

@@ -16,12 +16,12 @@ namespace flippR_driver
namespace output namespace output
{ {
void OutputPinController::initialize_i2c_address(uint8_ti2c_address, uint8_tpin_base) void OutputPinController::initialize_i2c_address(uint8_t i2c_address, uint8_t pin_base)
{ {
mcp23017Setup(pin_base, i2c_address); mcp23017Setup(pin_base, i2c_address);
} }
void OutputPinController::initialize_pins_output(uint8_tpin_base) void OutputPinController::initialize_pins_output(uint8_t pin_base)
{ {
// Since this are all outputs we just initialize everything as output conveniently // Since this are all outputs we just initialize everything as output conveniently
for(int i = 0; i < 16; i++) for(int i = 0; i < 16; i++)

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

@@ -22,8 +22,8 @@ public:
virtual ~OutputPinController() = default; virtual ~OutputPinController() = default;
protected: protected:
static void initialize_i2c_address(uint8_ti2c_address, uint8_tpin_base); static void initialize_i2c_address(uint8_t i2c_address, uint8_t pin_base);
static void initialize_pins_output(uint8_tpin_base); static void initialize_pins_output(uint8_t pin_base);
}; };
} }

8
FlippR-Driver/src/output/impl/DisplayBoardPinController.cpp
View File

@@ -41,7 +41,7 @@ void DisplayBoardPinController::write_display(const items::Display &display) con
} }
void DisplayBoardPinController::write_display_digit(uint8_t display_address, uint8_tcontent, uint8_tposition) void DisplayBoardPinController::write_display_digit(uint8_t display_address, uint8_t content, uint8_t position)
{ {
select_display_segment(position); select_display_segment(position);
@@ -52,14 +52,14 @@ void DisplayBoardPinController::write_display_digit(uint8_t display_address, uin
std::this_thread::sleep_for(std::chrono::milliseconds(DISPLAY_SLEEP_TIME_MILLI)); std::this_thread::sleep_for(std::chrono::milliseconds(DISPLAY_SLEEP_TIME_MILLI));
} }
void DisplayBoardPinController::select_display_segment(uint8_tsegment) void DisplayBoardPinController::select_display_segment(uint8_t segment)
{ {
write_pin(pins_display_board.at("segment_select_A"), segment & ~0b001u); write_pin(pins_display_board.at("segment_select_A"), segment & ~0b001u);
write_pin(pins_display_board.at("segment_select_B"), segment & ~0b010u); write_pin(pins_display_board.at("segment_select_B"), segment & ~0b010u);
write_pin(pins_display_board.at("segment_select_C"), segment & ~0b100u); write_pin(pins_display_board.at("segment_select_C"), segment & ~0b100u);
} }
void DisplayBoardPinController::select_display_digit(uint8_tcontent) void DisplayBoardPinController::select_display_digit(uint8_t content)
{ {
write_pin(pins_display_board.at("digit_select_A"), content & 0b0001u); write_pin(pins_display_board.at("digit_select_A"), content & 0b0001u);
write_pin(pins_display_board.at("digit_select_B"), content & 0b0010u); write_pin(pins_display_board.at("digit_select_B"), content & 0b0010u);
@@ -67,7 +67,7 @@ void DisplayBoardPinController::select_display_digit(uint8_tcontent)
write_pin(pins_display_board.at("digit_select_D"), content & 0b1000u); write_pin(pins_display_board.at("digit_select_D"), content & 0b1000u);
} }
void DisplayBoardPinController::run_display(uint8_taddress) void DisplayBoardPinController::run_display(uint8_t address)
{ {
write_pin(pins_display_board.at("display_select_" + std::to_string(address)), 0); write_pin(pins_display_board.at("display_select_" + std::to_string(address)), 0);

8
FlippR-Driver/src/output/impl/DisplayBoardPinController.h
View File

@@ -30,10 +30,10 @@ public:
void write_display(const items::Display &display) const override; void write_display(const items::Display &display) const override;
private: private:
void write_display_digit(uint8_t display_address, uint8_tcontent, uint8_tposition); void write_display_digit(uint8_t display_address, uint8_t content, uint8_t position);
void select_display_segment(uint8_tdigit); void select_display_segment(uint8_t digit);
void select_display_digit(uint8_tcontent); void select_display_digit(uint8_t content);
void run_display(uint8_taddress); void run_display(uint8_t address);
private: private:
const std::map<std::string, uint8_t> pins_display_board; const std::map<std::string, uint8_t> pins_display_board;

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

@@ -13,7 +13,7 @@
#include <vector> #include <vector>
#include <thread> #include <thread>
#include "output/items/Display.h" #include "output/items/OutputDisplay.h"
#include "output/DisplayBoardPinController.h" #include "output/DisplayBoardPinController.h"
namespace flippR_driver namespace flippR_driver

0
FlippR-Driver/src/output/items/Display.h → FlippR-Driver/src/output/items/OutputDisplay.h
View File

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

@@ -8,7 +8,7 @@
#ifndef _SRC_OUTPUT_DISPLAY_H_ #ifndef _SRC_OUTPUT_DISPLAY_H_
#define _SRC_OUTPUT_DISPLAY_H_ #define _SRC_OUTPUT_DISPLAY_H_
#include "output/items/Display.h" #include "output/items/OutputDisplay.h"
#include <array> #include <array>
@@ -25,7 +25,7 @@ template<int DigitCount>
class Display : public items::Display class Display : public items::Display
{ {
public: public:
Display(int address, int id); Display(uint8_t address, uint8_t id);
virtual ~Display() = default; virtual ~Display() = default;
virtual void write_score(int score); virtual void write_score(int score);
@@ -38,7 +38,8 @@ public:
std::array<uint8_t, DigitCount> content; std::array<uint8_t, DigitCount> content;
private: private:
int address; const uint8_t id;
const uint8_t address;
std::string fit_string(std::string &score_string); std::string fit_string(std::string &score_string);
}; };

2
FlippR-Driver/src/output/items/impl/Display.hpp
View File

@@ -17,7 +17,7 @@ namespace impl
{ {
template<int DigitCount> template<int DigitCount>
Display<DigitCount>::Display(int address, int id) : Display<DigitCount>::Display(uint8_t address, uint8_t id) :
address(address), address(address),
id(id) id(id)
{ {

14
FlippR-Driver/src/output/items/impl/EightDigitDisplay.h
View File

@@ -2,8 +2,8 @@
// Created by rhetenor on 20.11.18. // Created by rhetenor on 20.11.18.
// //
#ifndef FLIPPR_DRIVER_EIGHTDIGITDISPLAY_H #ifndef FLIPPR_DRIVER_OUTPUT_ITEMS_IMPL_EIGHTDIGITDISPLAY_H
#define FLIPPR_DRIVER_EIGHTDIGITDISPLAY_H #define FLIPPR_DRIVER_OUTPUT_ITEMS_IMPL_EIGHTDIGITDISPLAY_H
#include "output/items/EightDigitDisplay.h" #include "output/items/EightDigitDisplay.h"
@@ -16,7 +16,15 @@ namespace items
namespace impl namespace impl
{ {
class EightDigitDisplay : public Display<8>, IEightDigitDisplay; class EightDigitDisplay : public Display<8>, public EightDigitDisplay
{
public:
EightDigitDisplay(uint8_t address, uint8_t id) :
Display<8>(address, id) {}
~EightDigitDisplay() override = default;
};
} }
} }