diff --git a/mcc/mcc_generic_mount.h b/mcc/mcc_generic_mount.h
index 90105dd..640e4bb 100644
--- a/mcc/mcc_generic_mount.h
+++ b/mcc/mcc_generic_mount.h
@@ -130,6 +130,8 @@ protected:
         base_gmount_t;
 
 public:
+    typedef typename base_gmount_t::error_t error_t;
+
     /*                          EVENTS AND STATES DEFINITION                            */
 
 
@@ -163,8 +165,6 @@ public:
     struct MccGenericMountEventError : MccGenericMountBaseEvent {
         static constexpr std::string_view ID = "MCC-MOUNT-ERROR-EVENT";
 
-        typedef typename base_gmount_t::error_t error_t;
-
         MccGenericMountEventError(MccGenericMountFSM& mount, const error_t& err)
             : MccGenericMountBaseEvent(mount), _error(err)
         {
@@ -257,14 +257,7 @@ public:
 
     struct MccGenericMountStateUninit : MccGenericMountBaseState {
         // from uninitialized state only INIT-event is permitted!
-        using transition_t =
-            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>,
-                                        std::pair<MccGenericMountEventIDLE, MccGenericMountStateUninit>,
-                                        std::pair<MccGenericMountEventError, MccGenericMountStateUninit>,
-                                        std::pair<MccGenericMountEventStop, MccGenericMountStateUninit>,
-                                        std::pair<MccGenericMountEventSlew, MccGenericMountStateUninit>,
-                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateUninit>,
-                                        std::pair<MccGenericMountEventGuiding, MccGenericMountStateUninit>>;
+        using transition_t = fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>>;
 
         template <std::derived_from<MccGenericMountBaseEvent> EvT>
         void exit(EvT& event)
@@ -281,13 +274,15 @@ public:
 
     struct MccGenericMountStateInit : MccGenericMountBaseState {
         using transition_t =
-            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>,
-                                        std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
-                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
-                                        std::pair<MccGenericMountEventStop, MccGenericMountStateInit>,
-                                        std::pair<MccGenericMountEventSlew, MccGenericMountStateInit>,
-                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateInit>,
-                                        std::pair<MccGenericMountEventGuiding, MccGenericMountStateInit>>;
+            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
+                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>>;
+        // fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>,
+        //                             std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
+        //                             std::pair<MccGenericMountEventError, MccGenericMountStateError>,
+        //                             std::pair<MccGenericMountEventStop, MccGenericMountStateInit>,
+        //                             std::pair<MccGenericMountEventSlew, MccGenericMountStateInit>,
+        //                             std::pair<MccGenericMountEventTrack, MccGenericMountStateInit>,
+        //                             std::pair<MccGenericMountEventGuiding, MccGenericMountStateInit>>;
 
         template <std::derived_from<MccGenericMountBaseEvent> EvT>
         void exit(EvT& event)
@@ -309,6 +304,153 @@ public:
         }
     };
 
+    struct MccGenericMountStateIDLE : MccGenericMountBaseState {
+        using transition_t =
+            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>,
+                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
+                                        std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
+                                        std::pair<MccGenericMountEventSlew, MccGenericMountStateSlew>,
+                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void exit(EvT& event)
+        {
+            this->exitLog(event);
+        }
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void enter(EvT& event)
+        {
+            this->enterLog(event);
+        }
+    };
+
+
+    struct MccGenericMountStateStopping : MccGenericMountBaseState {
+        using transition_t =
+            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
+                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>>;
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void exit(EvT& event)
+        {
+            this->exitLog(event);
+        }
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void enter(EvT& event)
+        {
+            this->enterLog(event);
+
+            error_t err = event.mount()._stopMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            } else {
+                event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()});
+            }
+        }
+    };
+
+
+    struct MccGenericMountStateSlew : MccGenericMountBaseState {
+        using transition_t =
+            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
+                                        std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
+                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
+                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void exit(EvT& event)
+        {
+            error_t err = event.mount()._stopSlewingMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            }
+
+            this->exitLog(event);
+        }
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void enter(EvT& event)
+        {
+            this->enterLog(event);
+
+            error_t err = event.mount()._slewMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            } else {
+                auto slew_pars = event.mount().getSlewingParams();
+
+                if (slew_pars.slewAndStop) {
+                    event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()});
+                } else {
+                    event.mount().dispatchEvent(MccGenericMountEventTrack{event.mount()});
+                }
+            }
+        }
+    };
+
+
+    struct MccGenericMountStateTrack : MccGenericMountBaseState {
+        using transition_t =
+            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
+                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
+                                        std::pair<MccGenericMountEventGuiding, MccGenericMountStateGuiding>>;
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void exit(EvT& event)
+        {
+            error_t err = event.mount()._stopTrackingMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            }
+
+            this->exitLog(event);
+        }
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void enter(EvT& event)
+        {
+            this->enterLog(event);
+
+            error_t err = event.mount()._trackMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            }
+        }
+    };
+
+
+    struct MccGenericMountStateGuiding : MccGenericMountBaseState {
+        using transition_t =
+            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
+                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
+                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void exit(EvT& event)
+        {
+            error_t err = event.mount()._stopGuidingMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            }
+
+            this->exitLog(event);
+        }
+
+        template <std::derived_from<MccGenericMountBaseEvent> EvT>
+        void enter(EvT& event)
+        {
+            this->enterLog(event);
+
+            error_t err = event.mount()._startGuidingMount();
+            if (err) {
+                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
+            }
+        }
+    };
+
+
     /*  CONSTRUCTORS AND DESTRUCTOR  */
 
     MccGenericMountFSM(HardwareT hardware,
@@ -332,17 +474,48 @@ public:
 
     virtual ~MccGenericMountFSM() = default;
 
+    // reimplementation of base-class methods to adapt it to FSM-behavior
     auto initMount()
     {
         this->dispatchEvent(MccGenericMountEventInit{*this});
     }
 
-
     auto stopMount()
     {
         this->dispatchEvent(MccGenericMountEventStop{*this});
     }
 
+    auto slewToTarget()
+    {
+        this->dispatchEvent(MccGenericMountEventSlew{*this});
+    }
+
+    auto stopSlewing()
+    {
+        this->dispatchEvent(MccGenericMountEventStop{*this});
+    }
+
+    auto trackTarget()
+    {
+        this->dispatchEvent(MccGenericMountEventTrack{*this});
+    }
+
+
+    auto stopTracking()
+    {
+        this->dispatchEvent(MccGenericMountEventIDLE{*this});
+    }
+
+    auto startGuidingTarget()
+    {
+        this->dispatchEvent(MccGenericMountEventGuiding{*this});
+    }
+
+    auto stopGuidingTarget()
+    {
+        this->dispatchEvent(MccGenericMountEventTrack{*this});
+    }
+
 protected:
     // wrappers
 
@@ -356,6 +529,28 @@ protected:
     {
         return base_gmount_t::stopMount();
     }
+
+    auto _slewToTarget()
+    {
+        return base_gmount_t::slewToTarget();
+    }
+
+
+    auto _trackTarget()
+    {
+        return base_gmount_t::trackTarget();
+    }
+
+
+    auto _startGuidingTarget()
+    {
+        return base_gmount_t::startGuidingTarget();
+    }
+
+    auto _stopGuidingTarget()
+    {
+        return base_gmount_t::stopGuidingTarget();
+    }
 };