NEW general cmd format ok : "set_radec 20 45", "set_state active", ...

Etienne Pallier
1 parent 1c5910c6
Showing 9 changed files with 207 additions and 164 deletions Show diff stats
src/core/pyros_django/agent/Agent.py
src/core/pyros_django/agent/AgentDevice.py
src/core/pyros_django/agent/AgentDeviceTelescopeGemini.py
src/core/pyros_django/agent/AgentMultiRequester.py
src/core/pyros_django/agent/doc/Agent_activity_diag.pu
src/core/pyros_django/common/models.py
src/device_controller/abstract_component/base.py
src/device_controller/abstract_component/telescope.py
src/device_controller/concrete_component/gemini/client_telescope_gemini_controller_run.py
@@ -232,29 +232,29 @@ class Agent:
     # Default scenario to be executed
     #TEST_COMMANDS = iter([
     TEST_COMMANDS_LIST = [
-        "go_active",
-        "go_idle",
+        "set_state:active",
+        "set_state:idle",
  
         # specific0 not_executed_because_idle
         "specific0",
  
-        "go_active",
+        "set_state:active",
  
         # specific1 executed_because_not_idle, should complete ok
         "specific1",
  
         # specific2 will be executed only when specific1 is finished,
         # and should be aborted before end of execution,
-        # because of the 1st coming "abort" command below
+        # because of the 1st coming "do_abort" command below
         "specific2",
  
         # specific3 should be executed only when specific2 is finished (in fact, aborted),
         # and should be aborted before end of execution,
-        # because of the 2nd coming "abort" command below
+        # because of the 2nd coming "do_abort" command below
         "specific3",
  
         # These commands should not have the time to be processed
-        # because the "exit" command below should be executed before
+        # because the "do_exit" command below should be executed before
         "specific4",
         "specific5",
         "specific6",
@@ -263,22 +263,22 @@ class Agent:
  
         # Should abort the current running command (which should normally be specific2)
         # even if commands above (specific3, ..., specific8) are already pending
-        "abort",
+        "do_abort",
  
         # These commands (except abort) won't be executed
         # because too many commands are already pending (above)
         "specific9",
-        "abort",
-        "go_active",
-        "go_idle",
+        "do_abort",
+        "set_state:active",
+        "set_state:idle",
  
         # Should stop the agent even before the previous pending commands are executed
-        "exit",
+        "do_exit",
  
-        # Because of the previous "exit" command,
+        # Because of the previous "do_exit" command,
         # these following commands should not be executed,
         # and not even be added to the database command table
-        "go_active",
+        "set_state:active",
         "specific10"
     ]
     #TEST_COMMANDS = iter(TEST_COMMANDS_LIST)
@@ -354,7 +354,7 @@ class Agent:
     _computer_description = ''
  
     # Current and next command to send
-    cmdts = None
+    cmdts:Command = None
     next_cmdts = None
  
     _agent_survey = None
@@ -404,13 +404,13 @@ class Agent:
             raise Exception(f"Bad config file name '{config_filename}', error {str(self.config.get_last_errno())}: {str(self.config.get_last_errmsg())}")
  
         #TODO: : à mettre dans la config
+        '''
+        'AgentDeviceTelescope1': 'AgentDeviceTelescopeGemini',
+        'AgentDeviceFilterSelector1': 'AgentDeviceSBIG',
+        'AgentDeviceShutter1': 'AgentDeviceSBIG',
+        'AgentDeviceSensor1': 'AgentDeviceSBIG',
+        '''
         self._my_client_agents = {
-            '''
-            'AgentDeviceTelescope1': 'AgentDeviceTelescopeGemini',
-            'AgentDeviceFilterSelector1': 'AgentDeviceSBIG',
-            'AgentDeviceShutter1': 'AgentDeviceSBIG',
-            'AgentDeviceSensor1': 'AgentDeviceSBIG',
-            '''
         }
  
         ### self._agent_logs = AgentLogs.objects.create(name=self.name, message="Step __init__")
@@ -473,6 +473,7 @@ class Agent:
             time.sleep(nbsec)
  
     def _get_real_agent_name_for_alias(self, agent_alias_name:str):
+        #print("key is", agent_alias_name)
         if not self._my_client_agents: return agent_alias_name
         return self._my_client_agents[agent_alias_name]
  
@@ -512,7 +513,7 @@ class Agent:
             # Main loop
             while self.DO_MAIN_LOOP:
                 try:
