Debut d'ajout pour protocole TCP.

Alain Klotz
1 parent 05522f81
Showing 1 changed file with 99 additions and 50 deletions Show diff stats
mount_tnc/raspberry/mountchannel.py
 # -*- coding: utf-8 -*-
 import time
 import serial
+import socket
  
 #import RPi.GPIO as io
  
 # #####################################################################
 # #####################################################################
 # #####################################################################
-# Class Astromecca
+# Class Mountchannel for communication clients
 # #####################################################################
 # #####################################################################
 # #####################################################################
@@ -26,6 +27,7 @@ class Mountchannel():
     ERR_CHAN_NOT_OPENED = 205
     ERR_CHAN_PORT_NOT_DEFINED = 206
     ERR_CHAN_EVER_OPENED = 207
+    ERR_CHAN_HOSTNAME_NOT_DEFINED = 208
  
     # --- main communication
     _fid_chan   = None
@@ -55,7 +57,7 @@ class Mountchannel():
         # --- Dico of axis_types and their parameters
         channel_types = {}
         channel_types["SERIAL"]= {"MANDATORY" : {"PORT":[str,"//./COM1"]}, "OPTIONAL" : {"BAUD_RATE":[int,9600]} }
-        #channel_types["ETHERNET"]= {"MANDATORY" : {"PORT":[int,"5000"], "HOSTNAME":[str,"127.0.0.1"]}, "OPTIONAL" : {} }
+        channel_types["TCP"]= {"MANDATORY" : {"PORT":[int,"5000"], "HOSTNAME":[str,"127.0.0.1"]}, "OPTIONAL" : {} }
         # --- 
         argc = len(args)
         # kwargc = len(kwargs)
@@ -136,8 +138,10 @@ class Mountchannel():
         if self._channel_type=="SERIAL":
             self._port_chan = self._channel_params["PORT"]
             self._baud_rate = self._channel_params["BAUD_RATE"]
+        if self._channel_type=="TCL":
+            self._port_chan = self._channel_params["PORT"]
+            self._hostname = self._channel_params["HOSTNAME"]
  
-        
     def _set_port_chan(self, port:str):
         self._port_chan = port
         return self._port_chan
@@ -145,6 +149,13 @@ class Mountchannel():
     def _get_port_chan(self):
         return self._port_chan
  
+    def _set_hostname_chan(self, hostname:str):
+        self._hostname_chan = hostname
+        return self._hostname_chan
+
+    def _get_hostname_chan(self):
+        return self._hostname_chan
+
     def _my_open_chan(self):
         # --- abstract method 
         # --- Please overload it according your language protocol
@@ -181,8 +192,28 @@ class Mountchannel():
                 self._fid_chan = fid
                 time.sleep(self._delay_init_chan)
                 fid.flush()
-        else:
-            pass
+        elif self._channel_type=="TCP":
+            fid = self._fid_chan
+            port  = self._port_chan
+            if self._port_chan == None:
+                err = self.ERR_CHAN_PORT_NOT_DEFINED
+                return (err, fid)
+            hostname  = self._hostname_chan
+            if self._hostname_chan == None:
+                err = self.ERR_CHAN_HOSTNAME_NOT_DEFINED
+                return (err, fid)
+            if self._fid_chan != None:
+                return (err, fid)
+            # --- pass here only if the port was closed
+            try:
+                fid = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                # Connect to server and send data
+                fid.connect((hostname, port))
+            except:
+                err = self.ERR_CHAN_UNKNOWN
+            # --- some inits
+            if err == self.NO_ERROR:
+                self._fid_chan = fid
         err = self._my_open_chan()
         return err, fid       
  
@@ -218,12 +249,16 @@ class Mountchannel():
         err, fid = self.check_chan()
         if err != self.NO_ERROR:
             raise Exception("Error {}".format(err))
-        # --- serial port buffer reset for the next read
-        fid.reset_input_buffer() 
-        # --- serial port is ready to put message
-        cmd = cmd + self._end_of_command_to_send
-        fid.write(cmd.encode())
-        fid.flush()
+        if self._channel_type=="SERIAL":
+            # --- serial port buffer reset for the next read
+            fid.reset_input_buffer() 
+            # --- serial port is ready to put message
+            cmd = cmd + self._end_of_command_to_send
+            fid.write(cmd.encode())
+            fid.flush()
+        elif self._channel_type=="TCP":
+            cmd = cmd + self._end_of_command_to_send
+            fid.sendall(cmd.encode())
         return (err, cmd)
  
     def _read_chan_old(self):
