MSDevice_ToC.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2013-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// The ToC Device controls the transition of control between automated and manual driving.
//
/****************************************************************************/
#ifndef MSDevice_ToC_h
#define MSDevice_ToC_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include "MSDevice.h"
#include <utils/common/SUMOTime.h>
#include <utils/common/WrappingCommand.h>


// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class MSVehicle;
class Command_ToCTrigger;
class Command_ToCProcess;
class RGBColor;

// ===========================================================================
// class definitions
// ===========================================================================
class MSDevice_ToC : public MSDevice {
public:
    static void insertOptions(OptionsCont& oc);


    static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSDevice*>& into);

private:

    enum ToCState {
        UNDEFINED = 0,
        MANUAL = 1,
        AUTOMATED = 2,
        PREPARING_TOC = 3, // this applies only to the transition AUTOMATED -> MANUAL !
        MRM = 4,
        RECOVERING = 5
    };

    static std::string getManualType(const SUMOVehicle& v, const OptionsCont& oc);
    static std::string getAutomatedType(const SUMOVehicle& v, const OptionsCont& oc);
    static double getResponseTime(const SUMOVehicle& v, const OptionsCont& oc);
    static double getRecoveryRate(const SUMOVehicle& v, const OptionsCont& oc);
    static double getInitialAwareness(const SUMOVehicle& v, const OptionsCont& oc);
    static double getMRMDecel(const SUMOVehicle& v, const OptionsCont& oc);
    static bool useColorScheme(const SUMOVehicle& v, const OptionsCont& oc);

    static ToCState _2ToCState(const std::string&);
    static std::string _2string(ToCState state);


public:
    ~MSDevice_ToC();

    const std::string deviceName() const {
        return "toc";
    }

    std::string getParameter(const std::string& key) const;

    void setParameter(const std::string& key, const std::string& value);


    SUMOTime ensureDriverStateExistence(SUMOTime);

    SUMOTime triggerMRM(SUMOTime t);

    SUMOTime triggerUpwardToC(SUMOTime t);

    SUMOTime triggerDownwardToC(SUMOTime t);

    SUMOTime ToCPreparationStep(SUMOTime t);

    SUMOTime MRMExecutionStep(SUMOTime t);

    SUMOTime awarenessRecoveryStep(SUMOTime t);

private:
    MSDevice_ToC(SUMOVehicle& holder, const std::string& id,
                 std::string manualType, std::string automatedType,
                 SUMOTime responseTime, double recoveryRate, double initialAwareness,
                 double mrmDecel, bool useColorScheme);

    void initColorScheme();

    void setAwareness(double value);

    void setState(ToCState state);

    // @brief Sets the device holder's color corresponding to the current state
    void setVehicleColor();

    void requestToC(SUMOTime timeTillMRM);

    void requestMRM();

    void switchHolderType(const std::string& targetTypeID);

    void descheduleMRM();
    void descheduleToC();
    void descheduleToCPreparation();
    void descheduleRecovery();



private:

    std::string myManualTypeID;
    std::string myAutomatedTypeID;

    // @brief Average response time needed by the driver to take back control
    SUMOTime myResponseTime;
    // @brief Recovery rate for the driver's awareness after a ToC
    double myRecoveryRate;
    // @brief Average awareness the driver has initially after a ToC
    double myInitialAwareness;

    double myMRMDecel;

    // @brief Current awareness-level of the driver in [0,1]
    double myCurrentAwareness;

    std::map<ToCState, RGBColor> myColorScheme;

    bool myUseColorScheme;

    ToCState myState;


    MSVehicle* myHolderMS;

    WrappingCommand<MSDevice_ToC>* myTriggerMRMCommand;
    WrappingCommand<MSDevice_ToC>* myTriggerToCCommand;
    WrappingCommand<MSDevice_ToC>* myRecoverAwarenessCommand;
    WrappingCommand<MSDevice_ToC>* myExecuteMRMCommand;
    WrappingCommand<MSDevice_ToC>* myPrepareToCCommand;


private:
    MSDevice_ToC(const MSDevice_ToC&);

    MSDevice_ToC& operator=(const MSDevice_ToC&);


};


#endif

/****************************************************************************/