CARIA.2.2
Update for the final presentation huge change with previous version
This commit is contained in:
ccunatbrule
@@ -1,38 +1,36 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import RPi.GPIO as GPIO
|
||||
import time
|
||||
import sys
|
||||
import time, sys
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from AlphaBot import AlphaBot
|
||||
|
||||
Ab = AlphaBot()
|
||||
speed = 100
|
||||
DR = 16
|
||||
DL = 19
|
||||
|
||||
GPIO.setmode(GPIO.BCM)
|
||||
GPIO.setwarnings(False)
|
||||
GPIO.setup(DR,GPIO.IN,GPIO.PUD_UP)
|
||||
GPIO.setup(DL,GPIO.IN,GPIO.PUD_UP)
|
||||
status = "initialization"
|
||||
duration = 0.1
|
||||
speed = 20
|
||||
|
||||
try:
|
||||
while True:
|
||||
DR_status = GPIO.input(DR)
|
||||
DL_status = GPIO.input(DL)
|
||||
if((DL_status == 1) and (DR_status == 1)):
|
||||
Ab.forward(speed)
|
||||
elif((DL_status == 1) and (DR_status == 0)):
|
||||
Ab.left(speed)
|
||||
elif((DL_status == 0) and (DR_status == 1)):
|
||||
Ab.right(speed)
|
||||
else:
|
||||
Ab.backward(speed)
|
||||
time.sleep(0.2)
|
||||
Ab.left(speed)
|
||||
time.sleep(0.2)
|
||||
Ab.stop()
|
||||
|
||||
start_time = time.time() # Enregistrer l'heure de début
|
||||
while time.time() - start_time < 10: # Boucle pendant 5 seconde
|
||||
OBSTACLE_PIN_status = GPIO.input(Ab.OBSTACLE_PIN)
|
||||
if OBSTACLE_PIN_status == 1:
|
||||
Ab.forward(duration, speed)
|
||||
status = "operation successful"
|
||||
else:
|
||||
Ab.emergencystop()
|
||||
status = "emergency stop successful"
|
||||
except KeyboardInterrupt:
|
||||
GPIO.cleanup();
|
||||
print("Interruption par l'utilisateur.")
|
||||
status = "interrupted"
|
||||
finally:
|
||||
Ab.cleanup()
|
||||
# Vérification finale et affichage du statut
|
||||
if status == "operation successful" or status == "emergency stop successful":
|
||||
print(f"Le composant fonctionne correctement: {status}.")
|
||||
fonctionnement_ok = True
|
||||
else:
|
||||
print(f"Le composant a rencontré un problème: {status}.")
|
||||
fonctionnement_ok = False
|
||||
|
||||
Ab.enregistrer_resultats(sys.argv[0], fonctionnement_ok, status)
|
||||
|
||||
@@ -1,35 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import RPi.GPIO as GPIO
|
||||
import time
|
||||
import sys
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from AlphaBot import AlphaBot
|
||||
|
||||
Ab = AlphaBot()
|
||||
|
||||
DR = 16
|
||||
DL = 19
|
||||
|
||||
GPIO.setmode(GPIO.BCM)
|
||||
GPIO.setwarnings(False)
|
||||
GPIO.setup(DR,GPIO.IN,GPIO.PUD_UP)
|
||||
GPIO.setup(DL,GPIO.IN,GPIO.PUD_UP)
|
||||
Ab.stop()
|
||||
speed=100
|
||||
try:
|
||||
while True:
|
||||
|
||||
DR_status = GPIO.input(DR)
|
||||
DL_status = GPIO.input(DL)
|
||||
if((DL_status == 0) and (DR_status == 0)):
|
||||
Ab.forward(speed)
|
||||
elif((DL_status == 1) and (DR_status == 0)):
|
||||
Ab.right(speed)
|
||||
elif((DL_status == 0) and (DR_status == 1)):
|
||||
Ab.left(speed)
|
||||
else:
|
||||
Ab.stop()
|
||||
except KeyboardInterrupt:
|
||||
GPIO.cleanup();
|
||||
|
||||
59
WebControl/apps/itineraire_create.py
Normal file
59
WebControl/apps/itineraire_create.py
Normal file
@@ -0,0 +1,59 @@
|
||||
import requests, json, time
|
||||
|
||||
def get_directions(origin, destination, api_key):
|
||||
url = f"https://maps.googleapis.com/maps/api/directions/json?origin={origin}&destination={destination}&key={api_key}"
|
||||
response = requests.get(url)
|
||||
if response.status_code == 200:
|
||||
directions = response.json()
|
||||
return directions
|
||||
else:
|
||||
return None
|
||||
|
||||
def save_steps_to_file(directions, filename):
|
||||
if directions and 'routes' in directions and len(directions['routes']) > 0:
|
||||
steps = []
|
||||
for route in directions['routes']:
|
||||
for leg in route['legs']:
|
||||
for step in leg['steps']:
|
||||
steps.append(step)
|
||||
with open(filename, 'w', encoding='utf-8') as f:
|
||||
json.dump(steps, f, indent=2, ensure_ascii=False)
|
||||
|
||||
def save_selected_steps_to_file(directions, filename):
|
||||
selected_steps = []
|
||||
if directions and 'routes' in directions and len(directions['routes']) > 0:
|
||||
for route in directions['routes']:
|
||||
for leg in route['legs']:
|
||||
for step in leg['steps']:
|
||||
selected_step = {
|
||||
'distance_value': step['distance']['value'],
|
||||
'maneuver': step.get('maneuver', 'maneuver-unspecified')
|
||||
}
|
||||
selected_steps.append(selected_step)
|
||||
with open(filename, 'w', encoding='utf-8') as f:
|
||||
json.dump(selected_steps, f, indent=2, ensure_ascii=False)
|
||||
|
||||
# Paramètres
|
||||
origin = "48.8224, 2.2748" # Coordonnées pour Paris (latitude, longitude)
|
||||
destination = "48.67912602858551, 2.3860270345466024" # Coordonnées pour Lyon (latitude, longitude)
|
||||
api_key = "AIzaSyD6WRlNBTn27rEoYbIAlxw9U_Nr_iNqLJc"
|
||||
|
||||
|
||||
# Obtenir les directions
|
||||
directions = get_directions(origin, destination, api_key)
|
||||
print("Préparons ensemble votre itinéraire !")
|
||||
time.sleep(2)
|
||||
print("Veuillez saisir l'adresse de départ et l'adresse d'arrivée.")
|
||||
time.sleep(2)
|
||||
print("Calcul de l'itinéraire en cours : de Paris à Lyon.")
|
||||
time.sleep(2)
|
||||
|
||||
# Sauvegarder les étapes complètes dans un fichier JSON
|
||||
steps_filename = '/home/christian/WebControl/logs/steps.json'
|
||||
save_steps_to_file(directions, steps_filename)
|
||||
# print(f"Les étapes complètes de l'itinéraire ont été sauvegardées dans le fichier {steps_filename}")
|
||||
|
||||
# Sauvegarder les étapes sélectionnées dans un fichier JSON
|
||||
selected_steps_filename = '/home/christian/WebControl/logs/selected_steps.json'
|
||||
save_selected_steps_to_file(directions, selected_steps_filename)
|
||||
# print(f"Les étapes sélectionnées de l'itinéraire ont été sauvegardées dans le fichier {selected_steps_filename}")
|
||||
75
WebControl/apps/itineraire_suivre.py
Normal file
75
WebControl/apps/itineraire_suivre.py
Normal file
@@ -0,0 +1,75 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import json, time, sys
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from AlphaBot import AlphaBot
|
||||
Ab = AlphaBot()
|
||||
speed = 20
|
||||
|
||||
# Fonction pour calculer la durée en fonction de la distance
|
||||
def calculate_duration(distance_value):
|
||||
# Réglez la vitesse de traitement selon vos besoins
|
||||
speed_factor = 0.001 # Exemple 0.01/100m:s | 0.001/1km/s
|
||||
return distance_value * speed_factor
|
||||
|
||||
# Lecture du fichier selected_steps.json et traitement des manoeuvres
|
||||
def process_selected_steps(filename):
|
||||
with open(filename, 'r', encoding='utf-8') as f:
|
||||
selected_steps = json.load(f)
|
||||
|
||||
for step in selected_steps:
|
||||
maneuver = step['maneuver']
|
||||
distance_value = step['distance_value']
|
||||
|
||||
# Calcul de la durée en fonction de la distance
|
||||
duration = calculate_duration(distance_value)
|
||||
|
||||
if maneuver == "maneuver-unspecified":
|
||||
Ab.maneuver_unspecified(duration)
|
||||
elif maneuver == "turn-slight-left":
|
||||
Ab.turn_slight_left(duration, speed)
|
||||
elif maneuver == "turn-sharp-left":
|
||||
Ab.turn_sharp_left(duration, speed)
|
||||
elif maneuver == "u-turn-left":
|
||||
Ab.u_turn_left(duration, speed)
|
||||
elif maneuver == "turn-left":
|
||||
Ab.left(duration, speed)
|
||||
elif maneuver == "turn-slight-right":
|
||||
Ab.turn_slight_right(duration, speed)
|
||||
elif maneuver == "turn-sharp-right":
|
||||
Ab.turn_sharp_right(duration, speed)
|
||||
elif maneuver == "u-turn-right":
|
||||
Ab.u_turn_right(duration, speed)
|
||||
elif maneuver == "turn-right":
|
||||
Ab.right(duration, speed)
|
||||
elif maneuver == "straight":
|
||||
Ab.forward(duration, speed)
|
||||
elif maneuver == "ramp-left":
|
||||
Ab.ramp_left(duration, speed)
|
||||
elif maneuver == "ramp-right":
|
||||
Ab.ramp_right(duration, speed)
|
||||
elif maneuver == "merge":
|
||||
Ab.merge(duration, speed)
|
||||
elif maneuver == "fork-left":
|
||||
Ab.fork_left(duration, speed)
|
||||
elif maneuver == "fork-right":
|
||||
Ab.fork_right(duration, speed)
|
||||
elif maneuver == "ferry":
|
||||
Ab.stop(duration)
|
||||
elif maneuver == "ferry-train":
|
||||
Ab.stop(duration)
|
||||
elif maneuver == "roundabout-left":
|
||||
Ab.roundabout_left(duration, speed)
|
||||
elif maneuver == "roundabout-right":
|
||||
Ab.roundabout_right(duration, speed)
|
||||
else:
|
||||
print(f"Manoeuvre inconnue : {maneuver}")
|
||||
|
||||
# Nom du fichier contenant les étapes sélectionnées
|
||||
selected_steps_filename = '/home/christian/WebControl/logs/selected_steps_short.json'
|
||||
|
||||
# Appel de la fonction pour traiter les étapes sélectionnées
|
||||
print("Le départ est prévu dans 10 secondes...")
|
||||
time.sleep(10)
|
||||
print("Départ imminent !")
|
||||
process_selected_steps(selected_steps_filename)
|
||||
170
WebControl/apps/itineraire_suivre_emergency.py
Normal file
170
WebControl/apps/itineraire_suivre_emergency.py
Normal file
@@ -0,0 +1,170 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import RPi.GPIO as GPIO
|
||||
import json, time, sys, threading
|
||||
from threading import Thread
|
||||
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from AlphaBot import AlphaBot
|
||||
Ab = AlphaBot()
|
||||
|
||||
base_speed = 20 # Vitesse fixe de 20
|
||||
current_step_index = 0
|
||||
emergency_stop = False
|
||||
remaining_duration = 0
|
||||
stop_event_obstacle = threading.Event()
|
||||
|
||||
|
||||
# Fonction pour calculer la durée en fonction de la distance
|
||||
def calculate_duration(distance_value):
|
||||
speed_factor = 0.001 # Exemple 0.01/100m:s | 0.001/1km/s
|
||||
return distance_value * speed_factor
|
||||
|
||||
# Fonction pour surveiller les obstacles en arrière-plan
|
||||
def monitor_obstacles():
|
||||
global emergency_stop, remaining_duration
|
||||
while not stop_event_obstacle.is_set():
|
||||
DR_status = GPIO.input(Ab.OBSTACLE_PIN)
|
||||
if DR_status == 0: # Obstacle détecté
|
||||
Ab.emergencystop()
|
||||
emergency_stop = True
|
||||
while GPIO.input(Ab.OBSTACLE_PIN) == 0: # Attendre que l'obstacle soit dégagé
|
||||
time.sleep(2)
|
||||
print("Obstacle dégagé. Attente de 2 secondes avant de reprendre.")
|
||||
emergency_stop = False
|
||||
|
||||
# Fonction pour exécuter une manoeuvre avec arrêt d'urgence possible
|
||||
def execute_maneuver(maneuver_function, duration, speed=None):
|
||||
global remaining_duration
|
||||
start_time = time.time()
|
||||
while not emergency_stop and (time.time() - start_time) < duration:
|
||||
time_slice = min(remaining_duration, duration - (time.time() - start_time))
|
||||
|
||||
# Appel de la fonction manoeuvre avec ou sans vitesse selon le besoin
|
||||
if speed is not None:
|
||||
maneuver_function(time_slice, speed)
|
||||
else:
|
||||
maneuver_function(time_slice)
|
||||
|
||||
remaining_duration = duration - (time.time() - start_time)
|
||||
|
||||
# Fonction pour traiter les étapes sélectionnées
|
||||
def process_selected_steps(filename):
|
||||
global current_step_index, remaining_duration
|
||||
|
||||
with open(filename, 'r', encoding='utf-8') as f:
|
||||
selected_steps = json.load(f)
|
||||
|
||||
while current_step_index < len(selected_steps):
|
||||
if emergency_stop: # Si arrêt d'urgence, attendre que l'obstacle soit dégagé
|
||||
time.sleep(0.1)
|
||||
continue
|
||||
|
||||
step = selected_steps[current_step_index]
|
||||
maneuver = step['maneuver']
|
||||
distance_value = step['distance_value']
|
||||
duration = calculate_duration(distance_value)
|
||||
remaining_duration = duration # Initialiser la durée restante
|
||||
|
||||
# Appel de la fonction de manoeuvre avec une vitesse fixe de 20
|
||||
if maneuver == "maneuver-unspecified":
|
||||
execute_maneuver(Ab.maneuver_unspecified, duration)
|
||||
elif maneuver == "turn-slight-left":
|
||||
execute_maneuver(Ab.turn_slight_left, duration, base_speed)
|
||||
elif maneuver == "turn-sharp-left":
|
||||
execute_maneuver(Ab.turn_sharp_left, duration, base_speed)
|
||||
elif maneuver == "u-turn-left":
|
||||
execute_maneuver(Ab.u_turn_left, duration, base_speed)
|
||||
elif maneuver == "turn-left":
|
||||
execute_maneuver(Ab.left, duration, base_speed)
|
||||
elif maneuver == "turn-slight-right":
|
||||
execute_maneuver(Ab.turn_slight_right, duration, base_speed)
|
||||
elif maneuver == "turn-sharp-right":
|
||||
execute_maneuver(Ab.turn_sharp_right, duration, base_speed)
|
||||
elif maneuver == "u-turn-right":
|
||||
execute_maneuver(Ab.u_turn_right, duration, base_speed)
|
||||
elif maneuver == "turn-right":
|
||||
execute_maneuver(Ab.right, duration, base_speed)
|
||||
elif maneuver == "straight":
|
||||
execute_maneuver(Ab.forward, duration, base_speed)
|
||||
elif maneuver == "ramp-left":
|
||||
execute_maneuver(Ab.ramp_left, duration, base_speed)
|
||||
elif maneuver == "ramp-right":
|
||||
execute_maneuver(Ab.ramp_right, duration, base_speed)
|
||||
elif maneuver == "merge":
|
||||
execute_maneuver(Ab.merge, duration, base_speed)
|
||||
elif maneuver == "fork-left":
|
||||
execute_maneuver(Ab.fork_left, duration, base_speed)
|
||||
elif maneuver == "fork-right":
|
||||
execute_maneuver(Ab.fork_right, duration, base_speed)
|
||||
elif maneuver == "ferry":
|
||||
execute_maneuver(Ab.stop, duration)
|
||||
elif maneuver == "ferry-train":
|
||||
execute_maneuver(Ab.stop, duration)
|
||||
elif maneuver == "roundabout-left":
|
||||
execute_maneuver(Ab.roundabout_left, duration, base_speed)
|
||||
elif maneuver == "roundabout-right":
|
||||
execute_maneuver(Ab.roundabout_right, duration, base_speed)
|
||||
else:
|
||||
print(f"Manoeuvre inconnue : {maneuver}")
|
||||
|
||||
# Incrémenter l'index de l'étape seulement si l'arrêt d'urgence n'a pas été déclenché
|
||||
if not emergency_stop:
|
||||
current_step_index += 1
|
||||
|
||||
# Nom du fichier contenant les étapes sélectionnées
|
||||
selected_steps_filename = '/home/christian/WebControl/logs/selected_steps_short.json'
|
||||
|
||||
# Démarrer la surveillance des obstacles dans un thread séparé
|
||||
obstacle_thread = Thread(target=monitor_obstacles)
|
||||
obstacle_thread.daemon = True
|
||||
obstacle_thread.start()
|
||||
|
||||
# Attendre avant de démarrer
|
||||
print("Le départ est prévu dans 10 secondes...")
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
print("5 secondes...")
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
time.sleep(1)
|
||||
print("Départ imminent !")
|
||||
try:
|
||||
# Appel de la fonction pour traiter les étapes sélectionnées
|
||||
process_selected_steps(selected_steps_filename)
|
||||
status = "scenario successful"
|
||||
except KeyboardInterrupt:
|
||||
print("Interruption par l'utilisateur.")
|
||||
status = "interrupted"
|
||||
except Exception as e:
|
||||
print(f"Erreur lors de l'exécution: {e}")
|
||||
status = "error"
|
||||
finally:
|
||||
# Arrêter les threads
|
||||
Ab.stop_event_obstacle.set()
|
||||
# Attendre que les threads se terminent
|
||||
obstacle_thread.join()
|
||||
print("Fin de la surveillance d'obstacle")
|
||||
Ab.cleanup()
|
||||
|
||||
# Vérification finale et affichage du statut
|
||||
if status in ["scenario successful"]:
|
||||
print("Le scenario fonctionne correctement.")
|
||||
fonctionnement_ok = True
|
||||
else:
|
||||
print(f"Le scenario a rencontré un problème : {status}.")
|
||||
fonctionnement_ok = False
|
||||
|
||||
Ab.enregistrer_resultats(sys.argv[0], fonctionnement_ok, status)
|
||||
174
WebControl/apps/itineraire_suivre_emergency_speed.py
Normal file
174
WebControl/apps/itineraire_suivre_emergency_speed.py
Normal file
@@ -0,0 +1,174 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import RPi.GPIO as GPIO
|
||||
import json, time, sys
|
||||
from threading import Thread
|
||||
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from AlphaBot import AlphaBot
|
||||
Ab = AlphaBot()
|
||||
|
||||
status = "initialization"
|
||||
|
||||
base_speed = 20 # Vitesse fixe de 20
|
||||
current_step_index = 0
|
||||
emergency_stop = False
|
||||
remaining_duration = 0
|
||||
adjusted_speed = Ab.vitesse_queue.get()
|
||||
|
||||
# Fonction pour calculer la durée en fonction de la distance
|
||||
def calculate_duration(distance_value):
|
||||
speed_factor = 0.001 # Exemple 0.01/100m:s | 0.001/1km/s
|
||||
return distance_value * speed_factor
|
||||
|
||||
def execute_maneuver(maneuver_function, duration):
|
||||
global remaining_duration
|
||||
start_time = time.time()
|
||||
while not emergency_stop and (time.time() - start_time) < duration:
|
||||
time_slice = min(remaining_duration, duration - (time.time() - start_time))
|
||||
|
||||
# Lire la vitesse ajustée de la queue si disponible
|
||||
if not Ab.vitesse_queue.empty():
|
||||
adjusted_speed = Ab.vitesse_queue.get()
|
||||
else:
|
||||
adjusted_speed = base_speed # Utiliser la vitesse de base si la queue est vide
|
||||
|
||||
# Appel de la fonction manoeuvre avec la vitesse ajustée
|
||||
maneuver_function(time_slice, adjusted_speed)
|
||||
|
||||
remaining_duration = duration - (time.time() - start_time)
|
||||
|
||||
|
||||
# Fonction pour traiter les étapes sélectionnées
|
||||
def process_selected_steps(filename):
|
||||
global current_step_index, remaining_duration
|
||||
|
||||
with open(filename, 'r', encoding='utf-8') as f:
|
||||
selected_steps = json.load(f)
|
||||
|
||||
while current_step_index < len(selected_steps):
|
||||
if emergency_stop: # Si arrêt d'urgence, attendre que l'obstacle soit dégagé
|
||||
time.sleep(0.1)
|
||||
continue
|
||||
|
||||
step = selected_steps[current_step_index]
|
||||
maneuver = step['maneuver']
|
||||
distance_value = step['distance_value']
|
||||
duration = calculate_duration(distance_value)
|
||||
remaining_duration = duration # Initialiser la durée restante
|
||||
|
||||
# Appel de la fonction de manoeuvre avec une vitesse fixe de 20
|
||||
if maneuver == "maneuver-unspecified":
|
||||
execute_maneuver(Ab.maneuver_unspecified, adjusted_speed)
|
||||
elif maneuver == "turn-slight-left":
|
||||
execute_maneuver(Ab.turn_slight_left, duration, adjusted_speed)
|
||||
elif maneuver == "turn-sharp-left":
|
||||
execute_maneuver(Ab.turn_sharp_left, duration, adjusted_speed)
|
||||
elif maneuver == "u-turn-left":
|
||||
execute_maneuver(Ab.u_turn_left, duration, adjusted_speed)
|
||||
elif maneuver == "turn-left":
|
||||
execute_maneuver(Ab.left, duration, adjusted_speed)
|
||||
elif maneuver == "turn-slight-right":
|
||||
execute_maneuver(Ab.turn_slight_right, duration, adjusted_speed)
|
||||
elif maneuver == "turn-sharp-right":
|
||||
execute_maneuver(Ab.turn_sharp_right, duration, adjusted_speed)
|
||||
elif maneuver == "u-turn-right":
|
||||
execute_maneuver(Ab.u_turn_right, duration, adjusted_speed)
|
||||
elif maneuver == "turn-right":
|
||||
execute_maneuver(Ab.right, duration, adjusted_speed)
|
||||
elif maneuver == "straight":
|
||||
execute_maneuver(Ab.forward, duration, adjusted_speed)
|
||||
elif maneuver == "ramp-left":
|
||||
execute_maneuver(Ab.ramp_left, duration, adjusted_speed)
|
||||
elif maneuver == "ramp-right":
|
||||
execute_maneuver(Ab.ramp_right, duration, adjusted_speed)
|
||||
elif maneuver == "merge":
|
||||
execute_maneuver(Ab.merge, duration, adjusted_speed)
|
||||
elif maneuver == "fork-left":
|
||||
execute_maneuver(Ab.fork_left, duration, adjusted_speed)
|
||||
elif maneuver == "fork-right":
|
||||
execute_maneuver(Ab.fork_right, duration, adjusted_speed)
|
||||
elif maneuver == "ferry":
|
||||
execute_maneuver(Ab.stop, duration)
|
||||
elif maneuver == "ferry-train":
|
||||
execute_maneuver(Ab.stop, duration)
|
||||
elif maneuver == "roundabout-left":
|
||||
execute_maneuver(Ab.roundabout_left, duration, adjusted_speed)
|
||||
elif maneuver == "roundabout-right":
|
||||
execute_maneuver(Ab.roundabout_right, duration, adjusted_speed)
|
||||
else:
|
||||
print(f"Manoeuvre inconnue : {maneuver}")
|
||||
|
||||
# Incrémenter l'index de l'étape seulement si l'arrêt d'urgence n'a pas été déclenché
|
||||
if not emergency_stop:
|
||||
current_step_index += 1
|
||||
|
||||
# Nom du fichier contenant les étapes sélectionnées
|
||||
selected_steps_filename = '/home/christian/WebControl/logs/selected_steps_short.json'
|
||||
|
||||
# Démarrer la surveillance des obstacle dans un thread séparé
|
||||
vitesse_thread = Thread(target=Ab.monitor_vitesse)
|
||||
vitesse_thread.daemon = True
|
||||
vitesse_thread.start()
|
||||
print("Surveillance de la vitesse en cours")
|
||||
|
||||
# Démarrer la surveillance des obstacle dans un thread séparé
|
||||
obstacle_thread = Thread(target=Ab.monitor_obstacle)
|
||||
obstacle_thread.daemon = True
|
||||
obstacle_thread.start()
|
||||
print("Surveillance d'obstacle en cours")
|
||||
|
||||
# Attendre avant de démarrer
|
||||
print("Le départ est prévu dans 10 secondes...")
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
print("5 secondes...")
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.HIGH)
|
||||
time.sleep(1)
|
||||
GPIO.output(Ab.RED_LIGHT, GPIO.LOW)
|
||||
time.sleep(1)
|
||||
print("Départ imminent !")
|
||||
try:
|
||||
# Appel de la fonction pour traiter les étapes sélectionnées
|
||||
# Appel de la fonction pour traiter les étapes sélectionnées
|
||||
process_selected_steps(selected_steps_filename)
|
||||
status = "scenario successful"
|
||||
except KeyboardInterrupt:
|
||||
print("Interruption par l'utilisateur.")
|
||||
status = "interrupted"
|
||||
except Exception as e:
|
||||
print(f"Erreur lors de l'exécution: {e}")
|
||||
status = "error"
|
||||
finally:
|
||||
# Arrêter les threads
|
||||
Ab.stop_event_vitesse.set()
|
||||
Ab.stop_event_obstacle.set()
|
||||
# Attendre que les threads se terminent
|
||||
vitesse_thread.join()
|
||||
obstacle_thread.join()
|
||||
print("Fin de surveillance de la vitesse")
|
||||
print("Fin de la surveillance d'obstacle")
|
||||
|
||||
Ab.LIDAR_MODULE.close() # Fermeture propre du port série
|
||||
Ab.cleanup()
|
||||
|
||||
# Vérification finale et affichage du statut
|
||||
if status in ["scenario successful"]:
|
||||
print("Le scenario fonctionne correctement.")
|
||||
fonctionnement_ok = True
|
||||
else:
|
||||
print(f"Le scenario a rencontré un problème : {status}.")
|
||||
fonctionnement_ok = False
|
||||
|
||||
Ab.enregistrer_resultats(sys.argv[0], fonctionnement_ok, status)
|
||||
56
WebControl/apps/lidar_speed_move.py
Normal file
56
WebControl/apps/lidar_speed_move.py
Normal file
@@ -0,0 +1,56 @@
|
||||
import time
|
||||
import sys
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from AlphaBot import AlphaBot
|
||||
Ab = AlphaBot()
|
||||
|
||||
# Variable de statut pour indiquer le bon fonctionnement
|
||||
status = "initialization"
|
||||
|
||||
# Durée limite d'exécution en secondes
|
||||
time_limit = 10
|
||||
start_time = time.time()
|
||||
try:
|
||||
# Envoi de la commande pour initialiser le capteur
|
||||
while True:
|
||||
# Vérification si le temps limite est dépassé
|
||||
if time.time() - start_time > time_limit:
|
||||
break
|
||||
|
||||
if Ab.LIDAR_MODULE.in_waiting >= 9:
|
||||
if b'Y' == Ab.LIDAR_MODULE.read() and b'Y' == Ab.LIDAR_MODULE.read():
|
||||
Dist_L = Ab.LIDAR_MODULE.read()
|
||||
Dist_H = Ab.LIDAR_MODULE.read()
|
||||
Dist_Total = (Dist_H[0] * 256) + Dist_L[0]
|
||||
for i in range(0, 5):
|
||||
Ab.LIDAR_MODULE.read() # Lecture et ignore des octets supplémentaires
|
||||
print("Distance à l'avant du véhicule:", Dist_Total, "cm")
|
||||
status = "measurement successful"
|
||||
|
||||
# Ajuster la vitesse en fonction de la distance LIDAR
|
||||
vitesse_ajustee = Ab.ajuster_vitesse_selon_distance(Dist_Total)
|
||||
|
||||
if vitesse_ajustee > 0:
|
||||
Ab.forward(0.1, vitesse_ajustee) # Avancer avec la vitesse ajustée
|
||||
else:
|
||||
Ab.emergencystop() # S'arrêter si trop proche d'un obstacle
|
||||
Ab.LIDAR_MODULE.reset_input_buffer()
|
||||
except KeyboardInterrupt:
|
||||
print("Interruption par l'utilisateur.")
|
||||
status = "interrupted"
|
||||
except Exception as e:
|
||||
print(f"Erreur lors de l'exécution: {e}")
|
||||
status = "error"
|
||||
finally:
|
||||
Ab.LIDAR_MODULE.close() # Fermeture propre du port série
|
||||
Ab.cleanup()
|
||||
|
||||
# Vérification finale et affichage du statut
|
||||
if status in ["measurement successful"]:
|
||||
print("Le composant fonctionne correctement.")
|
||||
fonctionnement_ok = True
|
||||
else:
|
||||
print(f"Le composant a rencontré un problème: {status}.")
|
||||
fonctionnement_ok = False
|
||||
|
||||
Ab.enregistrer_resultats(sys.argv[0], fonctionnement_ok, status)
|
||||
31
WebControl/apps/rfid_read_write_module.py
Normal file
31
WebControl/apps/rfid_read_write_module.py
Normal file
@@ -0,0 +1,31 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import time
|
||||
import sys
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from SimpleMFRC522 import SimpleMFRC522
|
||||
RFID_MODULE = SimpleMFRC522()
|
||||
from AlphaBot import AlphaBot
|
||||
Ab = AlphaBot()
|
||||
|
||||
try:
|
||||
# Lecture initiale du tag RFID
|
||||
print("### Lecture RFID ###")
|
||||
print("Approchez le tag RFID du capteur:")
|
||||
print("(ID, Contenu)", RFID_MODULE.read())
|
||||
time.sleep(3)
|
||||
# Écriture sur le tag RFID
|
||||
data = "TEST RFID "
|
||||
print("### Écriture RFID ###")
|
||||
print("Valeur qui sera écrite:", data)
|
||||
print("Approchez le tag RFID du capteur:")
|
||||
RFID_MODULE.write(data)
|
||||
print("Succès de l'écriture sur le tag RFID.")
|
||||
time.sleep(3) # Attente courte avant de vérifier l'écriture
|
||||
# Seconde lecture du tag RFID
|
||||
print("### Lecture RFID ###")
|
||||
print("Approchez le tag RFID du capteur:")
|
||||
print("(ID, Contenu)", RFID_MODULE.read())
|
||||
time.sleep(3)
|
||||
except Exception as e:
|
||||
print(f"Erreur lors de l'écriture RFID: {e}")
|
||||
71
WebControl/apps/scenario_rfid.py
Normal file
71
WebControl/apps/scenario_rfid.py
Normal file
@@ -0,0 +1,71 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import subprocess, time, sys
|
||||
sys.path.append('/home/christian/WebControl/modules/')
|
||||
from SimpleMFRC522 import SimpleMFRC522
|
||||
RFID_MODULE = SimpleMFRC522()
|
||||
from AlphaBot import AlphaBot
|
||||
Ab = AlphaBot()
|
||||
|
||||
status = "initialization"
|
||||
try:
|
||||
while True:
|
||||
time.sleep(3)
|
||||
# Ab.set_angle(0)
|
||||
print("La porte est actuellement fermée.\nVeuillez approcher votre badge RFID du capteur pour accéder au véhicule.")
|
||||
id_rfid, text_rfid = RFID_MODULE.read()
|
||||
rfid_content = RFID_MODULE.read()
|
||||
if text_rfid == "TEST RFID ":
|
||||
Ab.set_angle(90)
|
||||
print(f"Bienvenue, {text_rfid.rstrip()} \nJe suis heureux de pouvoir partager un trajet avec vous !")
|
||||
time.sleep(5)
|
||||
print("Installez-vous confortablement !")
|
||||
time.sleep(2)
|
||||
print("Votre voiture autonome est prête à partir.")
|
||||
try:
|
||||
subprocess.run(['python3', 'apps/itineraire_create.py'], check=True)
|
||||
try:
|
||||
print("Nous préparons votre trajet en toute sécurité.")
|
||||
Ab.set_angle(0)
|
||||
# Changer si nécessaire 'apps/itineraire_suivre.py' en 'apps/itineraire_suivre_emergency.py'
|
||||
subprocess.run(['python3', 'apps/itineraire_suivre_emergency.py'], check=True)
|
||||
print("Merci d'avoir utilisé notre service !")
|
||||
time.sleep(2)
|
||||
Ab.set_angle(90)
|
||||
print("Nous espérons que vous avez apprécié votre trajet.")
|
||||
time.sleep(2)
|
||||
print("À bientôt avec CARIA !")
|
||||
status = "scenario successful"
|
||||
except subprocess.CalledProcessError as e:
|
||||
print(f"Erreur lors de l'exécution du script step2_suivre_itineraire: {e}")
|
||||
status = "error"
|
||||
except subprocess.CalledProcessError as e:
|
||||
print(f"Erreur lors de l'exécution du script step1_prepare_itineraire: {e}")
|
||||
status = "error"
|
||||
elif text_rfid in ["CHRIS "]:
|
||||
Ab.set_angle(90)
|
||||
print(f"Bienvenue, {text_rfid.rstrip()}.\nLa porte du véhicule est maintenant ouverte!")
|
||||
status = "scenario successful"
|
||||
else:
|
||||
Ab.set_angle(0)
|
||||
print("Bonjour, vous n'êtes pas autorisé à entrer dans le véhicule.\nLa porte reste fermée.")
|
||||
print(rfid_content)
|
||||
time.sleep(2)
|
||||
status = "interrupted"
|
||||
except KeyboardInterrupt:
|
||||
print("Interruption par l'utilisateur.")
|
||||
status = "interrupted"
|
||||
except Exception as e:
|
||||
print(f"Erreur lors de l'exécution: {e}")
|
||||
status = "error"
|
||||
finally:
|
||||
Ab.PWMSERVO.stop()
|
||||
Ab.cleanup()
|
||||
# Vérification finale et affichage du statut
|
||||
if status == "movement successful":
|
||||
print("Le scenario fonctionne correctement.")
|
||||
fonctionnement_ok = True
|
||||
else:
|
||||
print(f"Le scenario a rencontré un problème: {status}.")
|
||||
fonctionnement_ok = False
|
||||
Ab.enregistrer_resultats(sys.argv[0], fonctionnement_ok, status)
|
||||
Reference in New Issue
Block a user