Atc.h

[詳解]

// Copyright 2018 S520
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met :
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and / or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef ATC_H_
#define ATC_H_
#include <boost/container/vector.hpp>
#include <boost/array.hpp>
#include <boost/scoped_ptr.hpp>
#include "Base.h"

#define LOGARGS __FILE__, __FUNCTION__, __LINE__  // For Debug
#define BRAKE_STEP 4  
#define ALL_PATTERN 8  
#define STA_PATTERN 3  
#define USR_PATTERN 3  
#define ALL_SIGNAL 12  

class Atc :private Base {
  private:
    int max_brake_notch_;  
    int brake_notch_;  
    boost::array<int, BRAKE_STEP>default_notch_;  
    int max_signal_;  
    boost::container::vector<double>pattern_list_;  
    int next_reset_sw_down_sound_;  
    int next_reset_sw_up_sound_;  
    boost::array<float, ALL_PATTERN>pattarn_end_loc_list_;  
    boost::array<int, ALL_PATTERN>pattern_is_valid_list_;  
    boost::array<int, ALL_PATTERN>pattern_tget_spd_list_;  
    boost::array<int, ALL_PATTERN>pattern_arrow_spd_list_;  
    boost::array<float, ALL_PATTERN>pattern_start_loc_list_;  
    int debug_timer_;  
    int brake_timer_;  

    int SearchSignal(int spd);
    int ItoV(int index);
    int ItoV(int index, bool is_display);
    void Reset(void);
    void SetPatternList(void);
    void ChangedAtcType(int atc_type);
    void PassedLoop(int signal);
    int SearchPattern(float distance);
    void ValidPattern(int& tget_spd, int pattern_status);
    int CalcPatternSpd(int tget_spd, float pattern_end_loc);
    float CalcPatternLoc(int tget_spd, float pattern_end_loc, int pattern_status);
    void CollectPattern(void);
    void CalcPattern(void);
    void ChangedArrowSignal(void);
    int CalcBrake(int index, int tget_spd, float pattern_start_loc, float pattern_end_loc);
    int SelectBrake(void);
    int NonFuzzyCtrExe(void);
    void BrakeExeA(void);
    void BrakeExeD(void);
    void DisplaySpd(int spd, boost::array<int, 3>&display_spd);
    void ResetIndicatorNS(void);
    void RunIndicatorNS(void);
    void RunIndicatorA(void);
    void RunIndicatorD(void);
    void RunSubSpeedometer(void);
    void PlaySound(void);


    class AtcA {
      private:
        const Atc *atc_;  

      public:
        int signal_;  
        int is_stop_eb_;  
        int is_stop_svc_;  
        int is__brake_reset_;  
        int next_atc_ding_;  

        explicit AtcA(const Atc *atc);
        virtual ~AtcA(void);
        void Init(void);
        void ChangedSignal(int signal);
    };

    class AtcD {
      private:
        const Atc *atc_;  
        float prev_spd_;  

      public:
        int is_stop_eb_;  
        int is_stop_svc_;  
        int is__brake_reset_;  
        int next_atc_ding_;  
        int arrow_spd_;  
        int arrow_signal_;  
        int prev_arrow_signal_;  
        int tget_spd_;  
        int tget_signal_;  
        int prev_tget_signal_;  

        explicit AtcD(const Atc *atc);
        virtual ~AtcD(void);
        void Init(void);
        void ChangedSignal(int signal);
        void AtcCheck(void);


        class SectionD :private Base {
          private:
            const Atc *atc_;  
            double prev_loc_;  
            boost::container::vector<float>section_loc_list_;  

          public:
            int track_path_;  
            float red_signal_loc_;  

            explicit SectionD(const Atc *atc);
            virtual ~SectionD(void);
            void Init(void);
            void RegSection(float distance);
            void CalcSection(void);
        };

        class StationD {
          private:
            const Atc *atc_;  
            int is_stop_sta_;  
            boost::array<int, STA_PATTERN>pattern_is_ready_;  

          public:
            boost::array<float, STA_PATTERN>pattern_end_loc_;  
            boost::array<int, STA_PATTERN>pattern_is_valid_;  
            boost::array<int, STA_PATTERN>pattern_tget_spd_;  

            explicit StationD(const Atc *atc);
            virtual ~StationD(void);
            void Init(void);
            void RegStaStop(int signal);
            void RegStaBranch(int distance);
            void RegStaManual(int distance);
            void RegStaEnd(int distance);
            void RegStaLoc(void);
            void IsStopSta(void);
        };

