Automation.h

Go to the documentation of this file.

#ifndef AUTOMATION_INCLUDED
#define AUTOMATION_INCLUDED

#include "odem.h"
#include <cassert>

#include "Location.h"

class BathPlace;
class Crane;
class Loader;
class Furnace;
class BufferStore;
class RingFactory;
class VehicleToFurn;
class VehicleFromFurn;
class ReturnBufferStore;
class CraneRequestq;
class SetOfRingStack;

class Automation : public Discrete {
public:
        Automation(
                //PlaceConfiguration* pC,
                const Crane* c,
                Loader* l,
                Furnace** f,
                BufferStore* leftB,
                BufferStore* rightB,
                const RingFactory* fa,
                VehicleToFurn* vTF,
                VehicleFromFurn* vFF,
                ReturnBufferStore* leftL,
                ReturnBufferStore* rightL,
                const CraneRequestq* cReqQ
                );
        virtual ~Automation();

        virtual int main();

        // SynchSignale
        void vehicleTFReady(){waitVehicleToFurn.wait();}
        void vehicleFFReady(){waitVehicleFromFurn.wait();}
        void leftBufferReady(){waitLeftBuffer.wait();}
        void rightBufferReady(){waitRightBuffer.wait();}
        void leftLoadingReady(){waitLeftLoading.wait();}
        void rightLoadingReady(){waitRightLoading.wait();}
        void loaderReady(){waitLoader.wait();}

        // Untebrechungsbehandlung
        void interrupt (int cause);
        void goAhead (int cause);
        static bool rightTime();

        VehicleFromFurn* getvFF() {return vehicleFromFurn;}

        // Strategie-Entscheidungen für Loader
        ReturnBufferStore* getLoading();

        // Strategie-Entscheidungen für Furnace
        SetOfRingStack* getNextPalette() {return nextPalette;}

        // Externe Signale
        void signalWakeUp();

protected:
        
        static bool working;
        Condq*  interruptQ;

        BathPlace** baths;
        const Crane* crane;
        Loader* loader;
        Furnace** furnaces;
        BufferStore* leftBuffer;
        BufferStore* rightBuffer;
        const RingFactory* factory;
        VehicleToFurn* vehicleToFurn;
        VehicleFromFurn* vehicleFromFurn;
        ReturnBufferStore* leftLoading;
        ReturnBufferStore* rightLoading;
        const CraneRequestq* craneRequestQ;
        Direction nextBuffer;
        Direction nextLoading;

        SetOfRingStack* nextPalette;

        Waitq waitVehicleToFurn;
        Waitq waitVehicleFromFurn;
        Waitq waitLeftBuffer;
        Waitq waitRightBuffer;
        Waitq waitLeftLoading;
        Waitq waitRightLoading;
        Waitq waitLoader;

        // Strategie-Entscheidungen
        virtual void holdTransport();

        Direction useBuffer();
        Direction useLoading();

        // Strategie-Funktionen
        Direction fLinksRechts();
        Direction fLinksPrior();
        Direction fNacheinander();
        Direction fFairness();
        Direction fOfenPrior();
        Direction fSpeicherOpt1();
        Direction fSpeicherOpt2();
        Direction fMulti();

        int getFreeOven();

        // Hilfsfunktionen
        void writeBuffer(std::ostream& os, bool all=false);
};


#endif

---