Ahhhh, je ne m'en sors pas.
J'ai beau changer l'état des entrées rien ne se passe.
Je pige pas ce qu'il se passe. Je m'en réfère à votre expertise.
Code :
[== Indéfini ==]
#!/usr/bin/python3
#####################################################
##
## LOG
##
#Parametres du journal
LOG_NAME = "webcontroller"
LOG_PATH = "./log/webcontroller.log"
LOG_FORMAT = "%(asctime)s -> %(levelname)s -> %(message)s"
#Procedure d'ecriture dans le journal
def log(message, level = 0):
print(message)
if level == 0:
logger.setLevel(logging.INFO)
logger.info(message)
elif level == 1:
logger.setLevel(logging.WARNING)
logger.warning(message)
elif level == 2:
logger.setLevel(logging.ERROR)
logger.exception(message)
###########################################################
##
## Scenario
##
import threading
import time
class Game(threading.Thread):
def __init__(self, event):
threading.Thread.__init__(self)
self.running = False
self.stopped = False
self.timedout = False
self.killed = False
self.event = event
self.ready2go = threading.Event()
def init_room(self):
self.reset()
GPIO.output(WebHandler.toGPIO_OUT[1], GPIO.HIGH)
GPIO.output(WebHandler.toGPIO_OUT[2], GPIO.LOW)
GPIO.output(WebHandler.toGPIO_OUT[3], GPIO.HIGH)
GPIO.output(WebHandler.toGPIO_OUT[4], GPIO.LOW) # unused but safier
self.timedout = False
self.stopped = False
self.running = True
def reset(self):
WebHandler.OutPortForce[1] = False
WebHandler.OutPortForce[2] = False
WebHandler.OutPortForce[3] = False
WebHandler.OutPortForce[4] = False
def post_init(self):
GPIO.output(WebHandler.toGPIO_OUT[1], GPIO.LOW)
GPIO.output(WebHandler.toGPIO_OUT[2], GPIO.LOW)
GPIO.output(WebHandler.toGPIO_OUT[3], GPIO.HIGH)
GPIO.output(WebHandler.toGPIO_OUT[4], GPIO.LOW) # Unused but safier
def update_out_port(self, num, val):
if not WebHandler.OutPortForce[num]:
GPIO.output(WebHandler.toGPIO_OUT[num], val)
def check_input_value(self, pin):
print("input pin", pin, "value is", GPIO.input(pin))
def check_if_won(self):
flag = False
input_1 = GPIO.input(WebHandler.toGPIO_IN[1])
input_3 = GPIO.input(WebHandler.toGPIO_IN[3])
input_4 = GPIO.input(WebHandler.toGPIO_IN[4])
if (input_1 == 1 and input_3 == 0) or (input_1 == 0 and input_3 == 1):
self.update_out_port(1, GPIO.LOW)
self.update_out_port(2, GPIO.HIGH)
self.update_out_port(3, GPIO.HIGH)
elif input_1 == 1 and input_3 == 1:
#self.update_out_port(1, GPIO.HIGH)
#self.update_out_port(2, GPIO.LOW)
#self.update_out_port(3, GPIO.LOW)
thread_1.start()
elif input_4 == 1:
os.system("sudo shutdown -r now")
else:
self.update_out_port(1, GPIO.HIGH)
self.update_out_port(2, GPIO.LOW)
self.update_out_port(3, GPIO.HIGH)
def run(self):
while True:
self.ready2go.set()
self.event.wait()
self.ready2go.clear()
self.init_room()
#if not self.killed:
# timeout_timer = threading.Timer(3600.0, self.timeout)
# timeout_timer.start()
while not self.stopped and not self.timedout and not self.killed:
time.sleep(0.3)
self.check_if_won()
self.running = False
#if not self.timedout:
# timeout_timer.cancel()
self.post_init()
self.event.clear()
print("Game ends !")
if self.killed:
return
def timeout(self):
self.timedout = True
def stop(self):
self.stopped = True
def kill(self):
self.killed = True
####Fin Scenario##########################################
class ShutDown(Exception):
pass
###########################################################
##
## Blink
##
class Blink(threading.Thread):
#Thread chargé simplement de basculer la sortie pendant une seconde.
def __init__(self):
threading.Thread.__init__(self)
def run(self):
#Code à exécuter pendant l'exécution du thread.
GPIO.output(WebHandler.toGPIO_OUT[1], not GPIO.input(WebHandler.toGPIO_OUT[1]))
time.sleep(1)
GPIO.output(WebHandler.toGPIO_OUT[1], not GPIO.input(WebHandler.toGPIO_OUT[1]))
####Fin Blink##########################################
import logging
import http.server
import socketserver
import urllib.parse
import os
import RPi.GPIO as GPIO
###########################################################
##
## Traitement des requetes
##
#LOCAL_WEB_ADDR = "127.0.0.1"
LOCAL_WEB_ADDR = "192.168.0.23"
WEB_PORT = 8000
WEB_ADDR = LOCAL_WEB_ADDR
class WebHandler(http.server.BaseHTTPRequestHandler):
#Procedure permettant de retourner une reponse formatee JSON au client
def response(self, json):
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
self.wfile.write(bytes(json, "UTF-8"))
#Fonction d'obtention de la temperature du CPU
def getCPUtemp(self):
res = os.popen("vcgencmd measure_temp").readline()
return(res.replace("temp=","").replace("'C\n",""))
#Fonction d'obtention de l'espace memoire 1: Total, 2: Utilise, 3: Libre
def getRAMinfo(self):
p = os.popen('free')
i = 0
while True:
i += 1
line = p.readline()
if i == 2:
return(line.split()[1:4])
#Fonction d'obtention de la charge du CPU
def getCPUusage(self):
return(str(os.popen("top -b -n 5 -d 0.2 | grep \"Cpu\" | awk 'NR==3{ print($2)}'").readline().strip().replace(",", ".")))
#Fonction d'obtention de l'espace disque 1: Total, 2: Utilise, 3: Libre, 4: Pourcentage utilise
def getDiskSpace(self):
p = os.popen("df -m /")
i = 0
while True:
i += 1
line = p.readline()
if i == 2:
return(line.split()[1:5])
## def update_port(self, port):
## if port in self.query_components:
## port_num = int(port.replace("port", ""))
## print("print num = ", port_num)
## action = self.query_components[port][0]
## if action == "ON" and self.Port[port_num] == "OFF":
## self.Port[port_num] = "ON"
## return True
## elif action == "OFF" and self.Port[port_num] == "ON":
## self.Port[port_num] = "OFF"
## return True
## return False
def set_to_high(self, pin):
print("setting pin output ", pin, " to high")
GPIO.output(pin, GPIO.HIGH)
def set_to_low(self, pin):
print("setting pin output ", pin, " to low")
GPIO.output(pin, GPIO.LOW)
def update_port(self, num, dir, val):
port_num = int(num)
if dir == "in":
if val == "ON" and self.InPort[port_num] == "OFF":
self.InPort[port_num] = "ON"
return True
elif val == "OFF" and self.InPort[port_num] == "ON":
self.InPort[port_num] = "OFF"
return True
elif dir == "out":
if val == "ON":
#self.OutPort[port_num] = "ON"
self.set_to_high(self.toGPIO_OUT[port_num])
self.OutPortForce[port_num] = True
return True
elif val == "OFF":
#self.OutPort[port_num] = "OFF"
self.set_to_low(self.toGPIO_OUT[port_num])
self.OutPortForce[port_num] = True
return True
elif val == "RESET":
self.OutPortForce[port_num] = False
return True
return False
def start_game(self):
log("Starting Game", 1)
self.thread_event.set()
def stop_game(self):
log("Ending Game", 1)
self.thread_event.clear()
self.timer.stop()
self.restart_game_event.wait()
#Fonction appelee lors d'une requete http
def do_GET(self):
try:
#Extraction des parametres
qs = urllib.parse.urlparse(self.path).query
query_components = urllib.parse.parse_qs(qs)
self.query_components = query_components
if "server" in query_components:
action = query_components["server"][0]
if action == "stop":
self.response("{\"server\": \"shutting\"}")
self.thread_event.set()
self.timer.kill()
self.timer.join()
self.assassin.start()
return
if "game" in query_components:
action = query_components["game"][0]
if action == "restart":
self.stop_game()
self.start_game()
self.response("{\"game\": \"restarted\"}")
return
if action == "start":
self.start_game()
self.response("{\"game\": \"launched\"}")
return
if action == "stop":
self.stop_game()
self.response("{\"game\": \"stopped\"}")
return
if action == "status":
if self.timer.stopped:
self.response("{\"game\": \"stopped\"}")
elif self.timer.timedout:
self.response("{\"game\": \"timed out\"}")
elif self.timer.killed:
self.response("{\"game\": \"killed\"}")
elif self.timer.running:
self.response("{\"game\": \"running\"}")
else:
self.response("{\"game\": \"not running\"}")
return
#Informations du systeme
if "system" in query_components:
action = query_components["system"][0]
#Informations sur le systeme
if action == "infos":
CPU_temp = self.getCPUtemp()
CPU_used = self.getCPUusage()
RAM_infos = self.getRAMinfo()
DISK_infos = self.getDiskSpace()
RAM_total = round(int(RAM_infos[0]) / 1024, 1)
RAM_used = round(int(RAM_infos[1]) / 1024, 1)
RAM_free = round(int(RAM_infos[2]) / 1024, 1)
DISK_total = round(int(DISK_infos[0]) / 1000, 1)
DISK_free = round(int(DISK_infos[1]) / 1000, 1)
DISK_used = round(int(DISK_infos[2]) / 1000, 1)
DISK_perc = DISK_infos[3][:-1]
self.response("""
{{
"cpu\" :
{{
\"used\" : \"{0}\",
\"temp\" : \"{1}\"
}},
\"memory\" :
{{
\"used\" : \"{2}\",
\"total\" : \"{3}\",
\"free\" : \"{4}\"
}},
\"disk\" :
{{
\"used\" : \"{5}\",
\"total\" : \"{6}\",
\"free\" : \"{7}\",
\"perc\" : \"{8}\"
}}
}}""".format(CPU_used, CPU_temp, RAM_used, RAM_total, RAM_free, DISK_used, DISK_total, DISK_free, DISK_perc))
return
if "port" in query_components:
changed = self.update_port(query_components["port"][0], query_components["dir"][0], query_components["val"][0])
if changed:
self.response("{\"answer\": \"port changes ok\"}")
else:
self.response("{\"answer\": \"no port change\"}")
return
#Requete concernant le statut
if "all" in query_components:
action = query_components["all"][0]
#Statut des Ports
if action == "status":
in_port1 = GPIO.input(self.toGPIO_IN[1])
in_port2 = GPIO.input(self.toGPIO_IN[2])
in_port3 = GPIO.input(self.toGPIO_IN[3])
in_port4 = GPIO.input(self.toGPIO_IN[4])
out_port1 = GPIO.input(self.toGPIO_OUT[1])
out_port2 = GPIO.input(self.toGPIO_OUT[2])
out_port3 = GPIO.input(self.toGPIO_OUT[3])
out_port4 = GPIO.input(self.toGPIO_OUT[4])
self.response("""
{{
\"in_port1\" : \"{0}\",
\"in_port2\" : \"{1}\",
\"in_port3\" : \"{2}\",
\"in_port4\" : \"{3}\",
\"out_port1\" : \"{4}\",
\"out_port2\" : \"{5}\",
\"out_port3\" : \"{6}\",
\"out_port4\" : \"{7}\"
}}""".format(in_port1, in_port2, in_port3, in_port4, out_port1, out_port2, out_port3, out_port4))
return
#Requete invalide
log("Invalid query", 1)
self.response("{\"error\": \"Invalid query\"}")
except Exception as ex:
log(ex, 2)
pass
return
####Fin Traitement des requêtes###########################
class ThreadingServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
pass
def GPIO_Init():
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
print("Changing configuration")
GPIO.setup(4, GPIO.IN)
GPIO.setup(17, GPIO.IN)
GPIO.setup(27, GPIO.IN)
GPIO.setup(22, GPIO.IN)
GPIO.setup(5, GPIO.OUT)
GPIO.output(5, GPIO.LOW)
GPIO.setup(6, GPIO.OUT)
GPIO.output(6, GPIO.LOW)
GPIO.setup(13, GPIO.OUT)
GPIO.output(13, GPIO.LOW)
GPIO.setup(19, GPIO.OUT)
GPIO.output(19, GPIO.LOW)
############################################################
## MAIN method
##
if __name__ == "__main__":
thread_1 = Blink()
GPIO_Init()
#Initialisation du journal
logger = logging.getLogger(LOG_NAME)
hdlr = logging.FileHandler(LOG_PATH)
formatter = logging.Formatter(LOG_FORMAT)
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
WebHandler.InPort = ["IN Ports status", "OFF", "OFF", "OFF", "OFF"]
WebHandler.OutPort = ["OUT Ports status", "OFF", "OFF", "OFF", "OFF"]
WebHandler.OutPortForce = ["OUT Ports status", False, False, False, False]
WebHandler.toGPIO_IN = ["IN Ports matching", 4, 17, 27, 22]
WebHandler.toGPIO_OUT = ["OUT Ports matching", 19, 13, 6, 5]
WebHandler.thread_event = threading.Event()
WebHandler.thread_event.clear()
WebHandler.timer = Game(WebHandler.thread_event)
WebHandler.timer.start()
WebHandler.restart_game_event = WebHandler.timer.ready2go
log("Starting Room Server")
#Parametres du serveur HTTP
server_address = (WEB_ADDR, WEB_PORT)
try:
#Instanciation du serveur HTTP
httpd = ThreadingServer(server_address, WebHandler)
WebHandler.assassin = threading.Thread(target=httpd.shutdown)
WebHandler.assassin.daemon = True
httpd.serve_forever()
except KeyboardInterrupt:
log("Shutting down server")
WebHandler.timer.kill()
WebHandler.thread_event.set()
WebHandler.timer.join()
thread_1.join()
httpd.socket.close()
hdlr.close()
GPIO.cleanup()