-                    self.main_loop(nb_iter,FOR_REAL)
+                    self._main_loop(nb_iter,FOR_REAL)
                     if not self.DO_MAIN_LOOP: break
                 except KeyboardInterrupt:
                     # In case of CTRL-C, kill the current thread (process) before dying (in error)
@@ -522,7 +523,7 @@ class Agent:
             #if self.DO_EXIT: exit(0)
  
  
-    def main_loop(self, nb_iter:int=None, FOR_REAL:bool=True):
+    def _main_loop(self, nb_iter:int=None, FOR_REAL:bool=True):
  
         # Bad number of iterations, so exit
         if nb_iter is not None:
@@ -572,10 +573,10 @@ class Agent:
         cmd = self.get_next_valid_and_not_running_command()
         #if cmd: self.command_process(cmd)
         if cmd:
-            # GENERIC cmd : execute it always
-            if cmd.is_generic():
-                self.exec_generic_cmd(cmd)
-            # SPECIFIC cmd : execute it only if active and no currently running specific cmd
+            # GENERAL cmd (agent level) : execute it always
+            if cmd.is_general():
+                self.exec_general_cmd(cmd)
+            # SPECIFIC cmd (agent specific or device level) : execute it only if active and no currently running specific cmd
             else:
                 self.exec_specific_cmd_if_possible(cmd)
  
@@ -878,12 +879,13 @@ class Agent:
         self.print("Current pending commands are (time ordered) :")
         Command.show_commands(commands)
  
-        # 2) If there is a "exit" or "abort" command pending (even at the end of the list),
+        # 2) If there is a "do_exit" or "do_abort" command pending (even at the end of the list),
         # which is VALID (not expired),
         # then pass it straight away to general_process() for execution
         for cmd in commands:
-            if cmd.name in ("exit", "abort", "flush_commands"): break
-        if cmd.name in ("exit", "abort", "flush_commands"):
+            #if cmd.name in ("do_exit", "do_abort", "do_flush_commands"): break
+            if cmd.name in ("do_exit", "do_abort", "do_flush_commands"): break
+        if cmd.name in ("do_exit", "do_abort", "do_flush_commands"):
             if cmd.is_running():
                 return None
             if cmd.is_expired():
@@ -944,72 +946,7 @@ class Agent:
         return cmd
  
  
-    def AVIRER_command_process(self, cmd:Command)->Command:
-        assert cmd is not None
-        cmd = self.general_process(cmd)
-        # Sub-level loop (only if ACTIVE)
-        if cmd and self.is_active():
-            self.specific_process(cmd)
-
-
-    def AVIRER_general_process(self, cmd:Command)->Command:
-        assert cmd is not None
-
-        self.set_status(self.STATUS_GENERAL_PROCESS)
-        self.print("***")
-        self.print("*** RECEIVED", cmd)
-        self.print("***")
-        self.printd(f"Starting general processing of this command")
-
-        # Update read time to say that the command has been READ
-        cmd.set_read_time()
-        # Precondition: command cmd is valid (not expired), has already been read, is pending
-        assert (not cmd.is_expired()) and cmd.is_pending() and cmd.is_read() 
-
-        #self.printd(f"Starting general processing of command {cmd.name} sent by agent {cmd.sender} at {cmd.sender_deposit_time}")
-
-        """
-        # 2) If expired command, change its status to expired and return
-        if cmd.is_expired():
-            self.printd("This command is expired, so mark it as such, and ignore it")
-            cmd.set_as_outofdate()
-            return None
-        """
-
-        # If cmd is generic, execute it, change its status to executed, and return
-        if cmd.is_generic():
-            self.print("This command is generic, execute it...")
-            self.exec_generic_cmd(cmd)
-            # If cmd is "exit", kill myself (without any question, this is an order soldier !)
-            # This "exit" should normally kill any current thread (to be checked...)
-            if cmd.name == "exit":
-                self.printd("(before exiting) Here are the current (still) pending commands (time ordered) :")
-                commands = Command.get_pending_and_running_commands_for_agent(self.name)
-                Command.show_commands(commands)
-                #if self.TEST_MODE and self.TEST_WITH_FINAL_TEST and self.TEST_COMMANDS_DEST == "myself": self.simulator_test_results()
-                if self.TEST_MODE and self.TEST_WITH_FINAL_TEST: self.simulator_test_results()
-                #self.DO_EXIT=True
-                #exit(0)
-            # Command is executed, so return None
-            return None
-
-        # cmd is not generic
-        else:
-            # cmd is not generic but, as I am idle, change its status to SKIPPED, ignore it, and return
-            #if self.mode == self.MODE_IDLE:
-            if self.is_idle():
-                self.printd("This command is not generic but, as I am IDLE, I mark it SKIPPED and ignore it")
-                cmd.set_as_skipped()
-                return None
-
-        # Je suis pas idle et cde pas générique: je la traite pas, elle sera traitée par core_process :
-        # attendre que cette commande soit exécutée avant de passer à la commande suivante (situation “bloquante” normale)
-        self.printd("This command is not generic and, as I am not IDLE, I pass it to the specific processing")
-        self.printd("(then I will not execute any other new command until this command is EXECUTED)")
-        return cmd
-
-
-    def exec_generic_cmd(self, cmd:Command):
+    def exec_general_cmd(self, cmd:Command):
  
         self.printd(f"Starting execution of a GENERIC cmd {cmd}")
  
