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

still the biggest refactor

Browse Source
This commit is contained in:
Jonas Zeunert
2018-12-14 02:44:53 +01:00
parent 67edde9078
commit 8e12b3f3fa
23 changed files with 137 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
FlippR-Driver/src/output/DriverBoardPinController.h
View File

@@ -5,13 +5,17 @@
#ifndef FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_DRIVERBOARDPINCONTROLLER_H
#include <output/items/DriverBoardItem.h>
namespace flippR_driver
{
namespace output
{
namespace items
{
class DriverBoardItem;
}
class DriverBoardPinController
{
public:

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

@@ -2,15 +2,18 @@
// Created by rhetenor on 04.10.18.
//
#include <boost/range/algorithm/copy.hpp>
#include <boost/range/adaptor/map.hpp>
#include "OutputDriverFactory.h"
#include "utility/LoggerFactory.h"
#include "output/impl/OutputDriver.h"
#include "output/impl/OutputPinController.h"
#include "output/impl/DisplayController.h"
#include "output/impl/DisplayBoardPinController.h"
#include "output/impl/DriverBoardPinController.h"
#include "output/impl/SoundBoardPinController.h"
#include "DisplayBoardPinController.h"
namespace flippR_driver
{
@@ -28,37 +31,30 @@ std::shared_ptr<OutputDriver> get_OutputDriver(std::istream &output_pin_config,
{
utility::LoggerFactory::CreateOutputLogger();
std::shared_ptr<std::mutex> output_pin_mutex();
std::shared_ptr<std::mutex> output_pin_mutex;
json output_config;
output_pin_config >> output_config;
json driver_board_config = output_config.at("driver_board");
std::shared_ptr<DriverBoardPinController> driver_board_pin_controller(new impl::DriverBoardPinController(parse_pins_driver_board(driver_board_config), output_pin_mutex));
auto solenoids = create_solenoids(solenoid_config, driver_board_pin_controller);
auto lamps = create_lamps(lamp_config, driver_board_pin_controller);
json sound_board_config = output_config.at("sound_board");
std::shared_ptr<SoundBoardPinController> sound_board_pin_controller(new impl::SoundBoardPinController(parse_pins_sound_board(sound_board_config), output_pin_mutex));
auto sounds = create_sounds(sound_config, sound_board_pin_controller);
json display_board_config = output_config.at("display_board");
std::shared_ptr<DisplayBoardPinController> display_board_pin_controller(new impl::DisplayBoardPinController(parse_pins_display_board(display_board_config)));
std::unique_ptr<DisplayBoardPinController> display_board_pin_controller(new impl::DisplayBoardPinController(parse_pins_display_board(display_board_config)));
auto displays = create_displays(display_config);
auto solenoids = create_solenoids(solenoid_config, output_gpio_interface);
auto lamps = create_lamps(lamp_config, output_gpio_interface);
auto sounds = create_sounds(sound_config, output_gpio_interface);
// todo
std::vector<std::shared_ptr<items::IDisplay>> displays_vec;
boost::copy(displays | boost::adaptors::map_values, std::back_inserter(displays_vec));
std::unique_ptr<DisplayController> display_controller(new impl::DisplayController(displays_vec, std::move(display_board_pin_controller)));
auto displays = create_displays(display_config, output_gpio_interface);
return std::make_shared<OutputDriver>(solenoids, lamps, sounds, displays);
}
OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_config)
{
json output_config;
output_pin_config >> output_config;
return new OutputGPIOInterface(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")));
return std::make_shared<OutputDriver>(display_controller, solenoids, lamps, sounds, displays);
}
std::map<std::string, uint8_t> parse_pins_driver_board(json &driver_board_config)
@@ -124,12 +120,15 @@ std::map<std::string, uint8_t> parse_pins_display(json &display_board_config)
try
{
pins_display["run"] = display_board_config.at("run");
//todo
}
catch(json::exception &e)
{
CLOG(ERROR, OUTPUT_LOGGER) << "Output pin config file at display_board corrupted: " << e.what();
exit(EXIT_FAILURE);
}
return pins_display;
}
std::map<std::string, std::shared_ptr<items::ISolenoid>> create_solenoids(std::istream &solenoid_config, std::shared_ptr<OutputPinController> output_gpio_interface)
@@ -197,7 +196,7 @@ std::chrono::milliseconds get_deactivation_time(nlohmann::json &json)
}
}
std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<OutputPinController> output_gpio_interface, std::chrono::milliseconds deactivation_time)
std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<DriverBoardPinController> &pin_controller, std::chrono::milliseconds deactivation_time)
{
try
{
@@ -209,7 +208,7 @@ std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json,
deactivation_time = get_deactivation_time(solenoid_json);
}
return std::make_shared<items::Solenoid>(output_gpio_interface, address, name, deactivation_time);
return std::make_shared<items::Solenoid>(pin_controller, address, name, deactivation_time);
}
catch(json::type_error &e)
{
@@ -218,13 +217,13 @@ std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json,
}
}
std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<OutputPinController> output_gpio_interface)
std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<DriverBoardPinController> &pin_controller)
{
try
{
std::string name = lamp_json.at("name");
auto address = lamp_json.at("address").get<uint8_t>();
return std::make_shared<items::Lamp>(output_gpio_interface, address, name);
return std::make_shared<items::Lamp>(pin_controller, address, name);
}
catch(json::type_error &e)
{
@@ -233,14 +232,14 @@ std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_
}
}
std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<OutputPinController> &output_gpio_interface, std::chrono::milliseconds deactivation_time)
std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<SoundBoardPinController> &pin_controller, std::chrono::milliseconds deactivation_time)
{
try
{
auto id = sound_json.at("id").get<uint>();
std::string description = sound_json.at("description");
auto address = sound_json.at("address").get<uint8_t>();
return std::make_shared<items::Sound>(output_gpio_interface, address, description, deactivation_time, id);
return std::make_shared<items::Sound>(pin_controller, address, description, deactivation_time, id);
}
catch(json::type_error &e)
{

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

@@ -9,7 +9,7 @@
#include "output/items/Solenoid.h"
#include "output/items/Lamp.h"
#include "output/items/Sound.h"
#include "OutputPinController.h"
#include "output/DisplayBoardPinController.h"
#include "json/json.hpp"
@@ -25,20 +25,19 @@ namespace OutputDriverFactory
namespace
{
std::map<std::string, std::shared_ptr<items::ISolenoid>> create_solenoids(std::istream &solenoid_config, std::shared_ptr<OutputPinController> output_gpio_interface);
std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<OutputPinController> output_gpio_interface, std::chrono::milliseconds deactivation_time);
std::map<std::string, std::shared_ptr<items::ISolenoid>> create_solenoids(std::istream &solenoid_config, std::shared_ptr<DriverBoardPinController> &pin_controller);
std::shared_ptr<items::Solenoid> create_solenoid(nlohmann::json &solenoid_json, std::shared_ptr<DriverBoardPinController> pin_controller, std::chrono::milliseconds deactivation_time);
std::map<std::string, std::shared_ptr<items::ILamp>> create_lamps(std::istream &lamp_config, std::shared_ptr<OutputPinController> output_gpio_interface);
std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<OutputPinController> output_gpio_interface);
std::map<std::string, std::shared_ptr<items::ILamp>> create_lamps(std::istream &lamp_config, std::shared_ptr<DriverBoardPinController> &pin_controller);
std::shared_ptr<items::Lamp> create_lamp(nlohmann::json &lamp_json, std::shared_ptr<DriverBoardPinController> pin_controller);
std::map<std::string, std::shared_ptr<items::ISound>> create_sounds(std::istream &sound_config, std::shared_ptr<OutputPinController> output_gpio_interface);
std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<OutputPinController> output_gpio_interface, std::chrono::milliseconds deactivation_time);
std::map<std::string, std::shared_ptr<items::ISound>> create_sounds(std::istream &sound_config, std::shared_ptr<SoundBoardPinController> &pin_controller);
std::shared_ptr<items::Sound> create_sound(nlohmann::json &sound_json, std::shared_ptr<SoundBoardPinController> pin_controller, std::chrono::milliseconds deactivation_time);
std::chrono::milliseconds get_deactivation_time(nlohmann::json &json);
std::map<char, std::shared_ptr<items::IDisplay>> create_displays(std::istream &display_config, std::shared_ptr<OutputPinController> output_gpio_interface);
std::map<char, std::shared_ptr<items::IDisplay>> create_displays(std::istream &display_config);
OutputPinController* create_OutputGPIOInterface(std::istream &output_pin_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_display_board(nlohmann::json &display_board_config);

34
FlippR-Driver/src/output/OutputPinController.cpp Normal file
View File

@@ -0,0 +1,34 @@
/*
* OutputGPIOInterface.h
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#include "OutputPinController.h"
#include "utility/config.h"
#include <mcp23017.h>
namespace flippR_driver
{
namespace output
{
void OutputPinController::initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base)
{
mcp23017Setup(pin_base, i2c_address);
}
void OutputPinController::initialize_pins_output(const uint8_t &pin_base)
{
// Since this are all outputs we just initialize everything as output conveniently
for(int i = 0; i < 16; i++)
{
PinController::initialize_output_pin(pin_base + i);
}
}
}
}

14
FlippR-Driver/src/output/impl/OutputPinController.h → FlippR-Driver/src/output/OutputPinController.h
View File

@@ -8,34 +8,24 @@
#ifndef SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
#define SRC_UTILITIES_OUTPUTGPIOINTERFACE_H_
#include "output/OutputPinController.h"
#include "PinController.h"
#include <mcp23017.h>
#include <mutex>
#include <map>
namespace flippR_driver
{
namespace output
{
namespace impl
{
class OutputGPIOInterface : public PinController
class OutputPinController : public PinController
{
public:
OutputGPIOInterface();
~OutputGPIOInterface() override = default;
virtual ~OutputPinController() = default;
protected:
static void initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base);
static void initialize_pins_output(const uint8_t &pin_base);
};
}
}
}

10
FlippR-Driver/src/output/SoundBoardPinController.h
View File

@@ -2,16 +2,20 @@
// Created by rhetenor on 14.12.18.
//
#ifndef FLIPPR_DRIVER_SOUNDPINCONTROLLER_H
#define FLIPPR_DRIVER_SOUNDPINCONTROLLER_H
#ifndef FLIPPR_DRIVER_OUTPUT_SOUNDBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_OUTPUT_SOUNDBOARDPINCONTROLLER_H
#include <output/items/Sound.h>
#include "output/items/Sound.h"
namespace flippR_driver
{
namespace output
{
namespace items
{
class Sound;
}
class SoundBoardPinController
{
public:

4
FlippR-Driver/src/output/impl/DisplayController.cpp
View File

@@ -16,8 +16,8 @@ namespace output
namespace impl
{
DisplayController::DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<DisplayBoardPinController> output_gpio_interface)
: displays(std::move(displays)), pin_controller(std::move(output_gpio_interface)), is_running(true)
DisplayController::DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller)
: displays(std::move(displays)), pin_controller(std::move(pin_controller)), is_running(true)
{
this->display_cycle_thread = std::thread(&DisplayController::cycle_displays, this);

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

@@ -26,7 +26,7 @@ namespace impl
class DisplayController : public output::DisplayController
{
public:
explicit DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::shared_ptr<DisplayBoardPinController> output_gpio_interface);
explicit DisplayController(std::vector<std::shared_ptr<items::IDisplay>> displays, std::unique_ptr<DisplayBoardPinController> pin_controller);
~DisplayController() override;
private:

4
FlippR-Driver/src/output/impl/DriverBoardPinController.h
View File

@@ -7,7 +7,9 @@
#include "output/DriverBoardPinController.h"
#include "OutputPinController.h"
#include "output/OutputPinController.h"
#include <output/items/DriverBoardItem.h>
#include <map>
#include <memory>

4
FlippR-Driver/src/output/impl/OutputDriver.cpp
View File

@@ -19,8 +19,8 @@ namespace impl
using namespace items;
OutputDriver::OutputDriver(std::map<std::string, std::shared_ptr<ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<ILamp>> lamps, std::map<std::string, std::shared_ptr<ISound>> sounds, std::map<char, std::shared_ptr<IDisplay>> displays)
: solenoids(std::move(solenoids)), lamps(std::move(lamps)), sounds(std::move(sounds)), displays(std::move(displays))
OutputDriver::OutputDriver(std::unique_ptr<output::DisplayController> display_controller, std::map<std::string, std::shared_ptr<ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<ILamp>> lamps, std::map<std::string, std::shared_ptr<ISound>> sounds, std::map<char, std::shared_ptr<IDisplay>> displays)
: display_controller(std::move(display_controller)), solenoids(std::move(solenoids)), lamps(std::move(lamps)), sounds(std::move(sounds)), displays(std::move(displays))
{}
std::vector<std::shared_ptr<ISound>> OutputDriver::get_sounds()

5
FlippR-Driver/src/output/impl/OutputDriver.h
View File

@@ -9,6 +9,7 @@
#define _SRC_OUTPUT_OUTPUTDRIVER_H_
#include "output/OutputDriver.h"
#include "output/DisplayController.h"
#include <map>
@@ -22,7 +23,7 @@ namespace impl
class OutputDriver : public output::OutputDriver
{
public:
OutputDriver(std::map<std::string, std::shared_ptr<items::ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<items::ILamp>> lamps, std::map<std::string, std::shared_ptr<items::ISound>> sounds, std::map<char, std::shared_ptr<items::IDisplay>> displays);
OutputDriver(std::unique_ptr<output::DisplayController> display_controller, std::map<std::string, std::shared_ptr<items::ISolenoid>> solenoids, std::map<std::string, std::shared_ptr<items::ILamp>> lamps, std::map<std::string, std::shared_ptr<items::ISound>> sounds, std::map<char, std::shared_ptr<items::IDisplay>> displays);
~OutputDriver() override = default;
// todo what is flipper_relay ?
@@ -37,6 +38,8 @@ public:
boost::optional<std::shared_ptr<items::IDisplay>> get_display(char number) override;
private:
std::unique_ptr<output::DisplayController> display_controller;
const std::map<std::string, std::shared_ptr<items::ILamp>> lamps;
const std::map<std::string, std::shared_ptr<items::ISolenoid>> solenoids;
const std::map<std::string, std::shared_ptr<items::ISound>> sounds;

51
FlippR-Driver/src/output/impl/OutputPinController.cpp
View File

@@ -1,51 +0,0 @@
/*
* OutputGPIOInterface.h
*
* Created on: May 31, 2018
* Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
*/
#include "OutputPinController.h"
#include "utility/config.h"
namespace flippR_driver
{
namespace output
{
namespace impl
{
using namespace output::items;
OutputGPIOInterface::OutputGPIOInterface(std::map<std::string, uint8_t> pins_driver_board, std::map<std::string, uint8_t> pins_sound, std::map<std::string, uint8_t> pins_display)
: pins_driver_board(std::move(pins_driver_board)), pins_sound(std::move(pins_sound)), pins_display(std::move(pins_display))
{
initialize_i2c_addresses();
initialize_pins();
}
void OutputGPIOInterface::initialize_i2c_address(const uint8_t &i2c_address, const uint8_t &pin_base)
{
mcp23017Setup(pin_base, i2c_address);
}
void OutputGPIOInterface::initialize_pins_output(const uint8_t &pin_base)
{
// Since this are all outputs we just initialize everything as output conveniently
for(int i = 0; i < 16; i++)
{
PinController::initialize_output_pin(pin_base + i);
}
}
}
}

10
FlippR-Driver/src/output/impl/SoundBoardPinController.cpp
View File

@@ -17,7 +17,7 @@ SoundBoardPinController::SoundBoardPinController(std::map<std::string, uint8_t>
}
void SoundBoardPinController::activate(items::Sound &sound)
void SoundBoardPinController::activate(const items::Sound &sound)
{
std::lock_guard<std::mutex> guard(*output_item_mutex);
@@ -26,7 +26,7 @@ void SoundBoardPinController::activate(items::Sound &sound)
fire_sound(true);
}
void SoundBoardPinController::deactivate(items::Sound &sound)
void SoundBoardPinController::deactivate(const items::Sound &sound)
{
std::lock_guard<std::mutex> guard(*output_item_mutex);
@@ -36,7 +36,7 @@ void SoundBoardPinController::deactivate(items::Sound &sound)
}
void SoundBoardPinController::write_sound_address(uint8_t address)
void SoundBoardPinController::write_sound_address(const uint8_t address)
{
write_pin(pins_sound.at("A"), address & 0b0000001u);
write_pin(pins_sound.at("B"), address & 0b0000010u);
@@ -47,12 +47,12 @@ void SoundBoardPinController::write_sound_address(uint8_t address)
write_pin(pins_sound.at("G"), address & 0b1000000u);
}
void SoundBoardPinController::fire_sound(bool fire)
void SoundBoardPinController::fire_sound(const bool fire)
{
PinController::write_pin(pins_sound.at("fire"), fire);
}
void SoundBoardPinController::write_pin(uint8_t pin, bool value)
void SoundBoardPinController::write_pin(const uint8_t pin, const bool value)
{
PinController::write_pin(pins_sound.at("pin_base") + pin, value);
}

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

@@ -2,12 +2,14 @@
// Created by rhetenor on 14.12.18.
//
#ifndef FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_SOUNDBOARDPINCONTROLLER_H
#ifndef FLIPPR_DRIVER_OUTPUT_IMPL_SOUNDBOARDPINCONTROLLER_H
#define FLIPPR_DRIVER_OUTPUT_IMPL_SOUNDBOARDPINCONTROLLER_H
#include "output/SoundBoardPinController.h"
#include "OutputPinController.h"
#include "output/OutputPinController.h"
#include <output/items/Sound.h>
#include <map>
namespace flippR_driver
@@ -27,10 +29,10 @@ public:
void deactivate(const items::Sound &sound) override;
private:
void write_sound_address(uint8_t address);
void fire_sound(bool fire);
void write_sound_address(const uint8_t address);
void fire_sound(const bool fire);
void write_pin(uint8_t pin, bool value);
void write_pin(const uint8_t pin, const bool value);
private:
std::shared_ptr<std::mutex> output_item_mutex;

9
FlippR-Driver/src/output/items/DriverBoardItem.h
View File

@@ -7,6 +7,8 @@
#include "output/items/Item.h"
#include <output/DriverBoardPinController.h>
#include <cstdint>
namespace flippR_driver
@@ -19,10 +21,13 @@ namespace items
class DriverBoardItem : public Item
{
public:
DriverBoardItem(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name) :
Item(std::move(output_gpio_interface), address, std::move(name)) {}
DriverBoardItem(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name) :
pin_controller(std::move(pin_controller)), Item(address, std::move(name)) {}
~DriverBoardItem() override = default;
protected:
const std::shared_ptr<DriverBoardPinController> pin_controller;
};
}

6
FlippR-Driver/src/output/items/Item.cpp
View File

@@ -12,10 +12,8 @@ namespace output
namespace items
{
Item::Item(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name) :
address(address),
name(std::move(name)),
gpio_interface(std::move(output_gpio_interface))
Item::Item(uint8_t address, std::string name) :
address(address), name(std::move(name))
{}
uint8_t Item::get_address()

6
FlippR-Driver/src/output/items/Item.h
View File

@@ -18,15 +18,13 @@ namespace flippR_driver
namespace output
{
class OutputPinController;
namespace items
{
class Item : public IItem
{
public:
Item(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name);
Item(uint8_t address, std::string name);
~Item() override = default;
uint8_t get_address() override;
@@ -36,8 +34,6 @@ protected:
const uint8_t address;
const std::string name;
const std::shared_ptr<OutputPinController> gpio_interface;
};
}

8
FlippR-Driver/src/output/items/Lamp.cpp
View File

@@ -15,18 +15,18 @@ namespace output
namespace items
{
Lamp::Lamp(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name) :
DriverBoardItem(std::move(output_gpio_interface), address, std::move(name)), activated(false)
Lamp::Lamp(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name) :
DriverBoardItem(std::move(pin_controller), address, std::move(name)), activated(false)
{}
void Lamp::activate()
{
gpio_interface->activate(this);
pin_controller->activate(this);
}
void Lamp::deactivate()
{
gpio_interface->deactivate(this);
pin_controller->deactivate(this);
}
}

2
FlippR-Driver/src/output/items/Lamp.h
View File

@@ -21,7 +21,7 @@ namespace items
class Lamp : public DriverBoardItem, public ILamp
{
public:
Lamp(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name);
Lamp(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name);
~Lamp() override = default;
void activate() override;

8
FlippR-Driver/src/output/items/Solenoid.cpp
View File

@@ -16,17 +16,17 @@ namespace output
namespace items
{
Solenoid::Solenoid(std::shared_ptr<OutputPinController> 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)
Solenoid::Solenoid(std::shared_ptr<DriverBoardPinController> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time):
DriverBoardItem(std::move(pin_controller), address, std::move(name)), deactivation_time(deactivation_time)
{}
void Solenoid::triggerTask()
{
gpio_interface->activate(this);
pin_controller->activate(this);
std::this_thread::sleep_for(deactivation_time);
gpio_interface->deactivate(this);
pin_controller->deactivate(this);
}
void Solenoid::trigger()

2
FlippR-Driver/src/output/items/Solenoid.h
View File

@@ -24,7 +24,7 @@ namespace items
class Solenoid : public DriverBoardItem, public ISolenoid
{
public:
Solenoid(std::shared_ptr<OutputPinController> output_gpio_interface, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time);
Solenoid(std::shared_ptr<DriverBoardPinController> pin_controller, u_int8_t address, std::string name, std::chrono::milliseconds deactivation_time);
~Solenoid() override = default;
void trigger() override;

10
FlippR-Driver/src/output/items/Sound.cpp
View File

@@ -7,7 +7,7 @@
#include "Sound.h"
#include "output/OutputPinController.h"
#include <output/SoundBoardPinController.h>
namespace flippR_driver
{
@@ -16,8 +16,8 @@ namespace output
namespace items
{
Sound::Sound(std::shared_ptr<OutputPinController> 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)
Sound::Sound(std::shared_ptr<SoundBoardPinController> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id) :
pin_controller(std::move(pin_controller)), Item(address, std::move(name)), deactivation_time(deactivation_time), id(id)
{}
void Sound::play()
@@ -27,11 +27,11 @@ void Sound::play()
void Sound::playTask()
{
gpio_interface->activate(this);
pin_controller->activate(this);
std::this_thread::sleep_for(deactivation_time);
gpio_interface->deactivate(this);
pin_controller->deactivate(this);
}
}

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

@@ -20,6 +20,9 @@ namespace flippR_driver
{
namespace output
{
class SoundBoardPinController;
namespace items
{
@@ -29,12 +32,14 @@ public:
u_int id;
public:
Sound(std::shared_ptr<OutputPinController> output_gpio_interface, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id);
Sound(std::shared_ptr<SoundBoardPinController> pin_controller, uint8_t address, std::string name, std::chrono::milliseconds deactivation_time, u_int id);
~Sound() override = default;
void play() override;
private:
const std::shared_ptr<SoundBoardPinController> pin_controller;
std::chrono::milliseconds deactivation_time;
std::future<void> play_task;