Raspberry pi - Python - Serwer TCP

W tym poście przedstawię w jaki sposób wykonać serwer TCP na Raspberry Pi w Pythonie.

[Źródło: https://www.element14.com/community/community/raspberry-pi]

Aplikacja została napisana bezpośrednio w Pythonie. Przy wykorzystaniu standardowych bibliotek. W związku z tym projekt można bez problemów przenieść na inny system czy komputer.

Kod programu:

Poniżej będą się znajdowały dwa rozwiązania do projektu. Pierwszy z nich jest dosyć prosty opiera się na funkcji akceptującej połączenie, drugi natomiast ma zdefiniowane stany połączenia oraz przygotowaną osobną klasę do nawiązywania komunikacji.

Rozwiązanie 1:

1. def procesTCP():
2.     import socket
3.     import select
4.     import sys
5.     import os
6.     import threading
8.     TCP_IP = "192.254.168.2"
9.     s = None;
10.     TCP_PORT = 1025
11.     BUFFER_SIZE = 1024
13.     while 1:
14.         s= socket.socket(socket.AF_INET, socket.SOCK_STREAM)
15.         s.bind((TCP_IP, TCP_PORT))
16.         s.listen(5)
17.         conn, addr = s.accept()
19.         print("Connection open")
20.         while 1:
21.             data = conn.recv(BUFFER_SIZE)
22.             if not data: break
23.             print("recivecede")
24.             conn.send(data)
25.         conn.close()
26.         print("connectionClose")

Funkcja na początku dodaje potrzebne biblioteki, następnie definiuje adres IP serwera, port TCP oraz rozmiar buforu. Cała obsługa połączenia odbywa się w dwóch pętlach while.

Pierwsza instrukcja w pętli while tworzy gniazdo TCP/IP. Następnie poprzez instrukcję bind() tworzone jest połączenie gniazda z adresem serwera oraz portem.

Wywołanie funkcji listen() ustawia gniazdo w opcji serwera. Instrukcja accept() oczekuje na połączenie.

Kolejna pętla while zawiera obsługę odbierania oraz przesyłania danych do klienta.

Rozwiązanie 2:

Drugie rozwiązanie korzysta z tych samych metod co pierwsze. Różnica polega na przechodzeniu pomiędzy różnymi stanami połączenia.

Poniżej znajduje się klasa przechowująca możliwe stany połączenia w jakich serwer będzie się znajdował.

1. class STATUS:
2.     INIT = 1
3.     CONNECT = 2
4.     WAIT = 3

Poniżej klasa zawierająca informacje o adresie ip, porcie oraz rozmiar bufora:

1. class NetworkConfig:
2.     ADRES_TCP = "196.254.28.45"
3.     PORT_TCP = 1025
4.     BUFFER_SIZE = 1024

Teraz główna funkcja tworząca połączenie oraz obsługująca odebrane dane:

1. class ServerTCP:
2.     def __init__(self):
3.         self.connection = STATUS.INIT
4.         self.server = None
5.         self.client = 0
6.         self.data = []
7.         self.client_address = 0
8.         self.start = 0
9.         self.end = 0
11.     def __call__(self):
12.         while True:
13.             if self.connection == STATUS.CONNECT:
14.                 try:
15.                     self.data = self.client.recv(NetworkConfig.BUFFER_SIZE)
16.                 except:
17.                     self.connection = STATUS.CONNECT
19.                 if self.data:
20.                     response = self.data
21.                     try:
22.                         self.client.send(response)
23.                     except:
24.                         self.connection = STATUS.CONNECT
25.                 else:
26.                     self.connection = STATUS.WAIT
28.             elif self.connection==STATUS.INIT:
29.                 try:
30.                     self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
31.                     self.server.bind((NetworkConfig.ADRES_TCP, NetworkConfig.PORT_TCP))
32.                     self.connection = STATUS.WAIT
33.                 except:
34.                     self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
36.             elif self.connection==STATUS.WAIT:
37.                 try:
38.                     self.server.listen(5)
39.                     self.client, self.client_address = self.server.accept()
40.                     self.connection = STATUS.CONNECT
41.                 except:
42.                     self.client.close()
43.                     self.server.close()
44.                     self.connection = STATUS.INIT

Obie funkcje można wywołać w osobnym procesie:

1. multiProcesJobs = []
3. try:
4.     serProces = multiprocessing.Process(target=ServerTCP(), args=())
5.     multiProcesJobs.append(serProces)
6.     serProces.start()
7. except:
8.     print("SERVER PROCESS ERROR!!")