本例将care_taker程序拆分为两个单独的care_taker对象，一个是sunlight_care_taker_t, 一个是moisture_care_taker_t。
本例采用C++的命名空间机制进行了分层。同时采用python的下划线命名法。
程序的目录结构如下
图片.png
CMakeLists.txt
cmake_minimum_required(VERSION 3.3)
project(02_plant_care_isp)
set(ENV{PKG_CONFIG_PATH} "$ENV{PKG_CONFIG_PATH}:/usr/local/lib/pkgconfig/")
set ( CMAKE_CXX_FLAGS "-pthread")
set(CMAKE_CXX_STANDARD 20)
add_definitions(-g)
include_directories(
${INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/include
)
LINK_DIRECTORIES(${LINK_DIRS})
file( GLOB main_file_list ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
file( GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/**/**/*.cc)
foreach( main_file ${main_file_list} )
file(RELATIVE_PATH filename ${CMAKE_CURRENT_SOURCE_DIR} ${main_file})
string(REPLACE ".cpp" "" file ${filename})
add_executable(${file} ${main_file} ${SOURCES})
target_link_libraries(${file} pthread)
endforeach( main_file ${main_file_list})
main.cpp
#include <thread>
#include <mutex>
#include "care_taker/moisture_care_taker.h"
#include "care_taker/sunlight_care_taker.h"
#include "sensors/moisture_sensor.h"
#include "sensors/sunlight_sensor.h"
void run() {
std::mutex sensor_mutex;
sensors::sunlight_sensor_t sunlight_sensor(std::chrono::seconds(2), sensor_mutex);
sensors::moisture_sensor_t moisture_sensor(std::chrono::seconds(3), sensor_mutex);
care_taker::sunlight_care_taker_t sunlight_care_taker;
care_taker::moisture_care_taker_t moisture_care_taker;
moisture_sensor.subscribe(moisture_care_taker);
sunlight_sensor.subscribe(sunlight_care_taker);
std::thread sunlight_sensor_thread(sunlight_sensor);
std::thread moisture_sensor_thread(moisture_sensor);
sunlight_sensor_thread.join();
moisture_sensor_thread.join();
}
int main(int argc, char* argv[]) {
run();
return EXIT_SUCCESS;
}
care_taker/i_moisture_care_taker.h
#ifndef _FREDIRC_I_MOISTURE_CARE_TAKER_H_
#define _FREDIRC_I_MOISTURE_CARE_TAKER_H_
namespace care_taker {
class i_moisture_care_taker_t {
public:
virtual ~i_moisture_care_taker_t() = default;
virtual void pour_water() = 0;
virtual void sprinkle_water() = 0;
};
} // namespace care_taker
#endif
care_taker/i_sunlight_care_taker.h
#ifndef _FREDRIC_I_SUNLIGHT_CARE_TAKER_H_
#define _FREDRIC_I_SUNLIGHT_CARE_TAKER_H_
namespace care_taker {
class i_sunlight_care_taker_t {
public:
~i_sunlight_care_taker_t() = default;
virtual void open_window_blinds() = 0;
virtual void close_window_blinds() = 0;
};
} // namespace care_taker
#endif
care_taker/moisture_care_taker.h
#ifndef _FREDIRC_MOISTURE_CARE_TAKER_H_
#define _FREDIRC_MOISTURE_CARE_TAKER_H_
#include "care_taker/i_moisture_care_taker.h"
namespace care_taker {
class moisture_care_taker_t: public i_moisture_care_taker_t {
public:
void pour_water() override;
void sprinkle_water() override;
};
} // end care_taker
#endif
care_taker/sunlight_care_taker.h
#ifndef _FREDRIC_SUNLIGHT_CARE_TAKER_H_
#define _FREDRIC_SUNLIGHT_CARE_TAKER_H_
#include "care_taker/i_sunlight_care_taker.h"
namespace care_taker {
class sunlight_care_taker_t: public i_sunlight_care_taker_t {
bool m_window_blinds_open {true};
public:
void open_window_blinds() override;
void close_window_blinds() override;
};
} // namespace care_taker
#endif
care_taker/moisture_care_taker.cc
#include "care_taker/moisture_care_taker.h"
#include <iostream>
namespace care_taker {
void moisture_care_taker_t::pour_water() {
std::cout << "pouring water on Aloe" << std::endl;
}
void moisture_care_taker_t::sprinkle_water() {
std::cout << "sprinkling water on Aloe" << std::endl;
}
}
care_taker/sunlight_care_taker.cc
#include "care_taker/sunlight_care_taker.h"
#include <iostream>
namespace care_taker {
void sunlight_care_taker_t::open_window_blinds() {
if(!m_window_blinds_open) {
m_window_blinds_open = true;
std::cout << "Opened window blinds for Aloe" << std::endl;
}
}
void sunlight_care_taker_t::close_window_blinds() {
if(m_window_blinds_open) {
m_window_blinds_open = false;
std::cout << "Closed window blinds for Aloe" << std::endl;
}
}
}
sensors/moisture_sensor.h
#ifndef _FREDRIC_MOISTURE_SENSOR_H_
#define _FREDRIC_MOISTURE_SENSOR_H_
#include <chrono>
#include <mutex>
#include <set>
#include "care_taker/i_moisture_care_taker.h"
namespace sensors {
class moisture_sensor_t {
std::chrono::seconds const m_sleep_time;
std::mutex& m_mutex;
std::set<care_taker::i_moisture_care_taker_t*> m_care_takers;
int const m_min = 0;
int const m_max = 10;
int const m_threshold = 3;
public:
moisture_sensor_t(std::chrono::seconds, std::mutex&);
void subscribe(care_taker::i_moisture_care_taker_t&);
void operator()();
private:
bool is_air_too_dry();
bool is_soil_too_dry();
int get_air_moisture();
int get_soil_moisture();
};
}
#endif
sensors/sunlight_sensor.h
#ifndef _FREDRIC_SUNLIGHT_SENSOR_H_
#define _FREDRIC_SUNLIGHT_SENSOR_H_
#include <chrono>
#include <mutex>
#include <set>
#include <optional>
#include "care_taker/i_sunlight_care_taker.h"
namespace sensors {
class sunlight_sensor_t {
using time_point_t = decltype(std::chrono::system_clock::now());
std::chrono::seconds const m_sleep_time;
std::mutex& m_mutex;
std::set<care_taker::i_sunlight_care_taker_t*> m_care_takers;
std::optional<time_point_t> m_sunlight_on_from;
std::optional<time_point_t> m_sunlight_off_from;
int const m_thresold = 2;
bool m_sensor_on = true;
public:
sunlight_sensor_t(std::chrono::seconds const, std::mutex&);
void subscribe(care_taker::i_sunlight_care_taker_t&);
void operator()();
private:
void update_state(bool const);
bool is_too_much_sunlight(bool const);
bool is_too_little_sunlight(bool const);
bool is_sunlight() const;
};
} // sensors
#endif
sensors/moisture_sensor.cc
#include "sensors/moisture_sensor.h"
#include <thread>
#include <random>
namespace sensors {
moisture_sensor_t::moisture_sensor_t(std::chrono::seconds sleep_time, std::mutex& mutex_):
m_sleep_time(sleep_time), m_mutex(mutex_) {
}
void moisture_sensor_t::subscribe(care_taker::i_moisture_care_taker_t& care_taker) {
m_care_takers.insert(&care_taker);
}
void moisture_sensor_t::operator()() {
for(;;) {
std::unique_lock<std::mutex> lock(m_mutex);
if(is_air_too_dry()) {
for(auto care_taker : m_care_takers) {
care_taker->sprinkle_water();
}
}
if(is_soil_too_dry()) {
for(auto care_taker : m_care_takers) {
care_taker->pour_water();
}
}
lock.unlock();
std::this_thread::sleep_for(m_sleep_time);
}
}
bool moisture_sensor_t::is_air_too_dry() {
return get_air_moisture() < m_threshold;
}
bool moisture_sensor_t::is_soil_too_dry() {
return get_soil_moisture() < m_threshold;
}
int moisture_sensor_t::get_air_moisture() {
static std::mt19937 generator;
return std::uniform_int_distribution<int>(m_min, m_max)(generator);
}
int moisture_sensor_t::get_soil_moisture() {
static std::mt19937 generator;
return std::uniform_int_distribution<int>(m_min, m_max)(generator);
}
}
sensors/sunlight_sensor.cc
#include "sensors/sunlight_sensor.h"
#include <iostream>
#include <thread>
#include <random>
namespace sensors {
sunlight_sensor_t::sunlight_sensor_t(std::chrono::seconds const sleep_time, std::mutex& mutex_):
m_sleep_time{sleep_time},
m_mutex{mutex_}
{
}
void sunlight_sensor_t::subscribe(care_taker::i_sunlight_care_taker_t& care_taker) {
m_care_takers.insert(&care_taker);
}
void sunlight_sensor_t::operator()() {
for(;;) {
std::unique_lock<std::mutex> lock(m_mutex);
auto const sunlight = is_sunlight();
update_state(sunlight);
std::cout << "sun shines: " << std::boolalpha << sunlight << std::endl;
if(is_too_much_sunlight(sunlight)) {
for(auto& p: m_care_takers) {
p->close_window_blinds();
}
m_sensor_on = false;
} else if(is_too_little_sunlight(sunlight)) {
for(auto& p: m_care_takers) {
p->open_window_blinds();
}
m_sensor_on = true;
}
lock.unlock();
std::this_thread::sleep_for(m_sleep_time);
}
}
void sunlight_sensor_t::update_state(bool const sunlight) {
auto const current_time = std::chrono::system_clock::now();
if(sunlight && m_sensor_on) {
m_sunlight_on_from = m_sunlight_on_from? *m_sunlight_on_from: current_time;
m_sunlight_off_from = std::nullopt;
} else if(!sunlight) {
m_sunlight_off_from = m_sunlight_off_from? *m_sunlight_off_from: current_time;
m_sunlight_on_from = std::nullopt;
}
}
bool sunlight_sensor_t::is_too_much_sunlight(bool const sunlight) {
if(sunlight) {
auto const time_now = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed_secs = time_now - *m_sunlight_on_from;
return elapsed_secs.count() > m_thresold;
}
return false;
}
bool sunlight_sensor_t::is_too_little_sunlight(bool const sunlight) {
if(!sunlight) {
auto const time_now = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed_secs = time_now - *m_sunlight_off_from;
return elapsed_secs.count() > m_thresold;
}
return false;
}
bool sunlight_sensor_t::is_sunlight() const {
static bool sun_shines = false;
static std::mt19937 generator;
auto prob = std::uniform_int_distribution<int>(1, 100)(generator);
if(prob >= 80) {
sun_shines = !sun_shines;
}
return sun_shines;
}
}
程序输出的效果如下，
图片.png
