Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

navPathControl

Chemin représentant une trajectoire cinématique basée sur le contrôle

Depuis R2021b

Description

L'objet navPathControl stocke les chemins qui sont généralement créés par des planificateurs de chemin basés sur le contrôle, comme l'objet plannerControlRRT . L'objet navPathControl représente les chemins sous la forme d'une séquence d'états, de contrôles, de durées et de cibles. Cet objet associe chaque chemin à un propagateur d'état spécifique, qui propage les commandes de contrôle pour déterminer les états résultants.

Cet objet spécifie les états et les cibles dans le chemin dans l'espace d'état du propagateur. Les contrôles sont des sorties d'un contrôleur utilisées pour mettre à jour l'état de votre système pendant la propagation. Cet objet applique chaque contrôle pour une durée associée. Les commandes peuvent être des signaux de référence ou des entrées directes vers un intégrateur en fonction de la conception de votre système.

Création

Syntaxe

pathObj = navPathControl(propagator)

pathObj = navPathControl(propagator,states,controls,targets,durations)

Description

pathObj = navPathControl(propagator) crée un objet chemin avec le propagateur d'état spécifié. L'argument propagator spécifie le StatePropagator

pathObj = navPathControl(propagator,states,controls,targets,durations) initialise le chemin avec une séquence d'états, de contrôles, de cibles et de durées spécifiés. Les états d'entrée doivent avoir une ligne de plus que les autres vecteurs et matrices d'entrée.

Propriétés

StatePropagator — Propagateur d'état

objet de la sous-classe de nav.StatePropagator

Propagateur d'état, spécifié comme objet d'une sous-classe de nav.StatePropagator. Par exemple, l'objet mobileRobotPropagator représente l'espace d'état et le comportement de contrôle cinématique pour différents modèles de véhicules robots mobiles.

Types de données : double

States — Série d'états pour le chemin

[] (par défaut) | n-par- m matrice

Série d'états pour le chemin, spécifiés sous la forme d'une matrice n-par- m . n est le nombre de points sur le chemin. m est la dimension du vecteur d'état.

Vous pouvez spécifier cette propriété lors de la création de l'objet en utilisant l'argument states .

Types de données : double

Controls — Entrée de contrôle pour chaque état

[] (par défaut) | (n–1)-par- m matrice

Entrée de contrôle pour chaque état, spécifiée sous la forme d'une matrice (n–1)-par- m . n est le nombre de points sur le chemin. m est la dimension du vecteur d'état.

Vous pouvez spécifier cette propriété lors de la création de l'objet en utilisant l'argument controls .

Types de données : double

TargetStates — État cible pour chaque état du chemin

[] (par défaut) | (n–1)-par- m matrice

État cible pour chaque état du chemin, spécifié sous la forme d'une matrice (n–1)-par- m . n est le nombre de points sur le chemin. m est la dimension du vecteur d'état.

Vous pouvez spécifier cette propriété lors de la création de l'objet en utilisant l'argument targets .

Types de données : double

Durations — Durée de chaque entrée de contrôle

[] (par défaut) | (n–1)-élément vectoriel en secondes

Durée de chaque entrée de contrôle, spécifiée sous la forme d'un vecteur d'élément (n–1) en secondes. n est le nombre de points sur le chemin.

Vous pouvez spécifier cette propriété lors de la création de l'objet en utilisant l'argument durations .

Types de données : double

NumStates — Nombre d'états sur le chemin

0 (par défaut) | entier non négatif

Nombre d'états dans le chemin, spécifié sous forme d'entier positif.

Types de données : double

NumSegments — Nombre de segments entre les états

0 (par défaut) | entier non négatif

Nombre de segments entre les états du chemin, spécifié sous la forme d'un entier positif, qui doit être inférieur de un au nombre d'états.

Types de données : double

Fonctions d'objet

append	Ajouter des états à la fin du chemin
interpolate	Chemin d'interpolation en fonction de la taille du pas du propagateur
pathDuration	Durée totale écoulée du chemin de contrôle

Exemples

Planifier un chemin kinodynamique avec commandes pour robot mobile

Planifiez des trajectoires de contrôle pour un modèle cinématique de vélo avec l'objet mobileRobotPropagator . Spécifiez une carte pour l'environnement, définissez des limites d'état et définissez un emplacement de départ et un emplacement objectif. Planifiez un chemin à l'aide de l'algorithme RRT basé sur le contrôle, qui utilise un propagateur d'état pour planifier le mouvement et les commandes de contrôle requises.

Définir les paramètres d'état et de propagateur d'état