@@ -1018,43 +955,50 @@ class Agent:
         cmd.set_as_running()
  
         # Executing command
-        if cmd.name == "go_active":
-            self.set_active()
-            cmd.set_result("I am now active")
-            time.sleep(1)
-        elif cmd.name == "go_idle":
-            self.set_idle()
-            cmd.set_result("I am now idle")
+        cmd_name, cmd_args = cmd.tokenize()
+        #if cmd.name == "set_state:active":
+        #elif cmd.name == "set_state:idle":
+        if cmd_name == "set_state":
+            if not cmd_args: raise(ValueError)
+            state = cmd_args[0]
+            if state == "active": self.set_active()
+            if state == "idle": self.set_idle()
+            cmd.set_result("I am now " + state)
             time.sleep(1)
-        elif cmd.name in ("flush_commands"):
+        elif cmd.name in ("do_flush_commands"):
             self.print("flush_commands received: Delete all pending commands")
             Command.delete_pending_commands_for_agent(self.name)
             cmd.set_result('DONE')
-        elif cmd.name in ("abort", "exit", "restart_init"):
+        elif cmd.name in ("do_abort", "do_exit", "do_restart_init"):
             #self.printd("Current pending commands are:")
             #Command.show_commands(self._pending_commands)
             self.print("Aborting current executing command if exists:")
             self.kill_running_specific_cmd_if_exists(cmd.sender)
-            if cmd.name == "restart_init":
+            if cmd.name == "do_restart_init":
                 self.print("restart_init received: Restarting from init()")
                 self.DO_RESTART=True
-            elif cmd.name == "exit":
+            elif cmd.name == "do_exit":
                 self.DO_EXIT=True
             cmd.set_result('SHOULD BE DONE NOW')
         else:
+            '''
             name = cmd.name
             args = None
             if " " in name: name,args = name.split()
-            if name == "eval":
+            if name == "do_eval":
                 if args==None: raise(ValueError)
                 cmd.set_result(eval(args))
+            '''
+            if cmd_name == "do_eval":
+                if not cmd_args: raise(ValueError)
+                cmd.set_result(eval(cmd_args))
  
         cmd.set_as_processed()
         self.printd("...Generic cmd has been executed")
  
-        # If cmd is "exit", kill myself (without any question, this is an order soldier !)
-        # This "exit" should normally kill any current thread (to be checked...)
-        if cmd.name == "exit":
+        # If cmd is "do_exit", kill myself (without any question, this is an order soldier !)
+        # This "do_exit" should normally kill any current thread (to be checked...)
+        if cmd.name == "do_exit":
             self.printd("(before exiting) Here are the current (still) pending commands (time ordered) :")
             commands = Command.get_pending_and_running_commands_for_agent(self.name)
             Command.show_commands(commands)
@@ -1170,15 +1114,15 @@ class Agent:
         cmd = next(self.TEST_COMMANDS, None)
         #return cmd_name
         if cmd is None: return None
