64060072

Date: 2020-09-25 09:00:53
Score: 6
Natty:
Report link

I modified the code above from Torxed example as want a multi-threading python3 server. I'm still learning Python so am getting a little stuck.

I've got 2 threads working where the 1st (a background) thread sends a UDP broadcast to inform clients that the source host (the python server) is waiting for client connections.

The client detects the UDP broadcast (on port 1300) & initiates a new TCP session to port 1200. I have got the python server to immediately send some bytes (bytes as not ascii) to the client which 'asks' the client to identity itself upon connection (the client does not initiate the conversation other than establishing the TCP session). In this case the client host is a solar inverter.

The client responds with some basics such as it's serial number, software version, etc which I want to store. Currently I'm not able to store the reply in a variable as it's byte sequence, not ascii so I'm currently writing the datagram to a local file until I figure out how to unpack the byte sequence & save in variables associated to the client session. This will be used to aid identifying which data-set is associated to which client.

Every 15 seconds after that, I want the python server to send some more bytes (again bytes not ascii) which will inform the client to reply with some PV (solar) data.

The client will reply with the PV data which I want to store associated to the client session.

Lastly if an event occurs on the client (inverter such as AC loss power) it will send to the server another datagram in the established TCP session a specifically formatted byte sequence so the server needs to handle an independent response from the client which will be to initiate sending an email (to me) containing the event type. Is it better to use a single recv datagram handler with something like a case statement to identify the response then process it accordingly (but the server must first receive the client's id).

I want the TCP session to remain open indefinitely but also support a 2nd inverter to connect too & allow them should connectivity is temporally interpreted to re-connection without issue.

Any help appreciated as I'm stuck with being unable to read the response from the client.

Here is what I currently have:

#!/usr/bin/env python3

# need threading support to run broadcast UDP 1300 thread
from threading import *

from socket import *

# import time for sleep/delay timers
import time

# Now we can create socket object
serversocket = socket(AF_INET, SOCK_STREAM)
#serversocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
#serversocket.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

# Set the IP address and port to listen on
HOST = "192.168.1.11"
PORT = 1200

# Bind the socket on the interface/port
serversocket.bind((HOST, PORT))

# This is the client thread allowing multiple clients to connect
class client(Thread):
    # This section is what will run in the background
    def background():
        while True:
            cs.sendto(b'\x55\xaa\x00\x40\x02\x00\x0b\x49\x20\x41\x4d\x20\x53\x45\x52\x56\x45\x52\x04\x3a', ("192.168.1.255", 1301))
            time.sleep(5)

    # This section is what will run in the foreground
    def __init__(self, socket, address):
        Thread.__init__(self)
        self.sock = socket
        self.addr = address
        self.start()
    def run(self):
        while True:
            msg = (b'\x55\xaa\x01\x03\x02\x00\x00\x01\x05')
            self.sock.send(msg)
            
            #Open recv.txt file in write mode
            recvdatafile1 = open("recv1.txt", "wb") 
            print("Destination file name will be recv1.txt on the server\n")
            
            # Receive intiate data from client side
            # RecvData = self.sock.recv(1024)
            while True:
                recvdatafile1.write(RecvData)
                # recvdatafile1.write(self.sock.recv(1024))
                RecvData = self.sock.recv(1024)
                
                # Request initial configuration information (replies with S/N, model number, etc
                #msg = (b'\x55\xaa\x01\x03\x02\x00\x00\x01\x05')
                #conn.send(msg)
                
                # Close the file opened at server side once copy is completed
                recvdatafile1.close()
                print("\n File has been copied successfully \n")
                
                #Open recv.txt file in write mode
                recvdatafile2 = open("recv2.txt", "wb") 
                print("Destination file name will be recv2.txt on the server\n")
                
                # Request PV data
                msg = (b'\x55\xaa\x01\x02\x02\x00\x00\x01\x04')
                conn.send(msg)
                
                # Receive any data from client side
                RecvData = conn.recv(1024)
                while RecvData:
                    recvdatafile2.write(RecvData)
                    RecvData = conn.recv(1024)
                    
                # Close the file opened at server side once copy is completed
                recvdatafile2.close()
                print("\n File has been copied successfully \n")
                
                # Close connection with client
                conn.close()
                print("\n Server closed the connection \n")
                
            time.sleep(3)

            # Come out from the infinite while loop as the file has been copied from client.
            #break


serversocket.listen(5)
print("Server is listing on port:", PORT, "\n")

while 1:
    clientsocket, address = serversocket.accept()
    client(clientsocket, address)
    print ("connection found!")
    data = clientsocket.recv(1024).decode()
    print (data)

b = threading.Thread(name='background', target=background)
f = threading.Thread(name='foreground', target=foreground)

b.start()
f.start()

Server Output:

user@server:~# python3 ./Samil_Solar_River_Monitor_Server.py
Server is listing on port: 1200 

connection found!
Destination file name will be recv1.txt on the server

Exception in thread Thread-1:
Traceback (most recent call last):
  File "/usr/lib/python3.6/threading.py", line 916, in _bootstrap_inner
    self.run()
  File "./Samil_Solar_River_Monitor_Server.py", line 62, in run
    recvdatafile1.write(RecvData)
UnboundLocalError: local variable 'RecvData' referenced before assignment

Traceback (most recent call last):
  File "./Samil_Solar_River_Monitor_Server.py", line 109, in <module>
    data = clientsocket.recv(1024).decode()
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xaa in position 1: invalid start byte
user@server:~# 

Client Output:

user@client:~$ python3 test-solar-client.py 192.168.1.11

################## Below rcved from srv ################## 
 b'U\xaa\x01\x03\x02\x00\x00\x01\x05'      <-- This is good/correct

################## Below rcved from srv ################## 
 b''                                       <-- this & below appears when traceback on server occurs
Traceback (most recent call last):
  File "test-solar-client.py", line 47, in <module>
    s.send(SendData)
BrokenPipeError: [Errno 32] Broken pipe
user@client:~$ 
Reasons:
  • Blacklisted phrase (1): appreciated
  • Blacklisted phrase (1): Any help
  • RegEx Blacklisted phrase (1.5): I'm stuck
  • RegEx Blacklisted phrase (3): Any help appreciated
  • Long answer (-1):
  • Has code block (-0.5):
  • Low reputation (1):
Posted by: fireblade-au