Chargez une matrice de carte ternaire et créez un objet occupancyMap . Créez le propagateur d'état à l'aide de la carte. Par défaut, le propagateur d'état utilise un modèle cinématique de vélo.

load('exampleMaps','ternaryMap')
map = occupancyMap(ternaryMap,10);

propagator = mobileRobotPropagator(Environment=map); % Bicycle model

Définissez les limites d'état sur l'espace d'état en fonction des limites du monde cartographique.

propagator.StateSpace.StateBounds(1:2,:) = ...
                    [map.XWorldLimits; map.YWorldLimits];

Planifier le chemin

Créez le planificateur de chemin à partir du propagateur d'état.

planner = plannerControlRRT(propagator);

Spécifiez les états de départ et d’objectif.

start = [10 15 0];
goal  = [40 30 0];

Planifiez un chemin entre les États. Pour des résultats reproductibles, réinitialisez le générateur de nombres aléatoires avant de planifier. La fonction plan génère un objet navPathControl , qui contient les états, les commandes de contrôle et les durées.

rng("default")
path = plan(planner,start,goal)

path = 
  navPathControl with properties:

    StatePropagator: [1x1 mobileRobotPropagator]
             States: [192x3 double]
           Controls: [191x2 double]
          Durations: [191x1 double]
       TargetStates: [191x3 double]
          NumStates: 192
        NumSegments: 191

Visualisez les résultats

Visualisez la carte et tracez les états du chemin.

show(map)
hold on
plot(start(1),start(2),"rx")
plot(goal(1),goal(2),"go")
plot(path.States(:,1),path.States(:,2),"b")
hold off

Affichez les entrées de contrôle [v psi] de la vitesse d'avancement et de l'angle de braquage.

plot(path.Controls)
ylim([-1 1])
legend(["Velocity (m/s)","Steering Angle (rad)"])

Combinez deux chemins kinodynamiques avec des commandes pour robot mobile

Définir les paramètres d'état et de propagateur d'état

Chargez une matrice de carte ternaire et créez un objet occupancyMap .

load("exampleMaps","ternaryMap")
map = occupancyMap(ternaryMap,10);

Créez un propagateur d'état pour un modèle cinématique de vélo à l'aide de la carte.

propagator = mobileRobotPropagator(Environment=map);

Définissez les limites d'état sur l'espace d'état en fonction des limites du monde cartographique.

propagator.StateSpace.StateBounds(1:2,:) = [map.XWorldLimits; 
                                            map.YWorldLimits];

Planifier le chemin

Créez le planificateur de chemin à partir du propagateur d'état.

planner = plannerControlRRT(propagator);

Spécifiez les états de départ et d’objectif.

start = [10 15 0];
goal  = [40 30 0];

Planifiez un chemin entre les États. Pour des résultats reproductibles, réinitialisez le générateur de nombres aléatoires avant de planifier.

rng("default")
path = plan(planner,start,goal);

Vérifiez la durée totale écoulée du chemin de contrôle.

pathDuration(path)

ans = 102.4000

Interpolez le chemin vers la taille du pas de contrôle du propagateur.

interpolate(path)

Visualisez le chemin.

figure
show(map)
hold on
plot(start(1),start(2),"rx")
plot(goal(1),goal(2),"go")
plot(path.States(:,1),path.States(:,2),"b")
hold off

Planifier le chemin de retour

Planifiez un deuxième chemin depuis la fin de l'emplacement du chemin précédent jusqu'au début.

path2 = plan(planner,path.States(end,:),start);

Vérifiez la durée totale écoulée du deuxième chemin.

pathDuration(path2)

ans = 100.3000

Visualisez le chemin.

figure
show(map)
hold on
plot(start(1),start(2),"rx")
plot(goal(1),goal(2),"go")
plot(path2.States(:,1),path2.States(:,2),"m")
hold off

Combiner les chemins

Extrayez la séquence de mouvements du deuxième chemin.

states = path2.States(2:end,:);
controls = path2.Controls;
targets = path2.TargetStates;
durations = path2.Durations;

Ajoutez cette séquence à la fin du premier chemin.

append(path,states,controls,targets,durations)

Interpolez les nouveaux segments dans le chemin d'origine.

interpolate(path)

Vérifiez la durée totale écoulée du chemin final.

pathDuration(path)

ans = 102.4000

Visualisez le chemin.

figure
show(map)
hold on
plot(start(1),start(2),"rx")
plot(goal(1),goal(2),"go")
plot(path.States(:,1),path.States(:,2),"b")
hold off

Historique des versions

Introduit dans R2021b

Voir aussi

Objets

• navPath | mobileRobotPropagator

Fonctions

• append | interpolate | pathDuration