-        agent_recipient,cmd_name = cmd.split(':')
+        agent_recipient,cmd_name = cmd.split(' ', 1)
         ##recipient_agent = self.name if self.TEST_COMMANDS_DEST=="myself" else self.TEST_COMMANDS_DEST
         #return Command(sender=self.name, recipient=recipient_agent, name=cmd_name)
         return self.build_cmd(agent_recipient, cmd_name)
  
     """
     def simulator_send_next_command(self):
-        #self._current_test_cmd = "go_idle" if self._current_test_cmd=="go_active" else "go_active"
-        #if self._nb_test_cmds == 4: self._current_test_cmd = "exit"
+        #self._current_test_cmd = "set_state:idle" if self._current_test_cmd=="set_state:active" else "set_state:active"
+        #if self._nb_test_cmds == 4: self._current_test_cmd = "do_exit"
         cmd_name = next(self.TEST_COMMANDS, None)
         #self.printd("next cmd is ", cmd_name)
         if cmd_name is None: return
@@ -1196,17 +1140,17 @@ class Agent:
         """
  
         # There is a current command being processed 
-        # => check if next command is "abort"
-        # => if so, instantly send an "abort" to abort previous command
+        # => check if next command is "do_abort"
+        # => if so, instantly send an "do_abort" to abort previous command
         if self.cmdts is not None:
-            self.print(f"Waiting for end of cmd '{self.cmdts.name}' execution...")
+            self.print(f"Waiting for end execution of cmd '{self.cmdts.name}' (sent to {self.cmdts.recipient}) ...")
             # Update cmdts fields from DB
             self.cmdts.refresh_from_db()
             if self.cmdts.is_pending() or self.cmdts.is_running():
                 if self.next_cmdts is None:
-                    # If next command is "abort" then abort becomes the new current command (to be sent)
+                    # If next command is "do_abort" then abort becomes the new current command (to be sent)
                     self.next_cmdts = self.simulator_get_next_command_to_send()
-                    if self.next_cmdts and self.next_cmdts.name == "abort":
+                    if self.next_cmdts and self.next_cmdts.name == "do_abort":
                         # Wait a little to give a chance to agentB to start execution of current command,
                         # so that we can abort it then (otherwise it won't be aborted!!)
                         time.sleep(4)
@@ -1304,10 +1248,10 @@ class Agent:
                 assert cmd.is_pending()
                 nb_asserted+=1
             # 2 cmds abort
-            if cmd.name in ("abort"):
+            if cmd.name in ("do_abort"):
                 assert cmd.is_executed()
                 nb_asserted+=1
-            if cmd.name in ("exit"):
+            if cmd.name in ("do_exit"):
                 assert cmd.is_executed()
                 nb_asserted+=1
         assert nb_asserted == 12
@@ -237,6 +237,7 @@ class AgentDevice(Agent):
     # Define your own command step(s) here
     def cmd_step(self, step:int):
         cmd = self._current_specific_cmd
+        print("cmd name is", cmd.name)
         res = self._device_ctrl.execute_cmd(cmd.name)
         cmd.set_result(str(res))
         print("result is", str(res))
@@ -134,21 +134,24 @@ class AgentDeviceTelescopeGemini(AgentDevice):
     # @Override
     def get_device_status(self):
  
-        cmd="get date"
+        #cmd="get date"
+        cmd="get_date"
         res = self._device_ctrl.execute_cmd(cmd)
         self.printd("result is", str(res))
         if res.ok: print("OK")
         dev_date = str(res)
         time.sleep(1)
  
-        cmd="get time"
+        #cmd="get time"
+        cmd="get_time"
         res = self._device_ctrl.execute_cmd(cmd)
         self.printd("result is", str(res))
         if res.ok: print("OK")
         dev_time = str(res)
         time.sleep(1)
  
-        cmd="get radec"
+        #cmd="get radec"
+        cmd="get_radec"
         res = self._device_ctrl.execute_cmd(cmd)
         self.printd("result is", str(res))
         if res.ok: print("OK")
@@ -25,9 +25,53 @@ class AgentMultiRequester(Agent):
     # Who should I send commands to ?
     #TEST_COMMANDS_DEST = "myself"
     #TEST_COMMANDS_DEST = "AgentDeviceTelescopeGemini"
