BaseRobot.hpp

/*
 * Copyright 2021 Marcus Behel
 *
 * This file is part of ArPiRobot-CoreLib.
 * 
 * ArPiRobot-CoreLib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * ArPiRobot-CoreLib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with ArPiRobot-CoreLib.  If not, see <https://www.gnu.org/licenses/>. 
 */
 
#pragma once
 
#include <arpirobot/core/device/BaseDevice.hpp>
#include <arpirobot/core/robot/RobotProfile.hpp>
#include <arpirobot/core/scheduler.hpp>
#include <chrono>
#include <thread>
#include <mutex>
#include <vector>
#include <memory>
 
namespace arpirobot{
 
    class BaseRobot{
    public:
        BaseRobot() = default;
        BaseRobot(const BaseRobot &other) = delete;
 
        virtual ~BaseRobot() = default;
 
        BaseRobot &operator=(const BaseRobot &other) = delete;
 
        void feedWatchdog();
 
        void start();
 
        static std::shared_ptr<Task> scheduleRepeatedFunction(const std::function<void()> &&func, sched_clk::duration rate);
 
        static void runOnceSoon(const std::function<void()> &&func);
 
        static void removeTaskFromScheduler(std::shared_ptr<Task> task);
 
        static void beginWhenReady(BaseDevice *device);
 
        static void deviceDestroyed(BaseDevice *device);
 
        virtual void robotStarted() = 0;
 
        virtual void robotEnabled() = 0;
 
        virtual void robotDisabled() = 0;
 
        virtual void enabledPeriodic() = 0;
 
        virtual void disabledPeriodic() = 0;
 
        virtual void periodic() = 0;
 
        // True after start, false before stop
        // Used to determine if a BaseRobot instance is running or not
        static bool exists;
 
    private:
        static void stopSignalHandler(int signal);
 
        static void ignoreSignalHandler(int signal);
 
        void modeBasedPeriodic();
 
        void doPeriodic();
 
        void runWatchdog();
 
        void onDisable();
 
        void onEnable();
 
 
        // Status
        bool isEnabled = false;
 
        // Watchdog
        std::mutex watchdogMutex;
        std::chrono::steady_clock::time_point lastWatchdogFeed;
        bool watchdogDidDisable = false;
 
 
        // Static variables
 
        // Devices used on current robot
        // Not using shared_ptr because devices add themselves to this list
        // and remove themselves when destroyed
        static std::vector<BaseDevice*> devices;
        static std::mutex devicesLock;
        static bool devicesBeginNow;
 
        // Stop flag from Ctrl+C
        static bool stop;
 
        // Scheduler
        static Scheduler *scheduler;
 
        // Lock to ensure access to "exists" var is exclusive
        static std::mutex existsLock;
    };
}