AtsP.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 ATSP_H_
#define ATSP_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 ALL_PATTERN_P 7  
#define USR_PATTERN_P 5  

class Atsp :private Base {
  private:
    int max_brake_notch_;  
    int default_notch_;  
    boost::container::vector<double>pattern_list_;  
    double adj_deceleration_;  
    boost::array<float, ALL_PATTERN_P>pattern_end_loc_list_;  
    boost::array<int, ALL_PATTERN_P>pattern_is_valid_list_;  
    boost::array<int, ALL_PATTERN_P>pattern_tget_spd_list_;  
    boost::array<int, ALL_PATTERN_P>pattern_pre_spd_list_;  
    boost::array<int, ALL_PATTERN_P>pattern_aprch_list_;  
    int next_atsp_ding_;  
    int prev_aprch_lamp_;  
    int debug_timer_;  

    void SetPatternList(void);
    void AdjDeceleration(int deceleration);
    int SearchPattern(float distance);
    void ValidPattern(int& tget_spd, int pattern_status);
    int CalcPatternSpd(int tget_spd, float pattern_end_loc);
    int IsAprchPattern(int tget_spd, float pattern_end_loc);
    void CollectPattern(void);
    void CalcPattern(void);
    void AtspCheck(void);
    void Reset(void);
    void BrakeExe(void);
    void DisplayLamp(void);
    void PlaySound(void);


    class SectionP {
      private:
        const Atsp *atsp_;  
        float red_signal_loc_;  

      public:
        int is_immediate_stop_eb_;  
        int is_immediate_stop_svc_;  
        int is_immediate_stop_;  
        int is_stop_svc_;  
        int is__brake_reset_;  
        float pattern_end_loc_;  
        int pattern_is_valid_;  
        int pattern_tget_spd_;  

        explicit SectionP(Atsp *atsp);
        virtual ~SectionP(void);
        void Init(void);
        void GetSection(float distance);
        void PassedStopEb(float distance);
        void PassedStopSvc(float distance);
        void CalcSection(void);
    };

    class PatternP {
      private:
        const Atsp *atsp_;  

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

        explicit PatternP(Atsp *atsp);
        virtual ~PatternP(void);
        void Init(void);
        void RegPattern(int type, int optional);
        void DelPattern(int type);
    };
    boost::scoped_ptr<SectionP>section_p_;
    boost::scoped_ptr<PatternP>pattern_p_;

  public:
    int EmergencyNotch;  
    int ServiceNotch;  
    int AtsNotch;  
    const float *TrainSpeed;  
    const int *Time;  
    const int *ManualBrakeNotch;  
    double Location;  
    float max_deceleration_;  
    int atsp_power_;  
    int atsp_use_;  
    int atsp_max_spd_;  
    float atsp_deceleration_;  
    int atsp_brake_notch_;  
    int atsp_aprch_lamp_;  
    int atsp_brake_lamp_;  
    int atsp_reset_lamp_;  
    int atsp_ding_;  

    Atsp(void);
    virtual ~Atsp(void);
    void InitP(void);
    void StartP(void);
    void ExitP(void);
    void PassedBeaconP(int index, int signal, float distance, int optional);
    void ResetSwDownP(void);
    void ExeP(void);
};

#endif  // ATSP_H_