+
     # Scenario to be executed
     TEST_COMMANDS_LIST = [
         # Ask receiver to delete all its previous commands 
+        'ad_tele do_flush_commands',
+        ##'ad_filterselect:do_flush_commands',
+        ##'ad_shutter:do_flush_commands',
+        ##'ad_sensor:do_flush_commands',
+
+        #'ad_tele:go_active',
+        'ad_tele set_state active',
+
+        # Because of this command, the receiver agent :
+        # - will no more send any new command
+        # - will only execute "generic" commands (and not the "specific" ones)
+        ##'ad_tele:set_state:idle',
+
+        # Because of this command, the receiver agent(s)
+        # will now be able to send new commands
+        ##'ad_tele:set_state:active',
+        ##'ad_filterselect:set_state:active',
+        ##'ad_shutter:set_state:active',
+        ##'ad_sensor:set_state:active',
+
+        'ad_tele do_init',
+        ##'ad_filterselect:do_init',
+        ##'ad_shutter:do_init',
+        ##'ad_sensor:do_init',
+
+        'ad_tele do_goto_radec 15 20',
+        ##'ad_filterselect:do_goto:3',
+
+        ##'ad_shutter:do_open',
+        ##'ad_sensor:do_acquire:7000',
+        ##'ad_shutter:do_close',
+
+        ##'ad_sensor:do_shutdown'
+
+        # Now stop all my device agent clients:
+        'ad_tele do_exit',
+        ##'ad_filterselect:do_exit',
+        ##'ad_shutter:do_exit',
+        ##'ad_sensor:do_exit',
+    ]
+
+    TEST_COMMANDS_LIST_BASIC = [
+        # Ask receiver to delete all its previous commands 
         'AgentDeviceTelescope1:flush_commands',
         'AgentDeviceFilterSelector1:flush_commands',
         'AgentDeviceShutter1:flush_commands',
@@ -70,7 +114,6 @@ class AgentMultiRequester(Agent):
     ]
  
  
-
     """
     =================================================================
         FUNCTIONS RUN INSIDE MAIN THREAD
@@ -85,11 +128,17 @@ class AgentMultiRequester(Agent):
         super().__init__(config_filename, RUN_IN_THREAD)
  
         #TODO: : à mettre dans la config
+        """
+        'AgentDeviceTelescope1': 'AgentDeviceTelescopeGemini',
+        'AgentDeviceFilterSelector1': 'AgentDeviceSBIG',
+        'AgentDeviceShutter1': 'AgentDeviceSBIG',
+        'AgentDeviceSensor1': 'AgentDeviceSBIG',
+        """
         self._my_client_agents = {
-            'AgentDeviceTelescope1': 'AgentDeviceTelescopeGemini',
-            'AgentDeviceFilterSelector1': 'AgentDeviceSBIG',
-            'AgentDeviceShutter1': 'AgentDeviceSBIG',
-            'AgentDeviceSensor1': 'AgentDeviceSBIG',
+            'ad_tele': 'AgentDeviceTelescopeGemini',
+            'ad_filterselect': 'AgentDeviceSBIG',
+            'ad_shutter': 'AgentDeviceSBIG',
+            'ad_sensor': 'AgentDeviceSBIG',
         }
  
         #self._log.print(f"init done for {self.name}")
@@ -53,13 +53,14 @@ while (DO_RESTART ?) is (yes)
  
             :routine_process();
  
+
             :cmd = get_next_valid_command();
             if (cmd ?) then
-                partition command_process(cmd) {            
-                    :cmd = general_process(cmd);
-                    if (cmd ?) then
-                        :specific_process(cmd);
+                partition command_process(cmd) {         
+                    if (cmd.is_general ?) then
+                    	:exec_general_cmd(cmd);
                     else (no)
+                        :exec_specific_cmd_if_possible(cmd);
                     endif
                     note right
                         only if I am "active"
@@ -67,6 +68,8 @@ while (DO_RESTART ?) is (yes)
                 }
             else (no)
             endif
+
+
             if (DO_RESTART or DO_EXIT ?) then (yes)
                 :DO_MAIN_LOOP = False;
             endif
@@ -424,9 +424,11 @@ class Command(models.Model):
         "CMD_OUTOFDATE" # cde périmée 
     )
     GENERIC_COMMANDS = [
-        "eval", "go_idle", "go_active",
-        # Commands executed in priority (even if other pending commands exist) 
-        "flush_commands", "abort", "exit", "restart_init"
+        #"do_eval", "set_state:idle", "set_state:active",
+        "do_eval", 
+        "set_state",
+        # Commands executed in priority (even if other pending commands exist)
+        "do_flush_commands", "do_abort", "do_exit", "do_restart_init"
     ]
     #COMMANDS_PEREMPTION_HOURS = 48
     COMMANDS_PEREMPTION_HOURS = 60/60
@@ -619,14 +621,23 @@ class Command(models.Model):
         #self.save()
         self.set_as_pending()
  
-    def is_generic(self):
+    def tokenize(self):
+        '''
+        return: self (cmd) name and args
+        '''
+        cmd_name, *cmd_args = self.name.split(' ')
+        return cmd_name, cmd_args
+
+    def is_general(self):
         """