        class PatternD {
          private:
            const Atc *atc_;  

          public:
            boost::array<float, USR_PATTERN>pattern_end_loc_;  
            boost::array<int, USR_PATTERN>pattern_is_valid_;  
            boost::array<int, USR_PATTERN>pattern_tget_spd_;  

            explicit PatternD(const Atc *atc);
            virtual ~PatternD(void);
            void Init(void);
            void RegPattern(int type, int optional);
        };
        boost::scoped_ptr<SectionD>section_d_;
        boost::scoped_ptr<StationD>station_d_;
        boost::scoped_ptr<PatternD>pattern_d_;
    };

    class Fuzzy :private Base {
      private:
        const Atc *atc_;  
        int prev_brake_notch_;  
        int adj_timer_;  
        float fuzzy_prev_Tc_;  
        int fuzzy_prev_Nc_;  
        boost::container::vector<float>fuzzy_Xp_;  
        boost::container::vector<float>fuzzy_Ugg_;  
        boost::container::vector<float>fuzzy_Uga_;  
        float fuzzy_Ucg_;  
        float fuzzy_Ucb_;  
        boost::container::vector<float>fuzzy_U_;  
        float fuzzy_Usb_;  
        float fuzzy_Usvb_;  

        float FuzzyFuncL(float x, float a, float b);
        float FuzzyFuncF(float x, float a, float b);
        float FuzzyFuncA(float x, float a, float b);
        float FuzzyFuncG(float x, float a, float b);
        float FuzzyFuncQ(float x, float a, float b);
        float FuzzyEstLoc(int tget_spd, int notch_num);

      public:
        float adj_deceleration_;  
        boost::array<int, ALL_PATTERN>fuzzy_step_;  
        boost::array<int, ALL_PATTERN>brake_timer_;  
        boost::array<int, ALL_PATTERN>prev_tget_spd_;  
        boost::array<float, ALL_PATTERN>prev_pattern_end_loc_;  
        boost::array<int, ALL_PATTERN>fuzzy_brake_notch_list_;  

        explicit Fuzzy(const Atc *atc);
        virtual ~Fuzzy(void);
        void Init(void);
        void FuzzyAdjDeceleration(void);
        int FuzzyCtrInit(int index, float pattern_start_loc);
        int FuzzyCtrExe(int index, int tget_spd, float pattern_end_loc);
    };
    boost::scoped_ptr<AtcA>atc_a_;
    boost::scoped_ptr<AtcD>atc_d_;
    boost::scoped_ptr<Fuzzy>fuzzy_;

  public:
    int ServiceNotch;  
    int AtsNotch;  
    const float *TrainSpeed;  
    const float *Accel;  
    const int *Time;  
    const int *BrakeNotch;  
    const int *ManualBrakeNotch;  
    const int *PowerNotch;  
    double Location;  
    float max_deceleration_;  
    int atc_power_;  
    int atc_use_;  
    int atc_type_;  
    int atc_max_spd_;  
    boost::array<int, ALL_SIGNAL>atc_spd_list_;  
    boost::array<float, BRAKE_STEP>atc_deceleration_;  
    int atc_reset_sw_;  
    int atc_brake_notch_;  
    int atc_red_signal_;  
    int atc_green_signal_;  
    boost::array<int, ALL_SIGNAL>atc_sig_indicator_;  
    boost::array<int, 3>atc_spd_7seg_;  
    int atc_signal_index_;  
    int atc_spd_;  
    int dsatc_arrow_spd_;  
    boost::array<int, 3>sub_spd_label_1_;  
    boost::array<int, 3>sub_spd_label_2_;  
    boost::array<int, 3>sub_spd_label_3_;  
    boost::array<int, 3>sub_spd_label_4_;  
    int sub_atc_spd_;  
    int sub_train_spd_;  
    float lever_delay_;  
    int atc_ding_;  
    int reset_sw_up_sound_;  
    int reset_sw_down_sound_;  
    int atc_eb_lamp_;  
    int atc_svc_lamp_;  
    float Xe;  
    float Xo;  
    float Xk;  

    Atc(void);
    virtual ~Atc(void);
    void InitNS(void);
    void StartNS(void);
    void ExitNS(void);
    void ChangedSignalNS(int signal);
    void PassedBeaconNS(int index, int signal, float distance, int optional);
    void ResetSwDownNS(void);
    void ResetSwUpNS(void);
    void ExeNS(void);
};

#endif  // ATC_H_