@@ -248,29 +283,39 @@ class Mountchannel():
         err, fid = self.check_chan()
         if err != self.NO_ERROR:
             raise Exception("Error {}".format(err))        
-        # --- serial port is ready to put message
         lignes = "" ; # fid.readlines()
         t0 = time.time()
         dt = 0
         nn = 0
-        while True:
-            n = 0
-            for car in fid.read():
-                n += 1
-                car = chr(car)
-                lignes += car
-                nn = 0
-                t0 = time.time()
-                #print("car={} n={} nn={}".format(car,n,nn))
-            if n==0:
+        if self._channel_type=="SERIAL":
+            while True:
+                n = 0
+                for car in fid.read():
+                    n += 1
+                    car = chr(car)
+                    lignes += car
+                    nn = 0
+                    t0 = time.time()
+                    #print("car={} n={} nn={}".format(car,n,nn))
+                if n==0:
+                    nn += 1
+                    if nn==2:
+                        #print("n={} nn={} Time out".format(n,nn))
+                        break
+                    time.sleep(0.01)
+                dt = time.time()-t0
+                if dt>10.0:
+                    break
+        elif self._channel_type=="TCP":
+            while True:
+                lignes = fid.recv()
                 nn += 1
                 if nn==2:
-                    #print("n={} nn={} Time out".format(n,nn))
                     break
                 time.sleep(0.01)
-            dt = time.time()-t0
-            if dt>10.0:
-                break
+                dt = time.time()-t0
+                if dt>10.0:
+                    break
         #print("dt={} lignes={}".format(dt,lignes))
         # --- format la sortie
         if self._end_of_command_to_receive!="":
@@ -348,30 +393,34 @@ class Mountchannel():
         self.set_channel_params(*args, **kwargs)
         self.verbose_chan = False
  
+# #####################################################################
+# #####################################################################
+# #####################################################################
+# Main
+# #####################################################################
+# #####################################################################
+# #####################################################################
+
 if __name__ == "__main__":
-    """
-    try:
-        chan.close_chan()
-    except:
-        pass
-    """
-    port_serial_ascom='//./com10'
+
+    example = 2
+    print("Example       = {}".format(example))
  
-    if False:
-        chan = Mountchannel("SERIAL", port=port_serial_ascom, baud_rate=9600, delay_init_chan=0.1, end_of_command_to_send="".encode('utf8'), end_of_command_to_receive="#".encode('utf8'), delay_put_read=0.06)
-        s = chan.putread_chan("READ_RA")
-        print(s)
+    if example == 1:
+        port_serial_ascom='//./com8'
+        
+        chan = Mountchannel("SERIAL", port=port_serial_ascom, baud_rate=115200, delay_init_chan=0.1, end_of_command_to_send="#".encode('utf8'), end_of_command_to_receive="#".encode('utf8'), delay_put_read=0.06)
+        err, res = chan.putread_chan("READ_RA",0)
+        if err == chan.NO_ERROR:
+            print(res)
+        else:
+            print("Error code={}. {}".format(err,res))
+        chan.close_chan()
+
+    if example == 2:
+        port = 80
+        hostname = "http://www.google.com"
+        
+        chan = Mountchannel("TCP", port=port, hostname=hostname, delay_init_chan=0.1, end_of_command_to_send="".encode('utf8'), end_of_command_to_receive="".encode('utf8'), delay_put_read=0.2)
+        err, fid = chan.open_chan()
         chan.close_chan()
-    else:
-        fid = serial.Serial(
-           port=port_serial_ascom,
-           baudrate = 9600,
-           parity = serial.PARITY_NONE,
-           stopbits = serial.STOPBITS_ONE,
-           bytesize = serial.EIGHTBITS,
-           timeout = 0
-        )
-        cmd = "READ_RA"
-        fid.write(cmd.encode())
-        fid.flush()
-        fid.close()