-        Is this a generic command ?
-        It is the case if command is of style "go_idle" or "go_active" or "stop"...
+        Is this a general command ?
+        It is the case if command is of style "do_set:state:idle" or "do_restart" or "do_flush"...
         """
-        name = self.name
-        if " " in name: name,args = name.split()
-        return name in self.GENERIC_COMMANDS
+        ##name = self.name
+        ##if " " in name: name,args = name.split()
+        ##name = self.name.split(' ')[0]
+        cmd_name, _ = self.tokenize()
+        return cmd_name in self.GENERIC_COMMANDS
         #"CMD_OUTOFDATE" # cde périmée 
  
     def is_read(self):
@@ -267,14 +267,15 @@ class DeviceControllerAbstract():
  
  
     def is_generic_cmd(self, raw_input_cmd:str) -> bool:
+        print("raw_input_cmd is", raw_input_cmd)
         # Using Google documentation format (https://www.sphinx-doc.org/en/master/usage/extensions/example_google.html#example-google) 
         """ Is this a generic command ?
  
         Args:
-            raw_input_cmd: a command in raw string format (like 'get ra' or 'set ra 20:00:00' or 'set radec 20:00:00 90:00:00" or 'do park' or 'do_park'...)
+            raw_input_cmd: a command in string format (like 'set_state active' or 'get_ra' or 'set_ra 20:00:00' or 'set_radec 20:00:00 90:00:00" or 'do_park'...)
  
         Returns:
-            either False or (cmd, [values]) with cmd like "get_ra" (using underscore '_' instead of space ' ').
+            either False or (cmd, [args]) with cmd like "get_ra" and [args] like ['20:00:00', '90:00:00']
  
         """
         #return cmd.startswith('get_') or cmd.startswith('set_') or cmd.startswith('do_')
@@ -294,28 +295,41 @@ class DeviceControllerAbstract():
                     return generic_cmd.replace(' ','_'), values
         return False, False
         '''
-        values_to_set = None
-        cmds = ("get","set","do")
+        ##cmds = ("get","set","do")
+
+        '''
+        # ex: "set radec" => "set_radec"
         raw_input_cmd = raw_input_cmd.strip()
         cmd_splitted = raw_input_cmd.split(' ')
         if len(cmd_splitted) == 1: return False,False
-        # ex: "set_radec"
         generic_cmd = cmd_splitted[0] + '_' + cmd_splitted[1]
+        '''
+        # Ex: "set_radec 15 30", "do_init", "get_radec", "set_state active", "do_goto_radec 15 45"...
+        tokens = raw_input_cmd.split(' ')
+        generic_cmd = tokens[0]
+
         # Check this generic command exists    
         #if (generic_cmd not in self._cmd.keys()): return False,False
         if generic_cmd not in self._cmd: return False,False
         # Is there value(s) passed ?
-        if len(cmd_splitted) > 2: values_to_set = cmd_splitted[2:]
+        ###if len(cmd_splitted) > 2: values_to_set = cmd_splitted[2:]
+        args = tokens[1:] if len(tokens)>1 else None
         # ex: return "set_radec", ["20:00:00", "90:00:00"]
-        return generic_cmd, values_to_set
+        return generic_cmd, args
  
  
     def execute_cmd(self, raw_input_cmd:str)->GenericResult:
+        '''
+        :param raw_input_cmd:
+        '''
+        generic_cmd, args = self.is_generic_cmd(raw_input_cmd)
+
         # GENERIC command
-        generic_cmd, values = self.is_generic_cmd(raw_input_cmd)
         if generic_cmd is not False:
-            #print("GENERIC COMMAND")
-            return self.execute_generic_cmd(generic_cmd, values)
+            print("GENERIC COMMAND")
+            return self.execute_generic_cmd(generic_cmd, args)
+
+        # NATIVE command
         else:
             '''
             if cmd.startswith('get_'):
@@ -329,7 +343,7 @@ class DeviceControllerAbstract():
             return
             '''
             # NATIVE command
-            #print("NATIVE COMMAND")
+            print("NATIVE COMMAND")
             res_native = self.execute_native_cmd(raw_input_cmd)
             return GenericResult(res_native)
  
@@ -427,11 +441,14 @@ class DeviceControllerAbstract():
         # Get corresponding native command:
         native_cmd = native_cmd_infos[0]
         if not native_cmd: raise NotImplementedError
-        # ex: native_cmd == "do_init", "get_radec"
+
+        # MACRO-COMMAND (ex: native_cmd == "do_goto", "do_init", "get_radec")
         if native_cmd == generic_cmd:
+            print("MACRO-COMMAND")
             #print("cmd,val", native_cmd, values_to_set)
             #res:GenericResult = self.run_func(native_cmd, *values_to_set)
-            if values_to_set: 
+            if values_to_set:
+                print("with args")
                 res = self.run_func(native_cmd, *values_to_set)
                 #res = getattr(self, native_cmd)(values_to_set)
             else:
@@ -439,12 +456,13 @@ class DeviceControllerAbstract():
                 #res = getattr(self, native_cmd)()
             #if res is None: res = 'ok'
             # res should be a GenericResult
-            if not isinstance(res,GenericResult): raise Exception("Should be a GenericResult", res)
+            if not isinstance(res, GenericResult): raise Exception("Should be a GenericResult", res)
             return res
-        # ex: native_cmd == "GR"
+
+        # NATIVE COMMAND (ex: native_cmd == "GR")
         else:
             native_cmd = self.formated_cmd(native_cmd,values_to_set)
-        
+
         awaited_res_if_ok = None
         if len(native_cmd_infos) > 1: awaited_res_if_ok = native_cmd_infos[1]
         #native_res = self.execute_native_cmd(self.formated_cmd(native_cmd,value), awaited_res_ok)
@@ -109,7 +109,8 @@ class DeviceControllerTelescope(DeviceControllerAbstract):
         # DO commands:
         ##'do_init': ['do_init'],
         ##'do_park': [],
-        'do_goto': [],
+        'do_goto': ['do_goto'],
+        'do_goto_radec': ['do_goto_radec'],
         'do_move': [],
         'do_movenorth': [],
         'do_movesouth': [],
@@ -273,11 +274,15 @@ class DeviceControllerTelescope(DeviceControllerAbstract):
     @generic_cmd
     def do_prec_refr(self): pass        
  
- 
-    
+
     # MACRO generic command
     def do_init(self):
-        
+
+        print("...STARTING TELESCOPE INITIALIZATION...")
+        time.sleep(1)
+        print("...TELESCOPE INITIALIZATION ENDED")
+        return GenericResult("OK")
+
         '''
         1) Send cde ACK ('06') and check answer to see if telescope is ready (see doc page 100)
         (utile pour savoir si tout est ok ; par ex, si une raquette est branchée sur le tele, ça peut bloquer le protocole)
@@ -465,10 +470,18 @@ class DeviceControllerTelescope(DeviceControllerAbstract):
         - radec.goto()
     '''
     # MACRO generic command
+    def do_goto_radec(self, ra, dec, speed_rate=None): return self.do_goto(ra, dec, speed_rate)
     def do_goto(self, ra, dec, speed_rate=None):
  
+        # TODO: remove
+        print("...Starting GOTO...")
+        time.sleep(3)
+        radec = self.get_radec()
+        print("...GOTO ended OK")
+        return GenericResult("OK")
+
         # 1) set speed
-        if speed_rate: self.set_speed(speed_rate)
+        if speed_rate : self.set_speed(speed_rate)
  
         radec = self.get_radec()
         print("Current position is", radec)
@@ -101,12 +101,13 @@ def main():
             #req = input("\n(EXPERT MODE) REQUEST TO SERVER [ex: '6' (ACK), ':GD#' (Get Dec), ':GR#' (Get RA)'], (ENTER to quit): ").strip()
             cmd = input("REQUEST TO SERVER (ENTER to quit): >>> ").strip()
             if not cmd: break
-    
+
+            #res = tele_ctrl.execute_cmd(cmd.replace(' ', '_'))
             res = tele_ctrl.execute_cmd(cmd)
             print("result is", str(res))
             if res.ok: print("OK")
             #print("result.txt is", res.txt)
-            
+
         # END: park telescope    
         ###tele_ctrl.do_PARK()