diff --git a/conf/flight_plans/flight_plan.dtd b/conf/flight_plans/flight_plan.dtd
index 7d1fbdeb12..fb18d5ce0e 100644
--- a/conf/flight_plans/flight_plan.dtd
+++ b/conf/flight_plans/flight_plan.dtd
@@ -159,7 +159,8 @@ var CDATA #REQUIRED
value CDATA #REQUIRED>
+fun CDATA #REQUIRED
+until CDATA #IMPLIED>
grid CDATA #REQUIRED
orientation CDATA #IMPLIED
wp1 CDATA #REQUIRED
-wp2 CDATA #REQUIRED>
+wp2 CDATA #REQUIRED
+until CDATA #IMPLIED>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/conf/messages.xml b/conf/messages.xml
index 435a83c755..29dafa2393 100644
--- a/conf/messages.xml
+++ b/conf/messages.xml
@@ -2251,6 +2251,139 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/conf/modules/mission_fw.xml b/conf/modules/mission_fw.xml
new file mode 100644
index 0000000000..096e896394
--- /dev/null
+++ b/conf/modules/mission_fw.xml
@@ -0,0 +1,32 @@
+
+
+
+
+
+ Interface for mission control of fixed wing aircraft.
+ This module parse datalink commands for basic navigation routines
+ and store them in a queue.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sw/airborne/modules/mission/mission.c b/sw/airborne/modules/mission/mission.c
new file mode 100644
index 0000000000..d3794bbca9
--- /dev/null
+++ b/sw/airborne/modules/mission/mission.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2013 ENAC
+ *
+ * This file is part of paparazzi.
+ *
+ * paparazzi is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * paparazzi is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with paparazzi; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+/** @file modules/mission/mission.c
+ * @brief messages parser for mission interface
+ */
+
+#include "modules/mission/mission.h"
+
+#include
+#include "generated/airframe.h"
+#include "subsystems/datalink/datalink.h"
+#include "subsystems/datalink/downlink.h"
+
+
+struct _mission mission;
+
+
+void mission_init(void) {
+ mission.insert_idx = 0;
+ mission.current_idx = 0;
+ mission.element_time = 0.;
+}
+
+bool_t mission_insert(enum MissionInsertMode insert, struct _mission_element * element) {
+ uint8_t tmp;
+
+ switch (insert) {
+ case Append:
+ tmp = (mission.insert_idx + 1) % MISSION_ELEMENT_NB;
+ if (tmp == mission.current_idx) return FALSE; // no room to insert element
+ memcpy(&mission.elements[mission.insert_idx], element, sizeof(struct _mission_element)); // add element
+ mission.insert_idx = tmp; // move insert index
+ break;
+ case Prepend:
+ if (mission.current_idx == 0) tmp = MISSION_ELEMENT_NB-1;
+ else tmp = mission.current_idx - 1;
+ if (tmp == mission.insert_idx) return FALSE; // no room to inser element
+ memcpy(&mission.elements[tmp], element, sizeof(struct _mission_element)); // add element
+ mission.current_idx = tmp; // move current index
+ break;
+ case ReplaceCurrent:
+ // current element can always be modified, index are not changed
+ memcpy(&mission.elements[mission.current_idx], element, sizeof(struct _mission_element));
+ break;
+ case ReplaceAll:
+ // reset queue and index
+ memcpy(&mission.elements[0], element, sizeof(struct _mission_element));
+ mission.insert_idx = 0;
+ mission.current_idx = 0;
+ break;
+ default:
+ // unknown insertion mode
+ return FALSE;
+ }
+ return TRUE;
+
+}
+
+struct _mission_element * mission_get(void) {
+ if (mission.current_idx == mission.insert_idx) {
+ return NULL;
+ }
+ return &(mission.elements[mission.current_idx]);
+}
+
+
+
+///////////////////////
+// Parsing functions //
+///////////////////////
+
+int mission_parse_GOTO_WP(void) {
+ if (DL_MISSION_GOTO_WP_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionWP;
+ me.element.mission_wp.wp.x = DL_MISSION_GOTO_WP_wp_east(dl_buffer);
+ me.element.mission_wp.wp.y = DL_MISSION_GOTO_WP_wp_north(dl_buffer);
+ me.element.mission_wp.wp.z = DL_MISSION_GOTO_WP_wp_alt(dl_buffer);
+ me.duration = DL_MISSION_GOTO_WP_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_GOTO_WP_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_GOTO_WP_LLA(void) {
+ if (DL_MISSION_GOTO_WP_LLA_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionWP;
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_GOTO_WP_LLA_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_CIRCLE(void) {
+ if (DL_MISSION_CIRCLE_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionCircle;
+ me.element.mission_circle.center.x = DL_MISSION_CIRCLE_center_east(dl_buffer);
+ me.element.mission_circle.center.y = DL_MISSION_CIRCLE_center_north(dl_buffer);
+ me.element.mission_circle.center.z = DL_MISSION_CIRCLE_center_alt(dl_buffer);
+ me.element.mission_circle.radius = DL_MISSION_CIRCLE_radius(dl_buffer);
+ me.duration = DL_MISSION_CIRCLE_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_CIRCLE_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_CIRCLE_LLA(void) {
+ if (DL_MISSION_CIRCLE_LLA_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionCircle;
+ me.element.mission_circle.radius = DL_MISSION_CIRCLE_LLA_radius(dl_buffer);
+ me.duration = DL_MISSION_CIRCLE_LLA_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_CIRCLE_LLA_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_SEGMENT(void) {
+ if (DL_MISSION_SEGMENT_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionSegment;
+ me.element.mission_segment.from.x = DL_MISSION_SEGMENT_segment_east_1(dl_buffer);
+ me.element.mission_segment.from.y = DL_MISSION_SEGMENT_segment_north_1(dl_buffer);
+ me.element.mission_segment.from.z = DL_MISSION_SEGMENT_segment_alt(dl_buffer);
+ me.element.mission_segment.to.x = DL_MISSION_SEGMENT_segment_east_2(dl_buffer);
+ me.element.mission_segment.to.y = DL_MISSION_SEGMENT_segment_north_2(dl_buffer);
+ me.element.mission_segment.to.z = DL_MISSION_SEGMENT_segment_alt(dl_buffer);
+ me.duration = DL_MISSION_SEGMENT_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_SEGMENT_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_SEGMENT_LLA(void) {
+ if (DL_MISSION_SEGMENT_LLA_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionSegment;
+ me.duration = DL_MISSION_SEGMENT_LLA_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_SEGMENT_LLA_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_PATH(void) {
+ if (DL_MISSION_PATH_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionPath;
+ me.element.mission_path.path[0].x = DL_MISSION_PATH_point_east_1(dl_buffer);
+ me.element.mission_path.path[0].y = DL_MISSION_PATH_point_north_1(dl_buffer);
+ me.element.mission_path.path[0].z = DL_MISSION_PATH_path_alt(dl_buffer);
+ me.element.mission_path.path[1].x = DL_MISSION_PATH_point_east_2(dl_buffer);
+ me.element.mission_path.path[1].y = DL_MISSION_PATH_point_north_2(dl_buffer);
+ me.element.mission_path.path[1].z = DL_MISSION_PATH_path_alt(dl_buffer);
+ me.element.mission_path.path[2].x = DL_MISSION_PATH_point_east_3(dl_buffer);
+ me.element.mission_path.path[2].y = DL_MISSION_PATH_point_north_3(dl_buffer);
+ me.element.mission_path.path[2].z = DL_MISSION_PATH_path_alt(dl_buffer);
+ me.element.mission_path.path[3].x = DL_MISSION_PATH_point_east_4(dl_buffer);
+ me.element.mission_path.path[3].y = DL_MISSION_PATH_point_north_4(dl_buffer);
+ me.element.mission_path.path[3].z = DL_MISSION_PATH_path_alt(dl_buffer);
+ me.element.mission_path.path[4].x = DL_MISSION_PATH_point_east_5(dl_buffer);
+ me.element.mission_path.path[4].y = DL_MISSION_PATH_point_north_5(dl_buffer);
+ me.element.mission_path.path[4].z = DL_MISSION_PATH_path_alt(dl_buffer);
+ me.element.mission_path.nb = DL_MISSION_PATH_nb(dl_buffer);
+ if (me.element.mission_path.nb > MISSION_PATH_NB) me.element.mission_path.nb = MISSION_PATH_NB;
+ me.element.mission_path.path_idx = 0;
+ me.duration = DL_MISSION_PATH_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_PATH_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_PATH_LLA(void) {
+ if (DL_MISSION_PATH_LLA_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ struct _mission_element me;
+ me.type = MissionPath;
+ me.element.mission_path.nb = DL_MISSION_PATH_LLA_nb(dl_buffer);
+ if (me.element.mission_path.nb > MISSION_PATH_NB) me.element.mission_path.nb = MISSION_PATH_NB;
+ me.element.mission_path.path_idx = 0;
+ me.duration = DL_MISSION_PATH_LLA_duration(dl_buffer);
+
+ enum MissionInsertMode insert = (enum MissionInsertMode) (DL_MISSION_PATH_LLA_insert(dl_buffer));
+
+ return mission_insert(insert, &me);
+}
+
+int mission_parse_GOTO_MISSION(void) {
+ if (DL_GOTO_MISSION_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ uint8_t mission_id = DL_GOTO_MISSION_mission_id(dl_buffer);
+ if (mission_id < MISSION_ELEMENT_NB) {
+ mission.current_idx = mission_id;
+ }
+ else return FALSE;
+
+ return TRUE;
+}
+
+int mission_parse_NEXT_MISSION(void) {
+ if (DL_NEXT_MISSION_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ if (mission.current_idx == mission.insert_idx) return FALSE; // already at the last position
+
+ // increment current index
+ mission.current_idx = (mission.current_idx + 1) % MISSION_ELEMENT_NB;
+ return TRUE;
+}
+
+int mission_parse_END_MISSION(void) {
+ if (DL_END_MISSION_ac_id(dl_buffer) != AC_ID) return FALSE; // not for this aircraft
+
+ // set current index to insert index (last position)
+ mission.current_idx = mission.insert_idx;
+ return TRUE;
+}
+
diff --git a/sw/airborne/modules/mission/mission.h b/sw/airborne/modules/mission/mission.h
new file mode 100644
index 0000000000..d423c48c12
--- /dev/null
+++ b/sw/airborne/modules/mission/mission.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2013 Gautier Hattenberger
+ *
+ * This file is part of paparazzi.
+ *
+ * paparazzi is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * paparazzi is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with paparazzi; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+/** @file modules/mission/mission.h
+ * @brief mission planner library
+ *
+ * Provide the generic interface for the mission control
+ * Handle the parsing of datalink messages
+ */
+
+#ifndef MISSION_H
+#define MISSION_H
+
+#include "std.h"
+#include "math/pprz_geodetic_float.h"
+
+enum MissionType {
+ MissionWP,
+ MissionCircle,
+ MissionSegment,
+ MissionPath,
+ MissionSurvey,
+ MissionEight,
+ MissionOval
+};
+
+enum MissionInsertMode {
+ Append, ///< add at the last position
+ Prepend, ///< add before the current element
+ ReplaceCurrent, ///< replace current element
+ ReplaceAll ///< remove all elements and add the new one
+};
+
+struct _mission_wp {
+ struct EnuCoor_f wp;
+};
+
+struct _mission_circle {
+ struct EnuCoor_f center;
+ float radius;
+};
+
+struct _mission_segment {
+ struct EnuCoor_f from;
+ struct EnuCoor_f to;
+};
+
+#define MISSION_PATH_NB 5
+struct _mission_path {
+ struct EnuCoor_f path[MISSION_PATH_NB];
+ uint8_t path_idx;
+ uint8_t nb;
+};
+
+struct _mission_element {
+ enum MissionType type;
+ union {
+ struct _mission_wp mission_wp;
+ struct _mission_circle mission_circle;
+ struct _mission_segment mission_segment;
+ struct _mission_path mission_path;
+ } element;
+ float duration; ///< time to spend in the element (<= 0 to disable)
+};
+
+#define MISSION_ELEMENT_NB 20
+struct _mission {
+ struct _mission_element elements[MISSION_ELEMENT_NB];
+ float element_time; ///< time in second spend in the current element
+ uint8_t insert_idx; ///< inserstion index
+ uint8_t current_idx; ///< current mission element index
+};
+
+extern struct _mission mission;
+
+/** Init mission structure
+ */
+extern void mission_init(void);
+
+/** Insert a mission element according to the insertion mode
+ * @param insert insertion mode
+ * @param element mission element structure
+ * @return return TRUE if insertion is succesful, FALSE otherwise
+ */
+extern bool_t mission_insert(enum MissionInsertMode insert, struct _mission_element * element);
+
+/** Get current mission element
+ * @return return a pointer to the next mission element or NULL if no more elements
+ */
+extern struct _mission_element * mission_get(void);
+
+/** Run mission
+ *
+ * This function should be implemented into a dedicated file since
+ * navigation functions are different for different firmwares
+ *
+ * Currently, this function should be called from the flight plan
+ *
+ * @return return TRUE when the mission is running, FALSE when it is finished
+ */
+extern int mission_run();
+
+/** Parsing functions called when a mission message is received
+ */
+extern int mission_parse_GOTO_WP(void);
+extern int mission_parse_GOTO_WP_LLA(void);
+extern int mission_parse_CIRCLE(void);
+extern int mission_parse_CIRCLE_LLA(void);
+extern int mission_parse_SEGMENT(void);
+extern int mission_parse_SEGMENT_LLA(void);
+extern int mission_parse_PATH(void);
+extern int mission_parse_PATH_LLA(void);
+extern int mission_parse_SURVEY(void);
+extern int mission_parse_SURVEY_LLA(void);
+extern int mission_parse_GOTO_MISSION(void);
+extern int mission_parse_NEXT_MISSION(void);
+extern int mission_parse_END_MISSION(void);
+
+/** Status report messages
+ * @todo
+ */
+
+#endif // MISSION
diff --git a/sw/airborne/modules/mission/mission_fw_nav.c b/sw/airborne/modules/mission/mission_fw_nav.c
new file mode 100644
index 0000000000..f0b24e8094
--- /dev/null
+++ b/sw/airborne/modules/mission/mission_fw_nav.c
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2013 Gautier Hattenberger
+ *
+ * This file is part of paparazzi.
+ *
+ * paparazzi is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * paparazzi is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with paparazzi; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+/** @file modules/mission/mission_fw_nav.c
+ * @brief mission navigation for fixedwing aircraft
+ *
+ * Implement specific navigation routines for the mission control
+ * of a fixedwing aircraft
+ */
+
+#include
+#include "modules/mission/mission.h"
+#include "firmwares/fixedwing/autopilot.h"
+#include "subsystems/nav.h"
+
+// navigation time step
+const float dt_navigation = 1.0 / ((float)NAVIGATION_FREQUENCY);
+
+// dirty hack to comply with nav_approaching_xy function
+struct EnuCoor_f last_wp = { 0., 0., 0. };
+
+/** Navigation function to a single waypoint
+ */
+static inline bool_t mission_nav_wp(struct _mission_wp * wp) {
+ if (nav_approaching_xy(wp->wp.x, wp->wp.y, last_wp.x, last_wp.y, CARROT)) {
+ last_wp = wp->wp; // store last wp
+ return FALSE; // end of mission element
+ }
+ // set navigation command
+ fly_to_xy(wp->wp.x, wp->wp.y);
+ NavVerticalAutoThrottleMode(0.);
+ NavVerticalAltitudeMode(wp->wp.z, 0.);
+ return TRUE;
+}
+
+/** Navigation function on a circle
+ */
+static inline bool_t mission_nav_circle(struct _mission_circle * circle) {
+ nav_circle_XY(circle->center.x, circle->center.y, circle->radius);
+ NavVerticalAutoThrottleMode(0.);
+ NavVerticalAltitudeMode(circle->center.z, 0.);
+ return TRUE;
+}
+
+/** Navigation function along a segment
+ */
+static inline bool_t mission_nav_segment(struct _mission_segment * segment) {
+ if (nav_approaching_xy(segment->to.x, segment->to.y, segment->from.x, segment->from.y, CARROT)) {
+ last_wp = segment->to;
+ return FALSE; // end of mission element
+ }
+ nav_route_xy(segment->from.x, segment->from.y, segment->to.x, segment->to.y);
+ NavVerticalAutoThrottleMode(0.);
+ NavVerticalAltitudeMode(segment->to.z, 0.); // both altitude should be the same anyway
+ return TRUE;
+}
+
+/** Navigation function along a path
+ */
+static inline bool_t mission_nav_path(struct _mission_path * path) {
+ if (path->nb == 0) {
+ return FALSE; // nothing to do
+ }
+ if (path->nb == 1) {
+ // handle as a single waypoint
+ struct _mission_wp wp = { path->path[0] };
+ return mission_nav_wp(&wp);
+ }
+ if (path->path_idx == path->nb-1) {
+ last_wp = path->path[path->path_idx]; // store last wp
+ return FALSE; // end of path
+ }
+ // normal case
+ struct EnuCoor_f from = path->path[path->path_idx];
+ struct EnuCoor_f to = path->path[path->path_idx+1];
+ nav_route_xy(from.x, from.y, to.x, to.y);
+ NavVerticalAutoThrottleMode(0.);
+ NavVerticalAltitudeMode(to.z, 0.); // both altitude should be the same anyway
+ if (nav_approaching_xy(to.x, to.y, from.x, from.y, CARROT)) {
+ path->path_idx++; // go to next segment
+ }
+ return TRUE;
+}
+
+
+int mission_run() {
+ // current element
+ struct _mission_element * el = NULL;
+ if ((el = mission_get()) == NULL) {
+ // TODO do something special like a waiting circle before ending the mission ?
+ return FALSE; // end of mission
+ }
+
+ bool_t el_running = FALSE;
+ switch (el->type){
+ case MissionWP:
+ el_running = mission_nav_wp(&(el->element.mission_wp));
+ break;
+ case MissionCircle:
+ el_running = mission_nav_circle(&(el->element.mission_circle));
+ break;
+ case MissionSegment:
+ el_running = mission_nav_segment(&(el->element.mission_segment));
+ break;
+ case MissionPath:
+ el_running = mission_nav_path(&(el->element.mission_path));
+ break;
+ default:
+ // invalid type or pattern not yet handled
+ break;
+ }
+
+ // increment element_time
+ mission.element_time += dt_navigation;
+
+ // test if element is finished or element time is elapsed
+ if (!el_running || (el->duration > 0. && mission.element_time >= el->duration)) {
+ // reset timer
+ mission.element_time = 0.;
+ // go to next element
+ mission.current_idx++;
+ }
+
+ return TRUE;
+}
+
+
diff --git a/sw/tools/gen_flight_plan.ml b/sw/tools/gen_flight_plan.ml
index ade969b63c..d0f466edf2 100644
--- a/sw/tools/gen_flight_plan.ml
+++ b/sw/tools/gen_flight_plan.ml
@@ -481,6 +481,13 @@ let rec print_stage = fun index_of_waypoints x ->
let statement = ExtXml.attrib x "fun" in
lprintf "if (! (%s))\n" statement;
lprintf " NextStageAndBreak();\n";
+ begin
+ try
+ let c = parsed_attrib x "until" in
+ lprintf "if (%s) NextStageAndBreak();\n" c
+ with
+ ExtXml.Error _ -> ()
+ end;
lprintf "break;\n"
| "survey_rectangle" ->
let grid = parsed_attrib x "grid"
@@ -495,6 +502,13 @@ let rec print_stage = fun index_of_waypoints x ->
left ();
stage ();
lprintf "NavSurveyRectangle(%s, %s);\n" wp1 wp2;
+ begin
+ try
+ let c = parsed_attrib x "until" in
+ lprintf "if (%s) NextStageAndBreak();\n" c
+ with
+ ExtXml.Error _ -> ()
+ end;
lprintf "break;\n"
| _s -> failwith "Unreachable"
end;