Rapport Théorique : Projet de Calculateur en
Réseau (serveur-client) :
Réalisé par Ahmed Ben Kilani RT2-2 et
Mohamed Ali Beltif RT2-1
Rapport Théorique : Projet de Calculateur en Réseau
Ce projet a été réalisé dans le but de mettre en place une communication réseau de type
client-serveur
permettant l’échange de données sous forme de structures JSON. L’application permet à un
client d’envoyer
une requête de calcul mathématique au serveur, qui la traite et retourne le résultat.
1. Identification des adresses IP
L’utilisateur a commencé par identifier les adresses IP de son PC et de son téléphone afin de
savoir
s’ils étaient dans le même réseau local. En utilisant la commande `ipconfig` sur Windows et
`ip a` via Termux,
il a pu vérifier que les deux appareils partageaient le même sous-réseau (par exemple
192.168.218.X).
2. Établissement d’une connexion Peer-to-Peer
Une fois la connexion hotspot activée, une communication en peer-to-peer a été établie à
l’aide de sockets Python.
Le PC agit comme serveur avec l’adresse `0.0.0.0` pour accepter toutes les connexions, et le
client (le téléphone)
se connecte à l’adresse IP locale du PC.
3. Échange de messages texte
Un script de base a été mis en place pour permettre au serveur de recevoir des messages
texte et d’y répondre,
en utilisant les fonctions `recv()` et `send()`. Le serveur écoute sur un port donné (ex: 5001)
et attend la
connexion du client.
4. Extension du projet : Calculateur réseau
Le projet a évolué vers une application de calcul distribué. Le client envoie une structure
JSON contenant :
- une opération (`+`, `-`, `*`, `/`)
- deux opérandes `a` et `b`
- un champ `res` initialement vide
Le serveur reçoit cette structure, la traite via une fonction Python, puis retourne la même
structure avec le
résultat calculé ou une erreur si l'opération est invalide.
5. Utilisation de JSON
JSON (JavaScript Object Notation) a été utilisé pour encoder/décoder les structures de
données échangées.
C’est un format léger, lisible et facilement manipulable en Python grâce au module `json`.
Exemple :
Structure envoyée par le client :
{
"op": "+",
"a": 5,
"b": 3,
"res": null
}
6. Fonction de traitement côté serveur
La fonction `traiter` suivante permet de calculer le résultat à partir de la structure JSON
reçue :
def traiter(S):
op = S["op"]
a = S["a"]
b = S["b"]
if op == "+":
S["res"] = a + b
elif op == "-":
S["res"] = a - b
elif op == "*":
S["res"] = a * b
elif op == "/":
S["res"] = a / b if b != 0 else "Erreur: division par zéro"
else:
S["res"] = "Opération invalide"
return S
7. code côté serveur
import socket
import json
# --- Setup socket serveur ---
HOST = '0.0.0.0'
PORT = 5001
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen(1)
print(f" En attente d'une connexion sur le port {PORT}...")
conn, addr = server_socket.accept()
print(f" Connecté à {addr}")
# --- Boucle de traitement ---
while True:
data = conn.recv(1024).decode()
if not data:
break
try:
S = json.loads(data)
print(f"Reçu : {S}")
S = traiter(S)
except Exception as e:
S = {"res": f"Erreur de traitement: {str(e)}"}
response = json.dumps(S)
conn.send(response.encode())
conn.close()
print("Connexion fermée")
8. code côté Client
import socket
import json
# --- Setup socket client ---
HOST = '192.168.218.xxx' # Remplace par l'IP de ton serveur (PC)
PORT = 5001
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((HOST, PORT))
print(f"Connecté à {HOST}:{PORT}")
# --- Envoi d'opérations ---
while True:
op = input("Opération (+, -, *, / ou 'exit' pour quitter) : ")
if op == "exit":
break
try:
a = float(input("Premier opérande : "))
b = float(input("Deuxième opérande : "))
except ValueError:
print(" Entrée invalide. Utilisez des nombres.")
continue
S={
"op": op,
"a": a,
"b": b,
"res": None
data = json.dumps(S)
client_socket.send(data.encode())
# --- Réception du résultat ---
response = client_socket.recv(1024).decode()
result = json.loads(response)
print(f" Résultat : {result['res']}")
client_socket.close()
print(" Déconnecté du serveur.")
8. Simulation d’erreurs (abordée mais non utilisée)
Il a été envisagé d’introduire une erreur aléatoire sur un bit pour simuler un canal bruité,
mais cette
fonctionnalité a été volontairement exclue pour rester dans un cadre simple et clair.
Conclusion
Ce projet a permis de découvrir les bases des communications réseau avec sockets en
Python, de manipuler
le format JSON, et de concevoir un protocole simple d’échange client-serveur pour des
calculs mathématiques.
Il peut être facilement étendu à d'autres applications.
