From a60baf281f612d6d26ed328dba6f800cfdba027d Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Thu, 2 Apr 2015 19:09:38 +0100 Subject: [PATCH 01/75] OP-1803 Initial commit --- shared/uavobjectdefinition/receiverstatus.xml | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 shared/uavobjectdefinition/receiverstatus.xml diff --git a/shared/uavobjectdefinition/receiverstatus.xml b/shared/uavobjectdefinition/receiverstatus.xml new file mode 100644 index 000000000..5a0415be2 --- /dev/null +++ b/shared/uavobjectdefinition/receiverstatus.xml @@ -0,0 +1,11 @@ + + + Receiver status. + + + + + + + + From a0f180d393f0b5adafea64771421afbe305c65e5 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Thu, 2 Apr 2015 19:09:58 +0100 Subject: [PATCH 02/75] OP-1803 Initial commit --- flight/modules/Receiver/receiver.c | 21 ++++++++ flight/pios/common/pios_rcvr.c | 28 +++++++++++ flight/pios/common/pios_sbus.c | 50 ++++++++++++++++--- flight/pios/inc/pios_rcvr.h | 2 + .../boards/coptercontrol/firmware/Makefile | 1 + .../discoveryf4bare/firmware/UAVObjects.inc | 1 + .../boards/revolution/firmware/UAVObjects.inc | 1 + .../boards/revoproto/firmware/UAVObjects.inc | 1 + .../src/plugins/uavobjects/uavobjects.pro | 2 + 9 files changed, 99 insertions(+), 8 deletions(-) diff --git a/flight/modules/Receiver/receiver.c b/flight/modules/Receiver/receiver.c index 2f42b7eed..16b05c440 100644 --- a/flight/modules/Receiver/receiver.c +++ b/flight/modules/Receiver/receiver.c @@ -37,6 +37,7 @@ #include #include #include +#include #include #include #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES @@ -99,6 +100,7 @@ struct rcvr_activity_fsm { ManualControlSettingsChannelGroupsOptions group; uint16_t prev[RCVR_ACTIVITY_MONITOR_CHANNELS_PER_GROUP]; uint8_t sample_count; + uint8_t quality; }; static struct rcvr_activity_fsm activity_fsm; @@ -148,6 +150,18 @@ int32_t ReceiverInitialize() } MODULE_INITCALL(ReceiverInitialize, ReceiverStart); +static void updateRcvrStatus(uint32_t rcvr_id) +{ + extern uint32_t pios_rcvr_group_map[]; + + uint8_t quality = PIOS_RCVR_GetQuality(pios_rcvr_group_map[rcvr_id]); +#if 1 + ReceiverStatusQualitySet(&quality); +#else + quality = quality * 100 / 255; +#endif +} + /** * Module task */ @@ -243,6 +257,13 @@ static void receiverTask(__attribute__((unused)) void *parameters) } } + /* Update the receiver status, specifically signal quality, for the + * receiver used for flight mode control. + * + * SCEDEBUG Fixed to use S.Bus for now + */ + updateRcvrStatus(MANUALCONTROLSETTINGS_CHANNELGROUPS_SBUS); + // Check settings, if error raise alarm if (settings.ChannelGroups.Roll >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE || settings.ChannelGroups.Pitch >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE diff --git a/flight/pios/common/pios_rcvr.c b/flight/pios/common/pios_rcvr.c index b947c5142..66720ff5d 100644 --- a/flight/pios/common/pios_rcvr.c +++ b/flight/pios/common/pios_rcvr.c @@ -113,6 +113,34 @@ int32_t PIOS_RCVR_Read(uint32_t rcvr_id, uint8_t channel) return rcvr_dev->driver->read(rcvr_dev->lower_id, channel); } +/** + * @brief Reads input quality from the appropriate driver + * @param[in] rcvr_id driver to read from + * @returns Unitless input value + * @retval PIOS_RCVR_NODRIVER driver was not initialized + */ +uint8_t PIOS_RCVR_GetQuality(uint32_t rcvr_id) +{ + if (rcvr_id == 0) { + return PIOS_RCVR_NODRIVER; + } + + struct pios_rcvr_dev *rcvr_dev = (struct pios_rcvr_dev *)rcvr_id; + + if (!PIOS_RCVR_validate(rcvr_dev)) { + /* Undefined RCVR port for this board (see pios_board.c) */ + PIOS_Assert(0); + } + + if (!rcvr_dev->driver->get_quality) + { + /* If no quality is available assume max */ + return 255; + } + + return rcvr_dev->driver->get_quality(rcvr_dev->lower_id); +} + /** * @brief Get a semaphore that signals when a new sample is available. * @param[in] rcvr_id driver to read from diff --git a/flight/pios/common/pios_sbus.c b/flight/pios/common/pios_sbus.c index 69089e9cd..5531626c8 100644 --- a/flight/pios/common/pios_sbus.c +++ b/flight/pios/common/pios_sbus.c @@ -32,6 +32,8 @@ #ifdef PIOS_INCLUDE_SBUS +#include +#include #include "pios_sbus_priv.h" /* Forward Declarations */ @@ -42,11 +44,12 @@ static uint16_t PIOS_SBus_RxInCallback(uint32_t context, uint16_t *headroom, bool *need_yield); static void PIOS_SBus_Supervisor(uint32_t sbus_id); - +static uint8_t PIOS_SBus_Quality_Get(uint32_t rcvr_id); /* Local Variables */ const struct pios_rcvr_driver pios_sbus_rcvr_driver = { .read = PIOS_SBus_Get, + .get_quality = PIOS_SBus_Quality_Get }; enum pios_sbus_dev_magic { @@ -60,8 +63,14 @@ struct pios_sbus_state { uint8_t failsafe_timer; uint8_t frame_found; uint8_t byte_count; + uint8_t quality; }; +/* With an S.Bus frame rate of 7ms (130Hz) averaging over 26 samples + * gives about a 200ms response. + */ +#define SBUS_FL_WEIGHTED_AVE 26 + struct pios_sbus_dev { enum pios_sbus_dev_magic magic; const struct pios_sbus_cfg *cfg; @@ -120,6 +129,7 @@ static void PIOS_SBus_ResetState(struct pios_sbus_state *state) state->receive_timer = 0; state->failsafe_timer = 0; state->frame_found = 0; + state->quality = 0; PIOS_SBus_ResetChannels(state); } @@ -251,18 +261,29 @@ static void PIOS_SBus_UpdateState(struct pios_sbus_state *state, uint8_t b) state->byte_count++; } else { if (b == SBUS_EOF_BYTE || (b & SBUS_R7008SB_EOF_COUNTER_MASK) == 0) { + uint8_t quality_trend; + /* full frame received */ uint8_t flags = state->received_data[SBUS_FRAME_LENGTH - 3]; if (flags & SBUS_FLAG_FL) { /* frame lost, do not update */ - } else if (flags & SBUS_FLAG_FS) { - /* failsafe flag active */ - PIOS_SBus_ResetChannels(state); + /* Quality trend is towards 0% */ + quality_trend = 0; } else { - /* data looking good */ - PIOS_SBus_UnrollChannels(state); - state->failsafe_timer = 0; - } + /* Quality trend is towards 100% */ + quality_trend = 100; + if (flags & SBUS_FLAG_FS) { + /* failsafe flag active */ + PIOS_SBus_ResetChannels(state); + } else { + /* data looking good */ + PIOS_SBus_UnrollChannels(state); + state->failsafe_timer = 0; + } + } + /* Present quality as a weighted average of good frames */ + state->quality = ((state->quality * (SBUS_FL_WEIGHTED_AVE - 1)) + + quality_trend) / SBUS_FL_WEIGHTED_AVE; } else { /* discard whole frame */ } @@ -341,6 +362,19 @@ static void PIOS_SBus_Supervisor(uint32_t sbus_id) } } +static uint8_t PIOS_SBus_Quality_Get(uint32_t sbus_id) +{ + struct pios_sbus_dev *sbus_dev = (struct pios_sbus_dev *)sbus_id; + + bool valid = PIOS_SBus_Validate(sbus_dev); + + PIOS_Assert(valid); + + struct pios_sbus_state *state = &(sbus_dev->state); + + return state->quality; +} + #endif /* PIOS_INCLUDE_SBUS */ /** diff --git a/flight/pios/inc/pios_rcvr.h b/flight/pios/inc/pios_rcvr.h index 74fac086f..c289635d0 100644 --- a/flight/pios/inc/pios_rcvr.h +++ b/flight/pios/inc/pios_rcvr.h @@ -35,10 +35,12 @@ struct pios_rcvr_driver { void (*init)(uint32_t id); int32_t (*read)(uint32_t id, uint8_t channel); xSemaphoreHandle (*get_semaphore)(uint32_t id, uint8_t channel); + uint8_t (*get_quality)(uint32_t id); }; /* Public Functions */ extern int32_t PIOS_RCVR_Read(uint32_t rcvr_id, uint8_t channel); +extern uint8_t PIOS_RCVR_GetQuality(uint32_t rcvr_id); extern xSemaphoreHandle PIOS_RCVR_GetSemaphore(uint32_t rcvr_id, uint8_t channel); /*! Define error codes for PIOS_RCVR_Get */ diff --git a/flight/targets/boards/coptercontrol/firmware/Makefile b/flight/targets/boards/coptercontrol/firmware/Makefile index d58b57e64..8df60a8bf 100644 --- a/flight/targets/boards/coptercontrol/firmware/Makefile +++ b/flight/targets/boards/coptercontrol/firmware/Makefile @@ -122,6 +122,7 @@ ifndef TESTAPP SRC += $(OPUAVSYNTHDIR)/gpssettings.c SRC += $(OPUAVSYNTHDIR)/hwsettings.c SRC += $(OPUAVSYNTHDIR)/receiveractivity.c + SRC += $(OPUAVSYNTHDIR)/receiverstatus.c SRC += $(OPUAVSYNTHDIR)/mixerstatus.c SRC += $(OPUAVSYNTHDIR)/ratedesired.c SRC += $(OPUAVSYNTHDIR)/txpidsettings.c diff --git a/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc b/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc index 9f4007db8..d87f24086 100644 --- a/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc +++ b/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc @@ -103,6 +103,7 @@ UAVOBJSRCFILENAMES += watchdogstatus UAVOBJSRCFILENAMES += flightstatus UAVOBJSRCFILENAMES += hwsettings UAVOBJSRCFILENAMES += receiveractivity +UAVOBJSRCFILENAMES += receiverstatus UAVOBJSRCFILENAMES += cameradesired UAVOBJSRCFILENAMES += camerastabsettings UAVOBJSRCFILENAMES += altitudeholdsettings diff --git a/flight/targets/boards/revolution/firmware/UAVObjects.inc b/flight/targets/boards/revolution/firmware/UAVObjects.inc index 9f4007db8..d87f24086 100644 --- a/flight/targets/boards/revolution/firmware/UAVObjects.inc +++ b/flight/targets/boards/revolution/firmware/UAVObjects.inc @@ -103,6 +103,7 @@ UAVOBJSRCFILENAMES += watchdogstatus UAVOBJSRCFILENAMES += flightstatus UAVOBJSRCFILENAMES += hwsettings UAVOBJSRCFILENAMES += receiveractivity +UAVOBJSRCFILENAMES += receiverstatus UAVOBJSRCFILENAMES += cameradesired UAVOBJSRCFILENAMES += camerastabsettings UAVOBJSRCFILENAMES += altitudeholdsettings diff --git a/flight/targets/boards/revoproto/firmware/UAVObjects.inc b/flight/targets/boards/revoproto/firmware/UAVObjects.inc index 987266d1f..0d216aba4 100644 --- a/flight/targets/boards/revoproto/firmware/UAVObjects.inc +++ b/flight/targets/boards/revoproto/firmware/UAVObjects.inc @@ -103,6 +103,7 @@ UAVOBJSRCFILENAMES += watchdogstatus UAVOBJSRCFILENAMES += flightstatus UAVOBJSRCFILENAMES += hwsettings UAVOBJSRCFILENAMES += receiveractivity +UAVOBJSRCFILENAMES += receiverstatus UAVOBJSRCFILENAMES += cameradesired UAVOBJSRCFILENAMES += camerastabsettings UAVOBJSRCFILENAMES += altitudeholdsettings diff --git a/ground/openpilotgcs/src/plugins/uavobjects/uavobjects.pro b/ground/openpilotgcs/src/plugins/uavobjects/uavobjects.pro index 94225fc81..69e032ecc 100644 --- a/ground/openpilotgcs/src/plugins/uavobjects/uavobjects.pro +++ b/ground/openpilotgcs/src/plugins/uavobjects/uavobjects.pro @@ -112,6 +112,7 @@ HEADERS += \ $$UAVOBJECT_SYNTHETICS/hwsettings.h \ $$UAVOBJECT_SYNTHETICS/gcsreceiver.h \ $$UAVOBJECT_SYNTHETICS/receiveractivity.h \ + $$UAVOBJECT_SYNTHETICS/receiverstatus.h \ $$UAVOBJECT_SYNTHETICS/attitudesettings.h \ $$UAVOBJECT_SYNTHETICS/txpidsettings.h \ $$UAVOBJECT_SYNTHETICS/cameradesired.h \ @@ -219,6 +220,7 @@ SOURCES += \ $$UAVOBJECT_SYNTHETICS/hwsettings.cpp \ $$UAVOBJECT_SYNTHETICS/gcsreceiver.cpp \ $$UAVOBJECT_SYNTHETICS/receiveractivity.cpp \ + $$UAVOBJECT_SYNTHETICS/receiverstatus.cpp \ $$UAVOBJECT_SYNTHETICS/attitudesettings.cpp \ $$UAVOBJECT_SYNTHETICS/txpidsettings.cpp \ $$UAVOBJECT_SYNTHETICS/cameradesired.cpp \ From 2e5ecd2dce988ed31be7b980dd41b93e1ec9facd Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Thu, 2 Apr 2015 21:41:40 +0100 Subject: [PATCH 03/75] OP-1803 S.Bus signal quality monitoring --- flight/modules/Receiver/receiver.c | 61 ++++++++++++++++++---------- flight/modules/Telemetry/telemetry.c | 4 +- flight/pios/common/pios_rcvr.c | 7 ++-- flight/pios/common/pios_sbus.c | 34 ++++++++-------- 4 files changed, 62 insertions(+), 44 deletions(-) diff --git a/flight/modules/Receiver/receiver.c b/flight/modules/Receiver/receiver.c index 16b05c440..bdcc376a8 100644 --- a/flight/modules/Receiver/receiver.c +++ b/flight/modules/Receiver/receiver.c @@ -99,13 +99,17 @@ static void applyLPF(float *value, ManualControlSettingsResponseTimeElem channel struct rcvr_activity_fsm { ManualControlSettingsChannelGroupsOptions group; uint16_t prev[RCVR_ACTIVITY_MONITOR_CHANNELS_PER_GROUP]; - uint8_t sample_count; - uint8_t quality; + uint8_t sample_count; + uint8_t quality; }; static struct rcvr_activity_fsm activity_fsm; static void resetRcvrActivity(struct rcvr_activity_fsm *fsm); static bool updateRcvrActivity(struct rcvr_activity_fsm *fsm); +static void resetRcvrStatus(struct rcvr_activity_fsm *fsm); +static bool updateRcvrStatus( + struct rcvr_activity_fsm *fsm, + ManualControlSettingsChannelGroupsOptions group); #define assumptions \ ( \ @@ -140,6 +144,7 @@ int32_t ReceiverInitialize() AccessoryDesiredInitialize(); ManualControlCommandInitialize(); ReceiverActivityInitialize(); + ReceiverStatusInitialize(); ManualControlSettingsInitialize(); #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES StabilizationSettingsInitialize(); @@ -150,18 +155,6 @@ int32_t ReceiverInitialize() } MODULE_INITCALL(ReceiverInitialize, ReceiverStart); -static void updateRcvrStatus(uint32_t rcvr_id) -{ - extern uint32_t pios_rcvr_group_map[]; - - uint8_t quality = PIOS_RCVR_GetQuality(pios_rcvr_group_map[rcvr_id]); -#if 1 - ReceiverStatusQualitySet(&quality); -#else - quality = quality * 100 / 255; -#endif -} - /** * Module task */ @@ -187,6 +180,7 @@ static void receiverTask(__attribute__((unused)) void *parameters) /* Initialize the RcvrActivty FSM */ portTickType lastActivityTime = xTaskGetTickCount(); resetRcvrActivity(&activity_fsm); + resetRcvrStatus(&activity_fsm); // Main task loop lastSysTime = xTaskGetTickCount(); @@ -211,9 +205,13 @@ static void receiverTask(__attribute__((unused)) void *parameters) /* Reset the aging timer because activity was detected */ lastActivityTime = lastSysTime; } + /* Read signal quality from the group used for the throttle */ + (void)updateRcvrStatus(&activity_fsm, + settings.ChannelGroups.Throttle); } if (timeDifferenceMs(lastActivityTime, lastSysTime) > 5000) { resetRcvrActivity(&activity_fsm); + resetRcvrStatus(&activity_fsm); lastActivityTime = lastSysTime; } @@ -257,13 +255,6 @@ static void receiverTask(__attribute__((unused)) void *parameters) } } - /* Update the receiver status, specifically signal quality, for the - * receiver used for flight mode control. - * - * SCEDEBUG Fixed to use S.Bus for now - */ - updateRcvrStatus(MANUALCONTROLSETTINGS_CHANNELGROUPS_SBUS); - // Check settings, if error raise alarm if (settings.ChannelGroups.Roll >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE || settings.ChannelGroups.Pitch >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE @@ -529,6 +520,12 @@ static void resetRcvrActivity(struct rcvr_activity_fsm *fsm) fsm->sample_count = 0; } +static void resetRcvrStatus(struct rcvr_activity_fsm *fsm) +{ + /* Reset the state */ + fsm->quality = 0; +} + static void updateRcvrActivitySample(uint32_t rcvr_id, uint16_t samples[], uint8_t max_channels) { for (uint8_t channel = 1; channel <= max_channels; channel++) { @@ -599,6 +596,7 @@ static bool updateRcvrActivity(struct rcvr_activity_fsm *fsm) if (fsm->group >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE) { /* We're out of range, reset things */ resetRcvrActivity(fsm); + resetRcvrStatus(fsm); } extern uint32_t pios_rcvr_group_map[]; @@ -644,6 +642,27 @@ group_completed: return activity_updated; } +/* Read signal quality from the specified group */ +static bool updateRcvrStatus( + struct rcvr_activity_fsm *fsm, + ManualControlSettingsChannelGroupsOptions group) +{ + extern uint32_t pios_rcvr_group_map[]; + bool activity_updated = false; + uint8_t quality; + + quality = PIOS_RCVR_GetQuality(pios_rcvr_group_map[group]); + + /* Compare with previous sample */ + if (quality != fsm->quality) { + fsm->quality = quality; + ReceiverStatusQualitySet(&quality); + activity_updated = true; + } + + return activity_updated; +} + /** * Convert channel from servo pulse duration (microseconds) to scaled -1/+1 range. */ diff --git a/flight/modules/Telemetry/telemetry.c b/flight/modules/Telemetry/telemetry.c index ee7e53cda..0b653f652 100644 --- a/flight/modules/Telemetry/telemetry.c +++ b/flight/modules/Telemetry/telemetry.c @@ -221,9 +221,9 @@ int32_t TelemetryInitialize(void) timeOfLastObjectUpdate = 0; // Create object queues - localChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, + localChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, sizeof(UAVObjEvent)); - radioChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, + radioChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, sizeof(UAVObjEvent)); #if defined(PIOS_TELEM_PRIORITY_QUEUE) localChannel.priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, diff --git a/flight/pios/common/pios_rcvr.c b/flight/pios/common/pios_rcvr.c index 66720ff5d..590e9f213 100644 --- a/flight/pios/common/pios_rcvr.c +++ b/flight/pios/common/pios_rcvr.c @@ -132,10 +132,9 @@ uint8_t PIOS_RCVR_GetQuality(uint32_t rcvr_id) PIOS_Assert(0); } - if (!rcvr_dev->driver->get_quality) - { - /* If no quality is available assume max */ - return 255; + if (!rcvr_dev->driver->get_quality) { + /* If no quality is available assume max */ + return 255; } return rcvr_dev->driver->get_quality(rcvr_dev->lower_id); diff --git a/flight/pios/common/pios_sbus.c b/flight/pios/common/pios_sbus.c index 5531626c8..0d6a5e02e 100644 --- a/flight/pios/common/pios_sbus.c +++ b/flight/pios/common/pios_sbus.c @@ -48,7 +48,7 @@ static uint8_t PIOS_SBus_Quality_Get(uint32_t rcvr_id); /* Local Variables */ const struct pios_rcvr_driver pios_sbus_rcvr_driver = { - .read = PIOS_SBus_Get, + .read = PIOS_SBus_Get, .get_quality = PIOS_SBus_Quality_Get }; @@ -129,7 +129,7 @@ static void PIOS_SBus_ResetState(struct pios_sbus_state *state) state->receive_timer = 0; state->failsafe_timer = 0; state->frame_found = 0; - state->quality = 0; + state->quality = 0; PIOS_SBus_ResetChannels(state); } @@ -261,29 +261,29 @@ static void PIOS_SBus_UpdateState(struct pios_sbus_state *state, uint8_t b) state->byte_count++; } else { if (b == SBUS_EOF_BYTE || (b & SBUS_R7008SB_EOF_COUNTER_MASK) == 0) { - uint8_t quality_trend; + uint8_t quality_trend; /* full frame received */ uint8_t flags = state->received_data[SBUS_FRAME_LENGTH - 3]; if (flags & SBUS_FLAG_FL) { /* frame lost, do not update */ /* Quality trend is towards 0% */ - quality_trend = 0; + quality_trend = 0; } else { /* Quality trend is towards 100% */ - quality_trend = 100; - if (flags & SBUS_FLAG_FS) { - /* failsafe flag active */ - PIOS_SBus_ResetChannels(state); - } else { - /* data looking good */ - PIOS_SBus_UnrollChannels(state); - state->failsafe_timer = 0; - } - } - /* Present quality as a weighted average of good frames */ - state->quality = ((state->quality * (SBUS_FL_WEIGHTED_AVE - 1)) + - quality_trend) / SBUS_FL_WEIGHTED_AVE; + quality_trend = 100; + if (flags & SBUS_FLAG_FS) { + /* failsafe flag active */ + PIOS_SBus_ResetChannels(state); + } else { + /* data looking good */ + PIOS_SBus_UnrollChannels(state); + state->failsafe_timer = 0; + } + } + /* Present quality as a weighted average of good frames */ + state->quality = ((state->quality * (SBUS_FL_WEIGHTED_AVE - 1)) + + quality_trend) / SBUS_FL_WEIGHTED_AVE; } else { /* discard whole frame */ } From 8276aa3a66bf06a1b6b3a24c982b6146cc49d68f Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 3 Apr 2015 09:47:07 +0100 Subject: [PATCH 04/75] OP-1803 Monitor signal quality when armed too --- flight/modules/Receiver/receiver.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/flight/modules/Receiver/receiver.c b/flight/modules/Receiver/receiver.c index bdcc376a8..da26c23be 100644 --- a/flight/modules/Receiver/receiver.c +++ b/flight/modules/Receiver/receiver.c @@ -255,6 +255,10 @@ static void receiverTask(__attribute__((unused)) void *parameters) } } + /* Read signal quality from the group used for the throttle */ + (void)updateRcvrStatus(&activity_fsm, + settings.ChannelGroups.Throttle); + // Check settings, if error raise alarm if (settings.ChannelGroups.Roll >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE || settings.ChannelGroups.Pitch >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE From f9f0e1657c5b4a0124c7ddacad036da19e5686a4 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 3 Apr 2015 15:29:24 +0100 Subject: [PATCH 05/75] OP-1803 Add good frame count option for debug --- flight/pios/common/pios_sbus.c | 29 ++++++++++++++++++++++++++--- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/flight/pios/common/pios_sbus.c b/flight/pios/common/pios_sbus.c index 0d6a5e02e..778d91743 100644 --- a/flight/pios/common/pios_sbus.c +++ b/flight/pios/common/pios_sbus.c @@ -32,6 +32,9 @@ #ifdef PIOS_INCLUDE_SBUS +// Define to report number of frames since last dropped instead of weighted ave +#undef SBUS_GOOD_FRAME_COUNT + #include #include #include "pios_sbus_priv.h" @@ -64,6 +67,9 @@ struct pios_sbus_state { uint8_t frame_found; uint8_t byte_count; uint8_t quality; +#ifdef SBUS_GOOD_FRAME_COUNT + uint8_t frame_count; +#endif /* SBUS_GOOD_FRAME_COUNT */ }; /* With an S.Bus frame rate of 7ms (130Hz) averaging over 26 samples @@ -130,6 +136,9 @@ static void PIOS_SBus_ResetState(struct pios_sbus_state *state) state->failsafe_timer = 0; state->frame_found = 0; state->quality = 0; +#ifdef SBUS_GOOD_FRAME_COUNT + state->frame_count = 0; +#endif /* SBUS_GOOD_FRAME_COUNT */ PIOS_SBus_ResetChannels(state); } @@ -261,17 +270,29 @@ static void PIOS_SBus_UpdateState(struct pios_sbus_state *state, uint8_t b) state->byte_count++; } else { if (b == SBUS_EOF_BYTE || (b & SBUS_R7008SB_EOF_COUNTER_MASK) == 0) { - uint8_t quality_trend; +#ifndef SBUS_GOOD_FRAME_COUNT + /* Quality trend is towards 0% by default*/ + uint8_t quality_trend = 0; +#endif /* SBUS_GOOD_FRAME_COUNT */ /* full frame received */ uint8_t flags = state->received_data[SBUS_FRAME_LENGTH - 3]; if (flags & SBUS_FLAG_FL) { /* frame lost, do not update */ - /* Quality trend is towards 0% */ - quality_trend = 0; +#ifdef SBUS_GOOD_FRAME_COUNT + state->quality = state->frame_count; + state->frame_count = 0; +#endif /* SBUS_GOOD_FRAME_COUNT */ } else { +#ifdef SBUS_GOOD_FRAME_COUNT + if (++state->frame_count == 255) + { + state->quality = state->frame_count--; + } +#else /* SBUS_GOOD_FRAME_COUNT */ /* Quality trend is towards 100% */ quality_trend = 100; +#endif /* SBUS_GOOD_FRAME_COUNT */ if (flags & SBUS_FLAG_FS) { /* failsafe flag active */ PIOS_SBus_ResetChannels(state); @@ -281,9 +302,11 @@ static void PIOS_SBus_UpdateState(struct pios_sbus_state *state, uint8_t b) state->failsafe_timer = 0; } } +#ifndef SBUS_GOOD_FRAME_COUNT /* Present quality as a weighted average of good frames */ state->quality = ((state->quality * (SBUS_FL_WEIGHTED_AVE - 1)) + quality_trend) / SBUS_FL_WEIGHTED_AVE; +#endif /* SBUS_GOOD_FRAME_COUNT */ } else { /* discard whole frame */ } From 32b3f0d55de18ad7aa3932cecce2ed10c7f37edd Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 3 Apr 2015 15:45:00 +0100 Subject: [PATCH 06/75] OP-1803 Remove old header reference --- flight/pios/common/pios_sbus.c | 1 - 1 file changed, 1 deletion(-) diff --git a/flight/pios/common/pios_sbus.c b/flight/pios/common/pios_sbus.c index 778d91743..9cd2313e8 100644 --- a/flight/pios/common/pios_sbus.c +++ b/flight/pios/common/pios_sbus.c @@ -36,7 +36,6 @@ #undef SBUS_GOOD_FRAME_COUNT #include -#include #include "pios_sbus_priv.h" /* Forward Declarations */ From b5a3ad3708cecd693059ea5425332da8f3a122a9 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 3 Apr 2015 18:01:04 +0100 Subject: [PATCH 07/75] OP-1803 Use float to avoid rounding error on signal quality --- flight/pios/common/pios_sbus.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/flight/pios/common/pios_sbus.c b/flight/pios/common/pios_sbus.c index 9cd2313e8..b7d04c7d7 100644 --- a/flight/pios/common/pios_sbus.c +++ b/flight/pios/common/pios_sbus.c @@ -65,7 +65,7 @@ struct pios_sbus_state { uint8_t failsafe_timer; uint8_t frame_found; uint8_t byte_count; - uint8_t quality; + float quality; #ifdef SBUS_GOOD_FRAME_COUNT uint8_t frame_count; #endif /* SBUS_GOOD_FRAME_COUNT */ @@ -134,7 +134,7 @@ static void PIOS_SBus_ResetState(struct pios_sbus_state *state) state->receive_timer = 0; state->failsafe_timer = 0; state->frame_found = 0; - state->quality = 0; + state->quality = 0.0f; #ifdef SBUS_GOOD_FRAME_COUNT state->frame_count = 0; #endif /* SBUS_GOOD_FRAME_COUNT */ @@ -394,7 +394,7 @@ static uint8_t PIOS_SBus_Quality_Get(uint32_t sbus_id) struct pios_sbus_state *state = &(sbus_dev->state); - return state->quality; + return (uint8_t)(state->quality + 0.5f); } #endif /* PIOS_INCLUDE_SBUS */ From b7122008c7fa9b89e7cab3ace19c2d90e97b85e6 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 3 Apr 2015 18:30:36 +0100 Subject: [PATCH 08/75] OP-1803 Uncrustify --- flight/pios/common/pios_rcvr.c | 2 +- flight/pios/common/pios_sbus.c | 15 +++++++-------- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/flight/pios/common/pios_rcvr.c b/flight/pios/common/pios_rcvr.c index 590e9f213..89a827885 100644 --- a/flight/pios/common/pios_rcvr.c +++ b/flight/pios/common/pios_rcvr.c @@ -116,7 +116,7 @@ int32_t PIOS_RCVR_Read(uint32_t rcvr_id, uint8_t channel) /** * @brief Reads input quality from the appropriate driver * @param[in] rcvr_id driver to read from - * @returns Unitless input value + * @returns received signal quality expressed as a % * @retval PIOS_RCVR_NODRIVER driver was not initialized */ uint8_t PIOS_RCVR_GetQuality(uint32_t rcvr_id) diff --git a/flight/pios/common/pios_sbus.c b/flight/pios/common/pios_sbus.c index b7d04c7d7..e354a5c5f 100644 --- a/flight/pios/common/pios_sbus.c +++ b/flight/pios/common/pios_sbus.c @@ -136,7 +136,7 @@ static void PIOS_SBus_ResetState(struct pios_sbus_state *state) state->frame_found = 0; state->quality = 0.0f; #ifdef SBUS_GOOD_FRAME_COUNT - state->frame_count = 0; + state->frame_count = 0; #endif /* SBUS_GOOD_FRAME_COUNT */ PIOS_SBus_ResetChannels(state); } @@ -270,7 +270,7 @@ static void PIOS_SBus_UpdateState(struct pios_sbus_state *state, uint8_t b) } else { if (b == SBUS_EOF_BYTE || (b & SBUS_R7008SB_EOF_COUNTER_MASK) == 0) { #ifndef SBUS_GOOD_FRAME_COUNT - /* Quality trend is towards 0% by default*/ + /* Quality trend is towards 0% by default*/ uint8_t quality_trend = 0; #endif /* SBUS_GOOD_FRAME_COUNT */ @@ -279,15 +279,14 @@ static void PIOS_SBus_UpdateState(struct pios_sbus_state *state, uint8_t b) if (flags & SBUS_FLAG_FL) { /* frame lost, do not update */ #ifdef SBUS_GOOD_FRAME_COUNT - state->quality = state->frame_count; - state->frame_count = 0; + state->quality = state->frame_count; + state->frame_count = 0; #endif /* SBUS_GOOD_FRAME_COUNT */ } else { #ifdef SBUS_GOOD_FRAME_COUNT - if (++state->frame_count == 255) - { - state->quality = state->frame_count--; - } + if (++state->frame_count == 255) { + state->quality = state->frame_count--; + } #else /* SBUS_GOOD_FRAME_COUNT */ /* Quality trend is towards 100% */ quality_trend = 100; From b93d9e178e9c9ef038ef44c03a463ba786801eeb Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sat, 4 Apr 2015 14:50:08 +0100 Subject: [PATCH 09/75] OP-1803 Max signal quality is 100% --- flight/pios/common/pios_rcvr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flight/pios/common/pios_rcvr.c b/flight/pios/common/pios_rcvr.c index 89a827885..4ad7046ce 100644 --- a/flight/pios/common/pios_rcvr.c +++ b/flight/pios/common/pios_rcvr.c @@ -134,7 +134,7 @@ uint8_t PIOS_RCVR_GetQuality(uint32_t rcvr_id) if (!rcvr_dev->driver->get_quality) { /* If no quality is available assume max */ - return 255; + return 100; } return rcvr_dev->driver->get_quality(rcvr_dev->lower_id); From 73aeb5d65336cc81051ddbfcd8debe3b17fc98dc Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sat, 4 Apr 2015 22:02:54 +0100 Subject: [PATCH 10/75] OP-1803 Report link quality for OPLink --- flight/pios/common/pios_oplinkrcvr.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/flight/pios/common/pios_oplinkrcvr.c b/flight/pios/common/pios_oplinkrcvr.c index c4579a0b5..5c967c105 100644 --- a/flight/pios/common/pios_oplinkrcvr.c +++ b/flight/pios/common/pios_oplinkrcvr.c @@ -34,6 +34,7 @@ #include #include +#include #include static OPLinkReceiverData oplinkreceiverdata; @@ -41,9 +42,11 @@ static OPLinkReceiverData oplinkreceiverdata; /* Provide a RCVR driver */ static int32_t PIOS_OPLinkRCVR_Get(uint32_t rcvr_id, uint8_t channel); static void PIOS_oplinkrcvr_Supervisor(uint32_t ppm_id); +static uint8_t PIOS_OPLinkRCVR_Quality_Get(uint32_t oplinkrcvr_id); const struct pios_rcvr_driver pios_oplinkrcvr_rcvr_driver = { - .read = PIOS_OPLinkRCVR_Get, + .read = PIOS_OPLinkRCVR_Get, + .get_quality = PIOS_OPLinkRCVR_Quality_Get }; /* Local Variables */ @@ -186,6 +189,16 @@ static void PIOS_oplinkrcvr_Supervisor(uint32_t oplinkrcvr_id) oplinkrcvr_dev->Fresh = false; } +static uint8_t PIOS_OPLinkRCVR_Quality_Get(__attribute__((unused)) uint32_t oplinkrcvr_id) +{ + uint8_t oplink_quality; + + OPLinkStatusLinkQualityGet(&oplink_quality); + + /* link_status is in the range 0-128, so scale to a % */ + return oplink_quality * 100 / 128; +} + #endif /* PIOS_INCLUDE_OPLINKRCVR */ /** From 7c7b19ff2d0591ba416c61e301846d9bb87a95fb Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sat, 11 Apr 2015 10:10:04 +0100 Subject: [PATCH 11/75] OP-1289 Merge OP-1803 Only create local telemetry queues/tasks if needed --- flight/modules/Telemetry/telemetry.c | 134 +++++++++++++++------------ 1 file changed, 76 insertions(+), 58 deletions(-) diff --git a/flight/modules/Telemetry/telemetry.c b/flight/modules/Telemetry/telemetry.c index 58532ce78..9d3d1d5e6 100644 --- a/flight/modules/Telemetry/telemetry.c +++ b/flight/modules/Telemetry/telemetry.c @@ -157,36 +157,45 @@ static void updateSettings(channelContext *channel); */ int32_t TelemetryStart(void) { - UAVObjIterate(®isterLocalObject); + // Only start the local telemetry tasks if needed + if (localPort()) { + UAVObjIterate(®isterLocalObject); + + // Listen to objects of interest +#ifdef PIOS_TELEM_PRIORITY_QUEUE + GCSTelemetryStatsConnectQueue(localChannel.priorityQueue); +#else /* PIOS_TELEM_PRIORITY_QUEUE */ + GCSTelemetryStatsConnectQueue(localChannel.queue); +#endif /* PIOS_TELEM_PRIORITY_QUEUE */ + // Start telemetry tasks + xTaskCreate(telemetryTxTask, + "TelTx", + STACK_SIZE_TX_BYTES / 4, + &localChannel, + TASK_PRIORITY_TX, + &localChannel.txTaskHandle); + PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYTX, + localChannel.txTaskHandle); + xTaskCreate(telemetryRxTask, + "TelRx", + STACK_SIZE_RX_BYTES / 4, + &localChannel, + TASK_PRIORITY_RX, + &localChannel.rxTaskHandle); + PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYRX, + localChannel.rxTaskHandle); + } + + // Start the telemetry tasks associated with Radio/USB UAVObjIterate(®isterRadioObject); // Listen to objects of interest #ifdef PIOS_TELEM_PRIORITY_QUEUE - GCSTelemetryStatsConnectQueue(localChannel.priorityQueue); GCSTelemetryStatsConnectQueue(radioChannel.priorityQueue); #else /* PIOS_TELEM_PRIORITY_QUEUE */ - GCSTelemetryStatsConnectQueue(localChannel.queue); GCSTelemetryStatsConnectQueue(radioChannel.queue); #endif /* PIOS_TELEM_PRIORITY_QUEUE */ - // Start telemetry tasks - xTaskCreate(telemetryTxTask, - "TelTx", - STACK_SIZE_TX_BYTES / 4, - &localChannel, - TASK_PRIORITY_TX, - &localChannel.txTaskHandle); - PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYTX, - localChannel.txTaskHandle); - xTaskCreate(telemetryRxTask, - "TelRx", - STACK_SIZE_RX_BYTES / 4, - &localChannel, - TASK_PRIORITY_RX, - &localChannel.rxTaskHandle); - PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYRX, - localChannel.rxTaskHandle); - xTaskCreate(telemetryTxTask, "RadioTx", STACK_SIZE_RADIO_TX_BYTES / 4, @@ -207,6 +216,35 @@ int32_t TelemetryStart(void) return 0; } +/* Intialise a telemetry channel */ +void TelemetryInitializeChannel(channelContext *channel) +{ + // Create object queues + channel->queue = xQueueCreate(MAX_QUEUE_SIZE, + sizeof(UAVObjEvent)); +#if defined(PIOS_TELEM_PRIORITY_QUEUE) + channel->priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, + sizeof(UAVObjEvent)); +#endif /* PIOS_TELEM_PRIORITY_QUEUE */ + + // Initialise UAVTalk + channel->uavTalkCon = UAVTalkInitialize(&transmitLocalData); + + // Create periodic event that will be used to update the telemetry stats + UAVObjEvent ev; + memset(&ev, 0, sizeof(UAVObjEvent)); + +#ifdef PIOS_TELEM_PRIORITY_QUEUE + EventPeriodicQueueCreate(&ev, + channel->priorityQueue, + STATS_UPDATE_PERIOD_MS); +#else /* PIOS_TELEM_PRIORITY_QUEUE */ + EventPeriodicQueueCreate(&ev, + channel->queue, + STATS_UPDATE_PERIOD_MS); +#endif /* PIOS_TELEM_PRIORITY_QUEUE */ +} + /** * Initialise the telemetry module * \return -1 if initialisation failed @@ -214,58 +252,38 @@ int32_t TelemetryStart(void) */ int32_t TelemetryInitialize(void) { + HwSettingsInitialize(); + FlightTelemetryStatsInitialize(); GCSTelemetryStatsInitialize(); // Initialize vars - timeOfLastObjectUpdate = 0; + timeOfLastObjectUpdate = 0; - // Create object queues - localChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); - radioChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); -#if defined(PIOS_TELEM_PRIORITY_QUEUE) - localChannel.priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); - radioChannel.priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); -#endif /* PIOS_TELEM_PRIORITY_QUEUE */ + // Reset link stats + txErrors = 0; + txRetries = 0; // Set channel port handlers localChannel.getPort = localPort; radioChannel.getPort = radioPort; - HwSettingsInitialize(); + // Set the local telemetry baud rate updateSettings(&localChannel); + // Only initialise local channel if telemetry port enabled + if (localPort()) { + // Initialise channel + TelemetryInitializeChannel(&localChannel); + // Initialise UAVTalk + localChannel.uavTalkCon = UAVTalkInitialize(&transmitLocalData); + } + + // Initialise channel + TelemetryInitializeChannel(&radioChannel); // Initialise UAVTalk - localChannel.uavTalkCon = UAVTalkInitialize(&transmitLocalData); radioChannel.uavTalkCon = UAVTalkInitialize(&transmitRadioData); - // Create periodic event that will be used to update the telemetry stats - // FIXME STATS_UPDATE_PERIOD_MS is 4000ms while FlighTelemetryStats update period is 5000ms... - txErrors = 0; - txRetries = 0; - UAVObjEvent ev; - memset(&ev, 0, sizeof(UAVObjEvent)); - -#ifdef PIOS_TELEM_PRIORITY_QUEUE - EventPeriodicQueueCreate(&ev, - localChannel.priorityQueue, - STATS_UPDATE_PERIOD_MS); - EventPeriodicQueueCreate(&ev, - radioChannel.priorityQueue, - STATS_UPDATE_PERIOD_MS); -#else /* PIOS_TELEM_PRIORITY_QUEUE */ - EventPeriodicQueueCreate(&ev, - localChannel.queue, - STATS_UPDATE_PERIOD_MS); - EventPeriodicQueueCreate(&ev, - radioChannel.queue, - STATS_UPDATE_PERIOD_MS); -#endif /* PIOS_TELEM_PRIORITY_QUEUE */ - return 0; } From d2a69b2d449f0e0935e837d2ea31018c92a83ca8 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sat, 11 Apr 2015 10:10:04 +0100 Subject: [PATCH 12/75] OP-1803 Merge OP-1289 Only create local telemetry queues/tasks if needed --- flight/modules/Telemetry/telemetry.c | 134 +++++++++++++++------------ 1 file changed, 76 insertions(+), 58 deletions(-) diff --git a/flight/modules/Telemetry/telemetry.c b/flight/modules/Telemetry/telemetry.c index 58532ce78..9d3d1d5e6 100644 --- a/flight/modules/Telemetry/telemetry.c +++ b/flight/modules/Telemetry/telemetry.c @@ -157,36 +157,45 @@ static void updateSettings(channelContext *channel); */ int32_t TelemetryStart(void) { - UAVObjIterate(®isterLocalObject); + // Only start the local telemetry tasks if needed + if (localPort()) { + UAVObjIterate(®isterLocalObject); + + // Listen to objects of interest +#ifdef PIOS_TELEM_PRIORITY_QUEUE + GCSTelemetryStatsConnectQueue(localChannel.priorityQueue); +#else /* PIOS_TELEM_PRIORITY_QUEUE */ + GCSTelemetryStatsConnectQueue(localChannel.queue); +#endif /* PIOS_TELEM_PRIORITY_QUEUE */ + // Start telemetry tasks + xTaskCreate(telemetryTxTask, + "TelTx", + STACK_SIZE_TX_BYTES / 4, + &localChannel, + TASK_PRIORITY_TX, + &localChannel.txTaskHandle); + PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYTX, + localChannel.txTaskHandle); + xTaskCreate(telemetryRxTask, + "TelRx", + STACK_SIZE_RX_BYTES / 4, + &localChannel, + TASK_PRIORITY_RX, + &localChannel.rxTaskHandle); + PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYRX, + localChannel.rxTaskHandle); + } + + // Start the telemetry tasks associated with Radio/USB UAVObjIterate(®isterRadioObject); // Listen to objects of interest #ifdef PIOS_TELEM_PRIORITY_QUEUE - GCSTelemetryStatsConnectQueue(localChannel.priorityQueue); GCSTelemetryStatsConnectQueue(radioChannel.priorityQueue); #else /* PIOS_TELEM_PRIORITY_QUEUE */ - GCSTelemetryStatsConnectQueue(localChannel.queue); GCSTelemetryStatsConnectQueue(radioChannel.queue); #endif /* PIOS_TELEM_PRIORITY_QUEUE */ - // Start telemetry tasks - xTaskCreate(telemetryTxTask, - "TelTx", - STACK_SIZE_TX_BYTES / 4, - &localChannel, - TASK_PRIORITY_TX, - &localChannel.txTaskHandle); - PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYTX, - localChannel.txTaskHandle); - xTaskCreate(telemetryRxTask, - "TelRx", - STACK_SIZE_RX_BYTES / 4, - &localChannel, - TASK_PRIORITY_RX, - &localChannel.rxTaskHandle); - PIOS_TASK_MONITOR_RegisterTask(TASKINFO_RUNNING_TELEMETRYRX, - localChannel.rxTaskHandle); - xTaskCreate(telemetryTxTask, "RadioTx", STACK_SIZE_RADIO_TX_BYTES / 4, @@ -207,6 +216,35 @@ int32_t TelemetryStart(void) return 0; } +/* Intialise a telemetry channel */ +void TelemetryInitializeChannel(channelContext *channel) +{ + // Create object queues + channel->queue = xQueueCreate(MAX_QUEUE_SIZE, + sizeof(UAVObjEvent)); +#if defined(PIOS_TELEM_PRIORITY_QUEUE) + channel->priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, + sizeof(UAVObjEvent)); +#endif /* PIOS_TELEM_PRIORITY_QUEUE */ + + // Initialise UAVTalk + channel->uavTalkCon = UAVTalkInitialize(&transmitLocalData); + + // Create periodic event that will be used to update the telemetry stats + UAVObjEvent ev; + memset(&ev, 0, sizeof(UAVObjEvent)); + +#ifdef PIOS_TELEM_PRIORITY_QUEUE + EventPeriodicQueueCreate(&ev, + channel->priorityQueue, + STATS_UPDATE_PERIOD_MS); +#else /* PIOS_TELEM_PRIORITY_QUEUE */ + EventPeriodicQueueCreate(&ev, + channel->queue, + STATS_UPDATE_PERIOD_MS); +#endif /* PIOS_TELEM_PRIORITY_QUEUE */ +} + /** * Initialise the telemetry module * \return -1 if initialisation failed @@ -214,58 +252,38 @@ int32_t TelemetryStart(void) */ int32_t TelemetryInitialize(void) { + HwSettingsInitialize(); + FlightTelemetryStatsInitialize(); GCSTelemetryStatsInitialize(); // Initialize vars - timeOfLastObjectUpdate = 0; + timeOfLastObjectUpdate = 0; - // Create object queues - localChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); - radioChannel.queue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); -#if defined(PIOS_TELEM_PRIORITY_QUEUE) - localChannel.priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); - radioChannel.priorityQueue = xQueueCreate(MAX_QUEUE_SIZE, - sizeof(UAVObjEvent)); -#endif /* PIOS_TELEM_PRIORITY_QUEUE */ + // Reset link stats + txErrors = 0; + txRetries = 0; // Set channel port handlers localChannel.getPort = localPort; radioChannel.getPort = radioPort; - HwSettingsInitialize(); + // Set the local telemetry baud rate updateSettings(&localChannel); + // Only initialise local channel if telemetry port enabled + if (localPort()) { + // Initialise channel + TelemetryInitializeChannel(&localChannel); + // Initialise UAVTalk + localChannel.uavTalkCon = UAVTalkInitialize(&transmitLocalData); + } + + // Initialise channel + TelemetryInitializeChannel(&radioChannel); // Initialise UAVTalk - localChannel.uavTalkCon = UAVTalkInitialize(&transmitLocalData); radioChannel.uavTalkCon = UAVTalkInitialize(&transmitRadioData); - // Create periodic event that will be used to update the telemetry stats - // FIXME STATS_UPDATE_PERIOD_MS is 4000ms while FlighTelemetryStats update period is 5000ms... - txErrors = 0; - txRetries = 0; - UAVObjEvent ev; - memset(&ev, 0, sizeof(UAVObjEvent)); - -#ifdef PIOS_TELEM_PRIORITY_QUEUE - EventPeriodicQueueCreate(&ev, - localChannel.priorityQueue, - STATS_UPDATE_PERIOD_MS); - EventPeriodicQueueCreate(&ev, - radioChannel.priorityQueue, - STATS_UPDATE_PERIOD_MS); -#else /* PIOS_TELEM_PRIORITY_QUEUE */ - EventPeriodicQueueCreate(&ev, - localChannel.queue, - STATS_UPDATE_PERIOD_MS); - EventPeriodicQueueCreate(&ev, - radioChannel.queue, - STATS_UPDATE_PERIOD_MS); -#endif /* PIOS_TELEM_PRIORITY_QUEUE */ - return 0; } From b87a1c1fa6a73633b7eb6d1773e473bc6370f514 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sun, 19 Apr 2015 18:41:04 +0100 Subject: [PATCH 13/75] OP-1803 Enable DSM link quality so testers have something to work with --- flight/pios/stm32f10x/pios_dsm.c | 56 +++++++++++++++++++++++--------- flight/pios/stm32f4xx/pios_dsm.c | 56 +++++++++++++++++++++++--------- 2 files changed, 81 insertions(+), 31 deletions(-) diff --git a/flight/pios/stm32f10x/pios_dsm.c b/flight/pios/stm32f10x/pios_dsm.c index 0a3450a9f..a058ee9c2 100644 --- a/flight/pios/stm32f10x/pios_dsm.c +++ b/flight/pios/stm32f10x/pios_dsm.c @@ -34,9 +34,12 @@ #include "pios_dsm_priv.h" +// *** UNTESTED CODE *** +#define DSM_LINK_QUALITY /* Forward Declarations */ static int32_t PIOS_DSM_Get(uint32_t rcvr_id, uint8_t channel); +static uint8_t PIOS_DSM_Quality_Get(uint32_t rcvr_id); static uint16_t PIOS_DSM_RxInCallback(uint32_t context, uint8_t *buf, uint16_t buf_len, @@ -46,7 +49,8 @@ static void PIOS_DSM_Supervisor(uint32_t dsm_id); /* Local Variables */ const struct pios_rcvr_driver pios_dsm_rcvr_driver = { - .read = PIOS_DSM_Get, + .read = PIOS_DSM_Get, + .get_quality = PIOS_DSM_Quality_Get }; enum pios_dsm_dev_magic { @@ -60,12 +64,15 @@ struct pios_dsm_state { uint8_t failsafe_timer; uint8_t frame_found; uint8_t byte_count; -#ifdef DSM_LOST_FRAME_COUNTER uint8_t frames_lost_last; - uint16_t frames_lost; -#endif + float quality; }; +/* With an DSM frame rate of 11ms (90Hz) averaging over 18 samples + * gives about a 200ms response. + */ +#define DSM_FL_WEIGHTED_AVE 18 + struct pios_dsm_dev { enum pios_dsm_dev_magic magic; const struct pios_dsm_cfg *cfg; @@ -164,10 +171,8 @@ static void PIOS_DSM_ResetState(struct pios_dsm_dev *dsm_dev) state->receive_timer = 0; state->failsafe_timer = 0; state->frame_found = 0; -#ifdef DSM_LOST_FRAME_COUNTER + state->quality = 0.0f; state->frames_lost_last = 0; - state->frames_lost = 0; -#endif PIOS_DSM_ResetChannels(dsm_dev); } @@ -183,13 +188,24 @@ static int PIOS_DSM_UnrollChannels(struct pios_dsm_dev *dsm_dev) static uint8_t resolution = 11; uint32_t channel_log = 0; -#ifdef DSM_LOST_FRAME_COUNTER + // *** UNTESTED CODE *** +#ifdef DSM_LINK_QUALITY /* increment the lost frame counter */ uint8_t frames_lost = state->received_data[0]; - state->frames_lost += (frames_lost - state->frames_lost_last); - state->frames_lost_last = frames_lost; -#endif + /* We only get a lost frame count when the next good frame comes in */ + /* Present quality as a weighted average of good frames */ + /* First consider the bad frames */ + for (int i = 0; i < frames_lost - state->frames_lost_last; i++) { + state->quality = (state->quality * (DSM_FL_WEIGHTED_AVE - 1)) / + DSM_FL_WEIGHTED_AVE; + } + /* And now the good frame */ + state->quality = ((state->quality * (DSM_FL_WEIGHTED_AVE - 1)) + + 100) / DSM_FL_WEIGHTED_AVE; + + state->frames_lost_last = frames_lost; +#endif /* DSM_LINK_QUALITY */ /* unroll channels */ uint8_t *s = &(state->received_data[2]); @@ -238,11 +254,6 @@ static int PIOS_DSM_UnrollChannels(struct pios_dsm_dev *dsm_dev) } } -#ifdef DSM_LOST_FRAME_COUNTER - /* put lost frames counter into the last channel for debugging */ - state->channel_data[PIOS_DSM_NUM_INPUTS - 1] = state->frames_lost; -#endif - /* all channels processed */ return 0; @@ -406,6 +417,19 @@ static void PIOS_DSM_Supervisor(uint32_t dsm_id) } } +static uint8_t PIOS_DSM_Quality_Get(uint32_t dsm_id) +{ + struct pios_dsm_dev *dsm_dev = (struct pios_dsm_dev *)dsm_id; + + bool valid = PIOS_DSM_Validate(dsm_dev); + + PIOS_Assert(valid); + + struct pios_dsm_state *state = &(dsm_dev->state); + + return (uint8_t)(state->quality + 0.5f); +} + #endif /* PIOS_INCLUDE_DSM */ /** diff --git a/flight/pios/stm32f4xx/pios_dsm.c b/flight/pios/stm32f4xx/pios_dsm.c index 055f9505c..764bc231b 100644 --- a/flight/pios/stm32f4xx/pios_dsm.c +++ b/flight/pios/stm32f4xx/pios_dsm.c @@ -34,12 +34,16 @@ #include "pios_dsm_priv.h" +// *** UNTESTED CODE *** +#define DSM_LINK_QUALITY + #ifndef PIOS_INCLUDE_RTC #error PIOS_INCLUDE_RTC must be used to use DSM #endif /* Forward Declarations */ static int32_t PIOS_DSM_Get(uint32_t rcvr_id, uint8_t channel); +static uint8_t PIOS_DSM_Quality_Get(uint32_t rcvr_id); static uint16_t PIOS_DSM_RxInCallback(uint32_t context, uint8_t *buf, uint16_t buf_len, @@ -49,7 +53,8 @@ static void PIOS_DSM_Supervisor(uint32_t dsm_id); /* Local Variables */ const struct pios_rcvr_driver pios_dsm_rcvr_driver = { - .read = PIOS_DSM_Get, + .read = PIOS_DSM_Get, + .get_quality = PIOS_DSM_Quality_Get }; enum pios_dsm_dev_magic { @@ -63,12 +68,15 @@ struct pios_dsm_state { uint8_t failsafe_timer; uint8_t frame_found; uint8_t byte_count; -#ifdef DSM_LOST_FRAME_COUNTER uint8_t frames_lost_last; - uint16_t frames_lost; -#endif + float quality; }; +/* With an DSM frame rate of 11ms (90Hz) averaging over 18 samples + * gives about a 200ms response. + */ +#define DSM_FL_WEIGHTED_AVE 18 + struct pios_dsm_dev { enum pios_dsm_dev_magic magic; const struct pios_dsm_cfg *cfg; @@ -167,10 +175,8 @@ static void PIOS_DSM_ResetState(struct pios_dsm_dev *dsm_dev) state->receive_timer = 0; state->failsafe_timer = 0; state->frame_found = 0; -#ifdef DSM_LOST_FRAME_COUNTER + state->quality = 0.0f; state->frames_lost_last = 0; - state->frames_lost = 0; -#endif PIOS_DSM_ResetChannels(dsm_dev); } @@ -186,12 +192,24 @@ static int PIOS_DSM_UnrollChannels(struct pios_dsm_dev *dsm_dev) static uint8_t resolution = 11; uint32_t channel_log = 0; -#ifdef DSM_LOST_FRAME_COUNTER + // *** UNTESTED CODE *** +#ifdef DSM_LINK_QUALITY /* increment the lost frame counter */ uint8_t frames_lost = state->received_data[0]; - state->frames_lost += (frames_lost - state->frames_lost_last); + + /* We only get a lost frame count when the next good frame comes in */ + /* Present quality as a weighted average of good frames */ + /* First consider the bad frames */ + for (int i = 0; i < frames_lost - state->frames_lost_last; i++) { + state->quality = (state->quality * (DSM_FL_WEIGHTED_AVE - 1)) / + DSM_FL_WEIGHTED_AVE; + } + /* And now the good frame */ + state->quality = ((state->quality * (DSM_FL_WEIGHTED_AVE - 1)) + + 100) / DSM_FL_WEIGHTED_AVE; + state->frames_lost_last = frames_lost; -#endif +#endif /* DSM_LINK_QUALITY */ /* unroll channels */ uint8_t *s = &(state->received_data[2]); @@ -240,11 +258,6 @@ static int PIOS_DSM_UnrollChannels(struct pios_dsm_dev *dsm_dev) } } -#ifdef DSM_LOST_FRAME_COUNTER - /* put lost frames counter into the last channel for debugging */ - state->channel_data[PIOS_DSM_NUM_INPUTS - 1] = state->frames_lost; -#endif - /* all channels processed */ return 0; @@ -408,6 +421,19 @@ static void PIOS_DSM_Supervisor(uint32_t dsm_id) } } +static uint8_t PIOS_DSM_Quality_Get(uint32_t dsm_id) +{ + struct pios_dsm_dev *dsm_dev = (struct pios_dsm_dev *)dsm_id; + + bool valid = PIOS_DSM_Validate(dsm_dev); + + PIOS_Assert(valid); + + struct pios_dsm_state *state = &(dsm_dev->state); + + return (uint8_t)(state->quality + 0.5f); +} + #endif /* PIOS_INCLUDE_DSM */ /** From d28831008f4b49ad65c88bd872eae33c618b3e7e Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Mon, 20 Apr 2015 21:40:42 +0100 Subject: [PATCH 14/75] OP-1803 Return link quality of zero rather than throw an exception if no receiver if the receiver port is undefined --- flight/pios/common/pios_rcvr.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/flight/pios/common/pios_rcvr.c b/flight/pios/common/pios_rcvr.c index 4ad7046ce..afae44b2a 100644 --- a/flight/pios/common/pios_rcvr.c +++ b/flight/pios/common/pios_rcvr.c @@ -129,7 +129,8 @@ uint8_t PIOS_RCVR_GetQuality(uint32_t rcvr_id) if (!PIOS_RCVR_validate(rcvr_dev)) { /* Undefined RCVR port for this board (see pios_board.c) */ - PIOS_Assert(0); + /* As no receiver is available assume min */ + return 0; } if (!rcvr_dev->driver->get_quality) { From 955f3145416c6ee9d1ba53bb5b58eebdbe4d7a4c Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 21 Apr 2015 23:29:08 +1000 Subject: [PATCH 15/75] OP-1848 altvario rewrite - initial checkin TODO: 1) update uavos 2) check dT --- .../pid}/pidcontroldown.cpp | 16 ++-- .../inc => libraries/pid}/pidcontroldown.h | 6 +- flight/libraries/pid/pidcontroldowncallback.h | 42 +++++++++ .../PathFollower/inc/pathfollowerfsm.h | 3 +- .../{altitudeloop.c => altitudeloop.cpp} | 89 +++++++++++-------- make/apps-defs.mk | 8 ++ 6 files changed, 116 insertions(+), 48 deletions(-) rename flight/{modules/PathFollower => libraries/pid}/pidcontroldown.cpp (96%) rename flight/{modules/PathFollower/inc => libraries/pid}/pidcontroldown.h (96%) create mode 100644 flight/libraries/pid/pidcontroldowncallback.h rename flight/modules/Stabilization/{altitudeloop.c => altitudeloop.cpp} (65%) diff --git a/flight/modules/PathFollower/pidcontroldown.cpp b/flight/libraries/pid/pidcontroldown.cpp similarity index 96% rename from flight/modules/PathFollower/pidcontroldown.cpp rename to flight/libraries/pid/pidcontroldown.cpp index ea01b7e06..04ae1cddf 100644 --- a/flight/modules/PathFollower/pidcontroldown.cpp +++ b/flight/libraries/pid/pidcontroldown.cpp @@ -45,7 +45,6 @@ extern "C" { #include } -#include "pathfollowerfsm.h" #include "pidcontroldown.h" #define NEUTRALTHRUST_PH_POSITIONAL_ERROR_LIMIT 0.5f @@ -59,7 +58,7 @@ extern "C" { PIDControlDown::PIDControlDown() : deltaTime(0.0f), mVelocitySetpointTarget(0.0f), mVelocitySetpointCurrent(0.0f), mVelocityState(0.0f), mDownCommand(0.0f), - mFSM(NULL), mNeutral(0.5f), mVelocityMax(1.0f), mPositionSetpointTarget(0.0f), mPositionState(0.0f), + mCallback(NULL), mNeutral(0.5f), mVelocityMax(1.0f), mPositionSetpointTarget(0.0f), mPositionState(0.0f), mMinThrust(0.1f), mMaxThrust(0.6f), mActive(false) { Deactivate(); @@ -67,9 +66,9 @@ PIDControlDown::PIDControlDown() PIDControlDown::~PIDControlDown() {} -void PIDControlDown::Initialize(PathFollowerFSM *fsm) +void PIDControlDown::Initialize(PIDControlDownCallback *callback) { - mFSM = fsm; + mCallback = callback; } void PIDControlDown::SetThrustLimits(float min_thrust, float max_thrust) @@ -80,7 +79,6 @@ void PIDControlDown::SetThrustLimits(float min_thrust, float max_thrust) void PIDControlDown::Deactivate() { - // pid_zero(&PID); mActive = false; } @@ -333,9 +331,9 @@ void PIDControlDown::UpdateVelocityState(float pv) { mVelocityState = pv; - if (mFSM) { + if (mCallback) { // The FSM controls the actual descent velocity and introduces step changes as required - float velocitySetpointDesired = mFSM->BoundVelocityDown(mVelocitySetpointTarget); + float velocitySetpointDesired = mCallback->BoundVelocityDown(mVelocitySetpointTarget); // RateLimit(velocitySetpointDesired, mVelocitySetpointCurrent, 2.0f ); mVelocitySetpointCurrent = velocitySetpointDesired; } else { @@ -354,8 +352,8 @@ float PIDControlDown::GetDownCommand(void) float ulow = mMinThrust; float uhigh = mMaxThrust; - if (mFSM) { - mFSM->BoundThrust(ulow, uhigh); + if (mCallback) { + mCallback->BoundThrust(ulow, uhigh); } float downCommand = pid2_apply(&PID, mVelocitySetpointCurrent, mVelocityState, ulow, uhigh); pidStatus.setpoint = mVelocitySetpointCurrent; diff --git a/flight/modules/PathFollower/inc/pidcontroldown.h b/flight/libraries/pid/pidcontroldown.h similarity index 96% rename from flight/modules/PathFollower/inc/pidcontroldown.h rename to flight/libraries/pid/pidcontroldown.h index 9546e2e75..b7c215430 100644 --- a/flight/modules/PathFollower/inc/pidcontroldown.h +++ b/flight/libraries/pid/pidcontroldown.h @@ -34,13 +34,13 @@ extern "C" { #include #include } -#include "pathfollowerfsm.h" +#include "pidcontroldowncallback.h" class PIDControlDown { public: PIDControlDown(); ~PIDControlDown(); - void Initialize(PathFollowerFSM *fsm); + void Initialize(PIDControlDownCallback *callback); void SetThrustLimits(float min_thrust, float max_thrust); void Deactivate(); void Activate(); @@ -69,7 +69,7 @@ private: float mVelocitySetpointCurrent; float mVelocityState; float mDownCommand; - PathFollowerFSM *mFSM; + PIDControlDownCallback *mCallback; float mNeutral; float mVelocityMax; struct pid PIDpos; diff --git a/flight/libraries/pid/pidcontroldowncallback.h b/flight/libraries/pid/pidcontroldowncallback.h new file mode 100644 index 000000000..8d099fab8 --- /dev/null +++ b/flight/libraries/pid/pidcontroldowncallback.h @@ -0,0 +1,42 @@ +/** + ****************************************************************************** + * @addtogroup OpenPilotModules OpenPilot Modules + * @{ + * @addtogroup PID Library + * @brief Thrust control callback pure virtual + * @{ + * + * @file pidcontroldowncallback.h + * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2015. + * @brief Interface class for PathFollower FSMs + * + * @see The GNU Public License (GPL) Version 3 + * + *****************************************************************************/ +/* + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef PIDCONTROLDOWNCALLBACK_H +#define PIDCONTROLDOWNCALLBACK_H + +class PIDControlDownCallback { +public: + // PIDControlDownCalback() {}; + virtual void BoundThrust(__attribute__((unused)) float &ulow, __attribute__((unused)) float &uhigh) = 0; + virtual float BoundVelocityDown(float velocity) = 0; + //virtual ~PIDControlDownCalback() = 0; +}; + +#endif // PIDCONTROLDOWNCALLBACK_H diff --git a/flight/modules/PathFollower/inc/pathfollowerfsm.h b/flight/modules/PathFollower/inc/pathfollowerfsm.h index 9701bc7de..aaec8e5e7 100644 --- a/flight/modules/PathFollower/inc/pathfollowerfsm.h +++ b/flight/modules/PathFollower/inc/pathfollowerfsm.h @@ -34,6 +34,7 @@ extern "C" { #include } +#include typedef enum { PFFSM_STATE_INACTIVE = 0, // Inactive state is the initialised state on startup @@ -42,7 +43,7 @@ typedef enum { PFFSM_STATE_ABORT // Abort on error } PathFollowerFSMState_T; -class PathFollowerFSM { +class PathFollowerFSM: public PIDControlDownCallback { public: // PathFollowerFSM() {}; virtual void Inactive(void) {} diff --git a/flight/modules/Stabilization/altitudeloop.c b/flight/modules/Stabilization/altitudeloop.cpp similarity index 65% rename from flight/modules/Stabilization/altitudeloop.c rename to flight/modules/Stabilization/altitudeloop.cpp index 489e6e0d1..e1dee93fa 100644 --- a/flight/modules/Stabilization/altitudeloop.c +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -1,7 +1,7 @@ /** ****************************************************************************** * - * @file altitudeloop.c + * @file altitudeloop.cpp * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2014. * @brief This module compared @ref PositionActuatl to @ref ActiveWaypoint * and sets @ref AttitudeDesired. It only does this when the FlightMode field @@ -26,6 +26,7 @@ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +extern "C" { #include #include @@ -37,6 +38,11 @@ #include #include #include +#include +} + +#include + // Private constants @@ -54,6 +60,7 @@ // Private types // Private variables +static PIDControlDown controlDown; static DelayedCallbackInfo *altitudeHoldCBInfo; static AltitudeHoldSettingsData altitudeHoldSettings; static struct pid pid0, pid1; @@ -61,7 +68,9 @@ static ThrustModeType thrustMode; static PiOSDeltatimeConfig timeval; static float thrustSetpoint = 0.0f; static float thrustDemand = 0.0f; -static float startThrust = 0.5f; + // this is the max speed in m/s at the extents of thrust + static float thrustRate; + static uint8_t thrustExp; // Private functions @@ -71,15 +80,15 @@ static void VelocityStateUpdatedCb(UAVObjEvent *ev); /** * Setup mode and setpoint + * + * reinit: true when althold/vario mode selected over a previous alternate thrust mode */ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit) { static bool newaltitude = true; if (reinit) { - startThrust = setpoint; - pid_zero(&pid0); - pid_zero(&pid1); + controlDown.Activate(); newaltitude = true; } @@ -87,34 +96,28 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit const float DEADBAND_HIGH = 1.0f / 2 + DEADBAND / 2; const float DEADBAND_LOW = 1.0f / 2 - DEADBAND / 2; - // this is the max speed in m/s at the extents of thrust - float thrustRate; - uint8_t thrustExp; - - AltitudeHoldSettingsThrustExpGet(&thrustExp); - AltitudeHoldSettingsThrustRateGet(&thrustRate); - - PositionStateData posState; - PositionStateGet(&posState); if (altitudeHoldSettings.CutThrustWhenZero && setpoint <= 0) { // Cut thrust if desired - thrustSetpoint = 0.0f; + controlDown.UpdateVelocitySetpoint(0.0f); thrustDemand = 0.0f; thrustMode = DIRECT; newaltitude = true; } else if (mode == ALTITUDEVARIO && setpoint > DEADBAND_HIGH) { // being the two band symmetrical I can divide by DEADBAND_LOW to scale it to a value betweeon 0 and 1 // then apply an "exp" f(x,k) = (k*x*x*x + (255-k)*x) / 255 - thrustSetpoint = -((thrustExp * powf((setpoint - DEADBAND_HIGH) / (DEADBAND_LOW), 3) + (255 - thrustExp) * (setpoint - DEADBAND_HIGH) / DEADBAND_LOW) / 255 * thrustRate); + controlDown.UpdateVelocitySetpoint(-((thrustExp * powf((setpoint - DEADBAND_HIGH) / (DEADBAND_LOW), 3) + (255 - thrustExp) * (setpoint - DEADBAND_HIGH) / DEADBAND_LOW) / 255 * thrustRate)); thrustMode = ALTITUDEVARIO; newaltitude = true; } else if (mode == ALTITUDEVARIO && setpoint < DEADBAND_LOW) { - thrustSetpoint = -(-(thrustExp * powf((DEADBAND_LOW - (setpoint < 0 ? 0 : setpoint)) / DEADBAND_LOW, 3) + (255 - thrustExp) * (DEADBAND_LOW - setpoint) / DEADBAND_LOW) / 255 * thrustRate); + controlDown.UpdateVelocitySetpoint(-(-(thrustExp * powf((DEADBAND_LOW - (setpoint < 0 ? 0 : setpoint)) / DEADBAND_LOW, 3) + (255 - thrustExp) * (DEADBAND_LOW - setpoint) / DEADBAND_LOW) / 255 * thrustRate)); thrustMode = ALTITUDEVARIO; newaltitude = true; } else if (newaltitude == true) { - thrustSetpoint = posState.Down; + controlDown.UpdateVelocitySetpoint(0.0f); + PositionStateData posState; + PositionStateGet(&posState); + controlDown.UpdatePositionSetpoint(posState.Down); thrustMode = ALTITUDEHOLD; newaltitude = false; } @@ -150,28 +153,27 @@ void stabilizationAltitudeloopInit() static void altitudeHoldTask(void) { AltitudeHoldStatusData altitudeHoldStatus; - AltitudeHoldStatusGet(&altitudeHoldStatus); - // do the actual control loop(s) - float positionStateDown; - PositionStateDownGet(&positionStateDown); float velocityStateDown; VelocityStateDownGet(&velocityStateDown); + controlDown.UpdateVelocityState(velocityStateDown); float dT; dT = PIOS_DELTATIME_GetAverageSeconds(&timeval); + switch (thrustMode) { case ALTITUDEHOLD: { - // altitude control loop - // No scaling. - const pid_scaler scaler = { .p = 1.0f, .i = 1.0f, .d = 1.0f }; - altitudeHoldStatus.VelocityDesired = pid_apply_setpoint(&pid0, &scaler, thrustSetpoint, positionStateDown, dT); + float positionStateDown; + PositionStateDownGet(&positionStateDown); + controlDown.UpdatePositionState(positionStateDown); + controlDown.ControlPosition(); + altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); } break; case ALTITUDEVARIO: - altitudeHoldStatus.VelocityDesired = thrustSetpoint; + altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); break; default: altitudeHoldStatus.VelocityDesired = 0; @@ -186,10 +188,7 @@ static void altitudeHoldTask(void) break; default: { - // velocity control loop - // No scaling. - const pid_scaler scaler = { .p = 1.0f, .i = 1.0f, .d = 1.0f }; - thrustDemand = startThrust - pid_apply_setpoint(&pid1, &scaler, altitudeHoldStatus.VelocityDesired, velocityStateDown, dT); + thrustDemand = controlDown.GetDownCommand(); } break; } @@ -198,10 +197,30 @@ static void altitudeHoldTask(void) static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) { AltitudeHoldSettingsGet(&altitudeHoldSettings); - pid_configure(&pid0, altitudeHoldSettings.AltitudePI.Kp, altitudeHoldSettings.AltitudePI.Ki, 0, altitudeHoldSettings.AltitudePI.Ilimit); - pid_zero(&pid0); - pid_configure(&pid1, altitudeHoldSettings.VelocityPI.Kp, altitudeHoldSettings.VelocityPI.Ki, 0, altitudeHoldSettings.VelocityPI.Ilimit); - pid_zero(&pid1); + //pid_configure(&pid0, altitudeHoldSettings.AltitudePI.Kp, altitudeHoldSettings.AltitudePI.Ki, 0, altitudeHoldSettings.AltitudePI.Ilimit); + //pid_zero(&pid0); + //pid_configure(&pid1, altitudeHoldSettings.VelocityPI.Kp, altitudeHoldSettings.VelocityPI.Ki, 0, altitudeHoldSettings.VelocityPI.Ilimit); + //pid_zero(&pid1); + + controlDown.UpdateParameters(vtolPathFollowerSettings->LandVerticalVelPID.Kp, + vtolPathFollowerSettings->LandVerticalVelPID.Ki, + vtolPathFollowerSettings->LandVerticalVelPID.Kd, + vtolPathFollowerSettings->LandVerticalVelPID.Beta, + UPDATE_EXPECTED, + vtolPathFollowerSettings->VerticalVelMax); + + // The following is not currently used in the landing control. + controlDown.UpdatePositionalParameters(vtolPathFollowerSettings->VerticalPosP); + + VtolSelfTuningStatsData vtolSelfTuningStats; + VtolSelfTuningStatsGet(&vtolSelfTuningStats); + controlDown.UpdateNeutralThrust(vtolSelfTuningStats.NeutralThrustOffset + vtolPathFollowerSettings->ThrustLimits.Neutral); + + // initialise limits on thrust but note the FSM can override. + controlDown.SetThrustLimits(vtolPathFollowerSettings->ThrustLimits.Min, vtolPathFollowerSettings->ThrustLimits.Max); + + AltitudeHoldSettingsThrustExpGet(&thrustExp); + AltitudeHoldSettingsThrustRateGet(&thrustRate); } static void VelocityStateUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) diff --git a/make/apps-defs.mk b/make/apps-defs.mk index df0bf2acd..a9acb63df 100644 --- a/make/apps-defs.mk +++ b/make/apps-defs.mk @@ -33,6 +33,10 @@ FLIGHTLIBINC = $(FLIGHTLIB)/inc OPUAVOBJINC = $(OPUAVOBJ)/inc OPUAVTALKINC = $(OPUAVTALK)/inc +## PID +PIDLIB =$(FLIGHTLIB)/pid +PIDLIBINC =$(FLIGHTLIB)/pid + ## Math MATHLIB = $(FLIGHTLIB)/math MATHLIBINC = $(FLIGHTLIB)/math @@ -87,7 +91,10 @@ SRC += $(PIOSCOMMON)/pios_sensors.c SRC += $(FLIGHTLIB)/sanitycheck.c SRC += $(FLIGHTLIB)/CoordinateConversions.c SRC += $(MATHLIB)/sin_lookup.c + +## PID library functions SRC += $(MATHLIB)/pid.c +CPPSRC += $(PIDLIB)/pidcontroldown.cpp ## PIOS Hardware (Common) SRC += $(PIOSCOMMON)/pios_flashfs_logfs.c @@ -166,6 +173,7 @@ EXTRAINCDIRS += $(FLIGHTLIBINC) EXTRAINCDIRS += $(PIOSCOMMON) EXTRAINCDIRS += $(OPSYSTEMINC) EXTRAINCDIRS += $(MATHLIBINC) +EXTRAINCDIRS += $(PIDLIBINC) EXTRAINCDIRS += $(OPUAVOBJINC) EXTRAINCDIRS += $(OPUAVTALKINC) EXTRAINCDIRS += $(OPUAVSYNTHDIR) From d469a754bf7a0000a4d8eb53068d23664d1ec94e Mon Sep 17 00:00:00 2001 From: abeck70 Date: Thu, 23 Apr 2015 15:29:23 +1000 Subject: [PATCH 16/75] OP-1848 ready for review AltVario: 1. Uses new PID scheme 2. Runs at the outer loop rate to save CPU cycles --- flight/libraries/pid/pidcontroldowncallback.h | 2 +- .../PathFollower/inc/pathfollowerfsm.h | 2 +- flight/modules/Stabilization/altitudeloop.cpp | 152 +++++++----------- .../altitudeholdsettings.xml | 20 +-- 4 files changed, 70 insertions(+), 106 deletions(-) diff --git a/flight/libraries/pid/pidcontroldowncallback.h b/flight/libraries/pid/pidcontroldowncallback.h index 8d099fab8..b6aedf8dd 100644 --- a/flight/libraries/pid/pidcontroldowncallback.h +++ b/flight/libraries/pid/pidcontroldowncallback.h @@ -36,7 +36,7 @@ public: // PIDControlDownCalback() {}; virtual void BoundThrust(__attribute__((unused)) float &ulow, __attribute__((unused)) float &uhigh) = 0; virtual float BoundVelocityDown(float velocity) = 0; - //virtual ~PIDControlDownCalback() = 0; + // virtual ~PIDControlDownCalback() = 0; }; #endif // PIDCONTROLDOWNCALLBACK_H diff --git a/flight/modules/PathFollower/inc/pathfollowerfsm.h b/flight/modules/PathFollower/inc/pathfollowerfsm.h index aaec8e5e7..0188cc71c 100644 --- a/flight/modules/PathFollower/inc/pathfollowerfsm.h +++ b/flight/modules/PathFollower/inc/pathfollowerfsm.h @@ -43,7 +43,7 @@ typedef enum { PFFSM_STATE_ABORT // Abort on error } PathFollowerFSMState_T; -class PathFollowerFSM: public PIDControlDownCallback { +class PathFollowerFSM : public PIDControlDownCallback { public: // PathFollowerFSM() {}; virtual void Inactive(void) {} diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index e1dee93fa..0577b9331 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -39,6 +39,7 @@ extern "C" { #include #include #include +#include } #include @@ -56,27 +57,19 @@ extern "C" { #define CALLBACK_PRIORITY CALLBACK_PRIORITY_LOW #define CBTASK_PRIORITY CALLBACK_TASK_FLIGHTCONTROL -#define STACK_SIZE_BYTES 512 // Private types // Private variables static PIDControlDown controlDown; -static DelayedCallbackInfo *altitudeHoldCBInfo; static AltitudeHoldSettingsData altitudeHoldSettings; -static struct pid pid0, pid1; static ThrustModeType thrustMode; -static PiOSDeltatimeConfig timeval; -static float thrustSetpoint = 0.0f; -static float thrustDemand = 0.0f; - // this is the max speed in m/s at the extents of thrust - static float thrustRate; - static uint8_t thrustExp; +static float thrustDemand = 0.0f; +static float thrustRate; +static uint8_t thrustExp; // Private functions -static void altitudeHoldTask(void); static void SettingsUpdatedCb(UAVObjEvent *ev); -static void VelocityStateUpdatedCb(UAVObjEvent *ev); /** * Setup mode and setpoint @@ -88,7 +81,7 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit static bool newaltitude = true; if (reinit) { - controlDown.Activate(); + controlDown.Activate(); newaltitude = true; } @@ -100,28 +93,59 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit if (altitudeHoldSettings.CutThrustWhenZero && setpoint <= 0) { // Cut thrust if desired controlDown.UpdateVelocitySetpoint(0.0f); - thrustDemand = 0.0f; - thrustMode = DIRECT; - newaltitude = true; + thrustDemand = 0.0f; + thrustMode = DIRECT; + newaltitude = true; } else if (mode == ALTITUDEVARIO && setpoint > DEADBAND_HIGH) { // being the two band symmetrical I can divide by DEADBAND_LOW to scale it to a value betweeon 0 and 1 // then apply an "exp" f(x,k) = (k*x*x*x + (255-k)*x) / 255 - controlDown.UpdateVelocitySetpoint(-((thrustExp * powf((setpoint - DEADBAND_HIGH) / (DEADBAND_LOW), 3) + (255 - thrustExp) * (setpoint - DEADBAND_HIGH) / DEADBAND_LOW) / 255 * thrustRate)); - thrustMode = ALTITUDEVARIO; - newaltitude = true; + controlDown.UpdateVelocitySetpoint(-((thrustExp * powf((setpoint - DEADBAND_HIGH) / (DEADBAND_LOW), 3) + (255 - thrustExp) * (setpoint - DEADBAND_HIGH) / DEADBAND_LOW) / 255 * thrustRate)); + thrustMode = ALTITUDEVARIO; + newaltitude = true; } else if (mode == ALTITUDEVARIO && setpoint < DEADBAND_LOW) { - controlDown.UpdateVelocitySetpoint(-(-(thrustExp * powf((DEADBAND_LOW - (setpoint < 0 ? 0 : setpoint)) / DEADBAND_LOW, 3) + (255 - thrustExp) * (DEADBAND_LOW - setpoint) / DEADBAND_LOW) / 255 * thrustRate)); - thrustMode = ALTITUDEVARIO; - newaltitude = true; + controlDown.UpdateVelocitySetpoint(-(-(thrustExp * powf((DEADBAND_LOW - (setpoint < 0 ? 0 : setpoint)) / DEADBAND_LOW, 3) + (255 - thrustExp) * (DEADBAND_LOW - setpoint) / DEADBAND_LOW) / 255 * thrustRate)); + thrustMode = ALTITUDEVARIO; + newaltitude = true; } else if (newaltitude == true) { controlDown.UpdateVelocitySetpoint(0.0f); PositionStateData posState; PositionStateGet(&posState); controlDown.UpdatePositionSetpoint(posState.Down); - thrustMode = ALTITUDEHOLD; - newaltitude = false; + thrustMode = ALTITUDEHOLD; + newaltitude = false; } + AltitudeHoldStatusData altitudeHoldStatus; + AltitudeHoldStatusGet(&altitudeHoldStatus); + + float velocityStateDown; + VelocityStateDownGet(&velocityStateDown); + controlDown.UpdateVelocityState(velocityStateDown); + + switch (thrustMode) { + case ALTITUDEHOLD: + { + float positionStateDown; + PositionStateDownGet(&positionStateDown); + controlDown.UpdatePositionState(positionStateDown); + controlDown.ControlPosition(); + altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); + thrustDemand = controlDown.GetDownCommand(); + } + break; + + case ALTITUDEVARIO: + altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); + thrustDemand = controlDown.GetDownCommand(); + break; + + case DIRECT: + altitudeHoldStatus.VelocityDesired = 0; + break; + } + + AltitudeHoldStatusSet(&altitudeHoldStatus); + return thrustDemand; } @@ -134,99 +158,37 @@ void stabilizationAltitudeloopInit() AltitudeHoldStatusInitialize(); PositionStateInitialize(); VelocityStateInitialize(); + VtolSelfTuningStatsInitialize(); - PIOS_DELTATIME_Init(&timeval, UPDATE_EXPECTED, UPDATE_MIN, UPDATE_MAX, UPDATE_ALPHA); // Create object queue - - altitudeHoldCBInfo = PIOS_CALLBACKSCHEDULER_Create(&altitudeHoldTask, CALLBACK_PRIORITY, CBTASK_PRIORITY, CALLBACKINFO_RUNNING_ALTITUDEHOLD, STACK_SIZE_BYTES); AltitudeHoldSettingsConnectCallback(&SettingsUpdatedCb); - VelocityStateConnectCallback(&VelocityStateUpdatedCb); - - // Start main task SettingsUpdatedCb(NULL); } -/** - * Module thread, should not return. - */ -static void altitudeHoldTask(void) -{ - AltitudeHoldStatusData altitudeHoldStatus; - AltitudeHoldStatusGet(&altitudeHoldStatus); - - float velocityStateDown; - VelocityStateDownGet(&velocityStateDown); - controlDown.UpdateVelocityState(velocityStateDown); - - float dT; - dT = PIOS_DELTATIME_GetAverageSeconds(&timeval); - - switch (thrustMode) { - case ALTITUDEHOLD: - { - float positionStateDown; - PositionStateDownGet(&positionStateDown); - controlDown.UpdatePositionState(positionStateDown); - controlDown.ControlPosition(); - altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); - } - break; - case ALTITUDEVARIO: - altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); - break; - default: - altitudeHoldStatus.VelocityDesired = 0; - break; - } - - AltitudeHoldStatusSet(&altitudeHoldStatus); - - switch (thrustMode) { - case DIRECT: - thrustDemand = thrustSetpoint; - break; - default: - { - thrustDemand = controlDown.GetDownCommand(); - } - break; - } -} - static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) { AltitudeHoldSettingsGet(&altitudeHoldSettings); - //pid_configure(&pid0, altitudeHoldSettings.AltitudePI.Kp, altitudeHoldSettings.AltitudePI.Ki, 0, altitudeHoldSettings.AltitudePI.Ilimit); - //pid_zero(&pid0); - //pid_configure(&pid1, altitudeHoldSettings.VelocityPI.Kp, altitudeHoldSettings.VelocityPI.Ki, 0, altitudeHoldSettings.VelocityPI.Ilimit); - //pid_zero(&pid1); - controlDown.UpdateParameters(vtolPathFollowerSettings->LandVerticalVelPID.Kp, - vtolPathFollowerSettings->LandVerticalVelPID.Ki, - vtolPathFollowerSettings->LandVerticalVelPID.Kd, - vtolPathFollowerSettings->LandVerticalVelPID.Beta, - UPDATE_EXPECTED, - vtolPathFollowerSettings->VerticalVelMax); + controlDown.UpdateParameters(altitudeHoldSettings.VerticalVelPID.Kp, + altitudeHoldSettings.VerticalVelPID.Ki, + altitudeHoldSettings.VerticalVelPID.Kd, + altitudeHoldSettings.VerticalVelPID.Beta, + (float)(OUTERLOOP_SKIPCOUNT * UPDATE_EXPECTED), + altitudeHoldSettings.VerticalVelMax); - // The following is not currently used in the landing control. - controlDown.UpdatePositionalParameters(vtolPathFollowerSettings->VerticalPosP); + controlDown.UpdatePositionalParameters(altitudeHoldSettings.VerticalPosP); VtolSelfTuningStatsData vtolSelfTuningStats; VtolSelfTuningStatsGet(&vtolSelfTuningStats); - controlDown.UpdateNeutralThrust(vtolSelfTuningStats.NeutralThrustOffset + vtolPathFollowerSettings->ThrustLimits.Neutral); + controlDown.UpdateNeutralThrust(vtolSelfTuningStats.NeutralThrustOffset + altitudeHoldSettings.ThrustLimits.Neutral); // initialise limits on thrust but note the FSM can override. - controlDown.SetThrustLimits(vtolPathFollowerSettings->ThrustLimits.Min, vtolPathFollowerSettings->ThrustLimits.Max); + controlDown.SetThrustLimits(altitudeHoldSettings.ThrustLimits.Min, altitudeHoldSettings.ThrustLimits.Max); AltitudeHoldSettingsThrustExpGet(&thrustExp); AltitudeHoldSettingsThrustRateGet(&thrustRate); } -static void VelocityStateUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) -{ - PIOS_CALLBACKSCHEDULER_Dispatch(altitudeHoldCBInfo); -} - #endif /* ifdef REVOLUTION */ diff --git a/shared/uavobjectdefinition/altitudeholdsettings.xml b/shared/uavobjectdefinition/altitudeholdsettings.xml index aadf90e8f..df4917954 100644 --- a/shared/uavobjectdefinition/altitudeholdsettings.xml +++ b/shared/uavobjectdefinition/altitudeholdsettings.xml @@ -1,14 +1,16 @@ - Settings for the @ref AltitudeHold module - - + Settings for the @ref AltitudeHold module - - - - - - + + + + + + + + + + From 0d77cd95d91cafd2bed604f1cc7b6649194c2780 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Thu, 23 Apr 2015 21:13:00 +1000 Subject: [PATCH 17/75] OP-1848 altvari0 1. build fixes 2. Updated ui to use updated uavo names in altitude settings that align to the naming in vtol settings 3. Moved call the thrust altvario to pre application of PIDs for 3d axes to allow for later coupling. --- flight/modules/Stabilization/outerloop.c | 215 +++++++++--------- .../boards/discoveryf4bare/firmware/Makefile | 6 +- ...{discoveryf4bare.c => discoveryf4bare.cpp} | 3 +- .../boards/revoproto/firmware/Makefile | 7 +- .../firmware/{revolution.c => revolution.cpp} | 2 + .../src/plugins/config/stabilization.ui | 28 ++- 6 files changed, 137 insertions(+), 124 deletions(-) rename flight/targets/boards/discoveryf4bare/firmware/{discoveryf4bare.c => discoveryf4bare.cpp} (99%) rename flight/targets/boards/revoproto/firmware/{revolution.c => revolution.cpp} (99%) diff --git a/flight/modules/Stabilization/outerloop.c b/flight/modules/Stabilization/outerloop.c index 995003208..bb3ef4575 100644 --- a/flight/modules/Stabilization/outerloop.c +++ b/flight/modules/Stabilization/outerloop.c @@ -103,7 +103,25 @@ static void stabilizationOuterloopTask() float *stabilizationDesiredAxis = &stabilizationDesired.Roll; float *rateDesiredAxis = &rateDesired.Roll; int t; - float dT = PIOS_DELTATIME_GetAverageSeconds(&timeval); + float dT = PIOS_DELTATIME_GetAverageSeconds(&timeval); + + bool reinit = (StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST] != previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST]); + previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST]; + switch (StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST]) { +#ifdef REVOLUTION + case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE: + rateDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = stabilizationAltitudeHold(stabilizationDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST], ALTITUDEHOLD, reinit); + break; + case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDEVARIO: + rateDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = stabilizationAltitudeHold(stabilizationDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST], ALTITUDEVARIO, reinit); + break; +#endif /* REVOLUTION */ + case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: + default: + rateDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = stabilizationDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST]; + break; + } + float local_error[3]; { @@ -148,117 +166,102 @@ static void stabilizationOuterloopTask() } #endif /* if defined(PIOS_QUATERNION_STABILIZATION) */ } - for (t = 0; t < AXES; t++) { - bool reinit = (StabilizationStatusOuterLoopToArray(enabled)[t] != previous_mode[t]); + + + for (t = STABILIZATIONSTATUS_OUTERLOOP_ROLL; t < STABILIZATIONSTATUS_OUTERLOOP_THRUST; t++) { + reinit = (StabilizationStatusOuterLoopToArray(enabled)[t] != previous_mode[t]); previous_mode[t] = StabilizationStatusOuterLoopToArray(enabled)[t]; - if (t < STABILIZATIONSTATUS_OUTERLOOP_THRUST) { - if (reinit) { - stabSettings.outerPids[t].iAccumulator = 0; - } - switch (StabilizationStatusOuterLoopToArray(enabled)[t]) { - case STABILIZATIONSTATUS_OUTERLOOP_ATTITUDE: - rateDesiredAxis[t] = pid_apply(&stabSettings.outerPids[t], local_error[t], dT); - break; - case STABILIZATIONSTATUS_OUTERLOOP_RATTITUDE: - { - float stickinput[3]; - stickinput[0] = boundf(stabilizationDesiredAxis[0] / stabSettings.stabBank.RollMax, -1.0f, 1.0f); - stickinput[1] = boundf(stabilizationDesiredAxis[1] / stabSettings.stabBank.PitchMax, -1.0f, 1.0f); - stickinput[2] = boundf(stabilizationDesiredAxis[2] / stabSettings.stabBank.YawMax, -1.0f, 1.0f); - float rateDesiredAxisRate = stickinput[t] * StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t]; - // limit corrective rate to maximum rates to not give it overly large impact over manual rate when joined together - rateDesiredAxis[t] = boundf(pid_apply(&stabSettings.outerPids[t], local_error[t], dT), - -StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t], - StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t] - ); - // Compute the weighted average rate desired - // Using max() rather than sqrt() for cpu speed; - // - this makes the stick region into a square; - // - this is a feature! - // - hold a roll angle and add just pitch without the stick sensitivity changing - float magnitude = fabsf(stickinput[t]); - if (t < 2) { - magnitude = fmaxf(fabsf(stickinput[0]), fabsf(stickinput[1])); - } - - // modify magnitude to move the Att to Rate transition to the place - // specified by the user - // we are looking for where the stick angle == transition angle - // and the Att rate equals the Rate rate - // that's where Rate x (1-StickAngle) [Attitude pulling down max X Ratt proportion] - // == Rate x StickAngle [Rate pulling up according to stick angle] - // * StickAngle [X Ratt proportion] - // so 1-x == x*x or x*x+x-1=0 where xE(0,1) - // (-1+-sqrt(1+4))/2 = (-1+sqrt(5))/2 - // and quadratic formula says that is 0.618033989f - // I tested 14.01 and came up with .61 without even remembering this number - // I thought that moving the P,I, and maxangle terms around would change this value - // and that I would have to take these into account, but varying - // all P's and I's by factors of 1/2 to 2 didn't change it noticeably - // and varying maxangle from 4 to 120 didn't either. - // so for now I'm not taking these into account - // while working with this, it occurred to me that Attitude mode, - // set up with maxangle=190 would be similar to Ratt, and it is. - #define STICK_VALUE_AT_MODE_TRANSITION 0.618033989f - - // the following assumes the transition would otherwise be at 0.618033989f - // and THAT assumes that Att ramps up to max roll rate - // when a small number of degrees off of where it should be - - // if below the transition angle (still in attitude mode) - // '<=' instead of '<' keeps rattitude_mode_transition_stick_position==1.0 from causing DZ - if (magnitude <= stabSettings.rattitude_mode_transition_stick_position) { - magnitude *= STICK_VALUE_AT_MODE_TRANSITION / stabSettings.rattitude_mode_transition_stick_position; - } else { - magnitude = (magnitude - stabSettings.rattitude_mode_transition_stick_position) - * (1.0f - STICK_VALUE_AT_MODE_TRANSITION) - / (1.0f - stabSettings.rattitude_mode_transition_stick_position) - + STICK_VALUE_AT_MODE_TRANSITION; - } - rateDesiredAxis[t] = (1.0f - magnitude) * rateDesiredAxis[t] + magnitude * rateDesiredAxisRate; - } + if (reinit) { + stabSettings.outerPids[t].iAccumulator = 0; + } + switch (StabilizationStatusOuterLoopToArray(enabled)[t]) { + case STABILIZATIONSTATUS_OUTERLOOP_ATTITUDE: + rateDesiredAxis[t] = pid_apply(&stabSettings.outerPids[t], local_error[t], dT); break; - case STABILIZATIONSTATUS_OUTERLOOP_WEAKLEVELING: - // FIXME: local_error[] is rate - attitude for Weak Leveling - // The only ramifications are: - // Weak Leveling Kp is off by a factor of 3 to 12 and may need a different default in GCS - // Changing Rate mode max rate currently requires a change to Kp - // That would be changed to Attitude mode max angle affecting Kp - // Also does not take dT into account - { - float stickinput[3]; - stickinput[0] = boundf(stabilizationDesiredAxis[0] / stabSettings.stabBank.RollMax, -1.0f, 1.0f); - stickinput[1] = boundf(stabilizationDesiredAxis[1] / stabSettings.stabBank.PitchMax, -1.0f, 1.0f); - stickinput[2] = boundf(stabilizationDesiredAxis[2] / stabSettings.stabBank.YawMax, -1.0f, 1.0f); - float rate_input = stickinput[t] * StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t]; - float weak_leveling = local_error[t] * stabSettings.settings.WeakLevelingKp; - weak_leveling = boundf(weak_leveling, -stabSettings.settings.MaxWeakLevelingRate, stabSettings.settings.MaxWeakLevelingRate); + case STABILIZATIONSTATUS_OUTERLOOP_RATTITUDE: + { + float stickinput[3]; + stickinput[0] = boundf(stabilizationDesiredAxis[0] / stabSettings.stabBank.RollMax, -1.0f, 1.0f); + stickinput[1] = boundf(stabilizationDesiredAxis[1] / stabSettings.stabBank.PitchMax, -1.0f, 1.0f); + stickinput[2] = boundf(stabilizationDesiredAxis[2] / stabSettings.stabBank.YawMax, -1.0f, 1.0f); + float rateDesiredAxisRate = stickinput[t] * StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t]; + // limit corrective rate to maximum rates to not give it overly large impact over manual rate when joined together + rateDesiredAxis[t] = boundf(pid_apply(&stabSettings.outerPids[t], local_error[t], dT), + -StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t], + StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t] + ); + // Compute the weighted average rate desired + // Using max() rather than sqrt() for cpu speed; + // - this makes the stick region into a square; + // - this is a feature! + // - hold a roll angle and add just pitch without the stick sensitivity changing + float magnitude = fabsf(stickinput[t]); + if (t < 2) { + magnitude = fmaxf(fabsf(stickinput[0]), fabsf(stickinput[1])); + } - // Compute desired rate as input biased towards leveling - rateDesiredAxis[t] = rate_input + weak_leveling; + // modify magnitude to move the Att to Rate transition to the place + // specified by the user + // we are looking for where the stick angle == transition angle + // and the Att rate equals the Rate rate + // that's where Rate x (1-StickAngle) [Attitude pulling down max X Ratt proportion] + // == Rate x StickAngle [Rate pulling up according to stick angle] + // * StickAngle [X Ratt proportion] + // so 1-x == x*x or x*x+x-1=0 where xE(0,1) + // (-1+-sqrt(1+4))/2 = (-1+sqrt(5))/2 + // and quadratic formula says that is 0.618033989f + // I tested 14.01 and came up with .61 without even remembering this number + // I thought that moving the P,I, and maxangle terms around would change this value + // and that I would have to take these into account, but varying + // all P's and I's by factors of 1/2 to 2 didn't change it noticeably + // and varying maxangle from 4 to 120 didn't either. + // so for now I'm not taking these into account + // while working with this, it occurred to me that Attitude mode, + // set up with maxangle=190 would be similar to Ratt, and it is. +#define STICK_VALUE_AT_MODE_TRANSITION 0.618033989f + + // the following assumes the transition would otherwise be at 0.618033989f + // and THAT assumes that Att ramps up to max roll rate + // when a small number of degrees off of where it should be + + // if below the transition angle (still in attitude mode) + // '<=' instead of '<' keeps rattitude_mode_transition_stick_position==1.0 from causing DZ + if (magnitude <= stabSettings.rattitude_mode_transition_stick_position) { + magnitude *= STICK_VALUE_AT_MODE_TRANSITION / stabSettings.rattitude_mode_transition_stick_position; + } else { + magnitude = (magnitude - stabSettings.rattitude_mode_transition_stick_position) + * (1.0f - STICK_VALUE_AT_MODE_TRANSITION) + / (1.0f - stabSettings.rattitude_mode_transition_stick_position) + + STICK_VALUE_AT_MODE_TRANSITION; } + rateDesiredAxis[t] = (1.0f - magnitude) * rateDesiredAxis[t] + magnitude * rateDesiredAxisRate; + } + break; + case STABILIZATIONSTATUS_OUTERLOOP_WEAKLEVELING: + // FIXME: local_error[] is rate - attitude for Weak Leveling + // The only ramifications are: + // Weak Leveling Kp is off by a factor of 3 to 12 and may need a different default in GCS + // Changing Rate mode max rate currently requires a change to Kp + // That would be changed to Attitude mode max angle affecting Kp + // Also does not take dT into account + { + float stickinput[3]; + stickinput[0] = boundf(stabilizationDesiredAxis[0] / stabSettings.stabBank.RollMax, -1.0f, 1.0f); + stickinput[1] = boundf(stabilizationDesiredAxis[1] / stabSettings.stabBank.PitchMax, -1.0f, 1.0f); + stickinput[2] = boundf(stabilizationDesiredAxis[2] / stabSettings.stabBank.YawMax, -1.0f, 1.0f); + float rate_input = stickinput[t] * StabilizationBankManualRateToArray(stabSettings.stabBank.ManualRate)[t]; + float weak_leveling = local_error[t] * stabSettings.settings.WeakLevelingKp; + weak_leveling = boundf(weak_leveling, -stabSettings.settings.MaxWeakLevelingRate, stabSettings.settings.MaxWeakLevelingRate); + + // Compute desired rate as input biased towards leveling + rateDesiredAxis[t] = rate_input + weak_leveling; + } + break; + case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: + default: + rateDesiredAxis[t] = stabilizationDesiredAxis[t]; break; - case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: - default: - rateDesiredAxis[t] = stabilizationDesiredAxis[t]; - break; - } - } else { - switch (StabilizationStatusOuterLoopToArray(enabled)[t]) { -#ifdef REVOLUTION - case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE: - rateDesiredAxis[t] = stabilizationAltitudeHold(stabilizationDesiredAxis[t], ALTITUDEHOLD, reinit); - break; - case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDEVARIO: - rateDesiredAxis[t] = stabilizationAltitudeHold(stabilizationDesiredAxis[t], ALTITUDEVARIO, reinit); - break; -#endif /* REVOLUTION */ - case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: - default: - rateDesiredAxis[t] = stabilizationDesiredAxis[t]; - break; - } } } diff --git a/flight/targets/boards/discoveryf4bare/firmware/Makefile b/flight/targets/boards/discoveryf4bare/firmware/Makefile index f0d0e483f..4d9c3064c 100644 --- a/flight/targets/boards/discoveryf4bare/firmware/Makefile +++ b/flight/targets/boards/discoveryf4bare/firmware/Makefile @@ -24,6 +24,9 @@ endif include ../board-info.mk include $(ROOT_DIR)/make/firmware-defs.mk +# REVO C++ support +USE_CXX = YES + # ARM DSP library USE_DSP_LIB ?= NO @@ -70,7 +73,7 @@ ifndef TESTAPP ## Application Core SRC += ../pios_usb_board_data.c SRC += $(OPMODULEDIR)/System/systemmod.c - SRC += $(OPSYSTEM)/discoveryf4bare.c + CPPSRC += $(OPSYSTEM)/discoveryf4bare.cpp SRC += $(OPSYSTEM)/pios_board.c SRC += $(FLIGHTLIB)/alarms.c SRC += $(OPUAVTALK)/uavtalk.c @@ -91,6 +94,7 @@ ifndef TESTAPP SRC += $(FLIGHTLIB)/insgps13state.c SRC += $(FLIGHTLIB)/auxmagsupport.c SRC += $(FLIGHTLIB)/lednotification.c + CPPSRC += $(FLIGHTLIB)/mini_cpp.cpp ## UAVObjects include ./UAVObjects.inc diff --git a/flight/targets/boards/discoveryf4bare/firmware/discoveryf4bare.c b/flight/targets/boards/discoveryf4bare/firmware/discoveryf4bare.cpp similarity index 99% rename from flight/targets/boards/discoveryf4bare/firmware/discoveryf4bare.c rename to flight/targets/boards/discoveryf4bare/firmware/discoveryf4bare.cpp index 19e33890b..268325b26 100644 --- a/flight/targets/boards/discoveryf4bare/firmware/discoveryf4bare.c +++ b/flight/targets/boards/discoveryf4bare/firmware/discoveryf4bare.cpp @@ -31,7 +31,7 @@ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - +extern "C" { #include "inc/openpilot.h" #include @@ -74,6 +74,7 @@ static void initTask(void *parameters); /* Prototype of generated InitModules() function */ extern void InitModules(void); +} /** * OpenPilot Main function: diff --git a/flight/targets/boards/revoproto/firmware/Makefile b/flight/targets/boards/revoproto/firmware/Makefile index c040a0421..a47856179 100644 --- a/flight/targets/boards/revoproto/firmware/Makefile +++ b/flight/targets/boards/revoproto/firmware/Makefile @@ -24,6 +24,9 @@ endif include ../board-info.mk include $(ROOT_DIR)/make/firmware-defs.mk +# REVO C++ support +USE_CXX = YES + # ARM DSP library USE_DSP_LIB ?= NO @@ -65,7 +68,7 @@ ifndef TESTAPP ## Application Core SRC += ../pios_usb_board_data.c SRC += $(OPMODULEDIR)/System/systemmod.c - SRC += $(OPSYSTEM)/revolution.c + CPPSRC += $(OPSYSTEM)/revolution.cpp SRC += $(OPSYSTEM)/pios_board.c SRC += $(FLIGHTLIB)/alarms.c SRC += $(OPUAVTALK)/uavtalk.c @@ -84,6 +87,8 @@ ifndef TESTAPP SRC += $(FLIGHTLIB)/WorldMagModel.c SRC += $(FLIGHTLIB)/insgps13state.c SRC += $(FLIGHTLIB)/auxmagsupport.c + CPPSRC += $(FLIGHTLIB)/mini_cpp.cpp + ## UAVObjects include ./UAVObjects.inc diff --git a/flight/targets/boards/revoproto/firmware/revolution.c b/flight/targets/boards/revoproto/firmware/revolution.cpp similarity index 99% rename from flight/targets/boards/revoproto/firmware/revolution.c rename to flight/targets/boards/revoproto/firmware/revolution.cpp index b1081c4b9..268325b26 100644 --- a/flight/targets/boards/revoproto/firmware/revolution.c +++ b/flight/targets/boards/revoproto/firmware/revolution.cpp @@ -31,6 +31,7 @@ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +extern "C" { #include "inc/openpilot.h" #include @@ -73,6 +74,7 @@ static void initTask(void *parameters); /* Prototype of generated InitModules() function */ extern void InitModules(void); +} /** * OpenPilot Main function: diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index a2a157089..ce1ba7c62 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -25209,8 +25209,7 @@ border-radius: 5; objname:AltitudeHoldSettings - fieldname:AltitudePI - element:Kp + fieldname:VerticalPosP scale:0.01 haslimits:yes buttongroup:98,10 @@ -25294,7 +25293,7 @@ border-radius: 5; - + <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> @@ -25313,7 +25312,7 @@ border-radius: 5; objname:AltitudeHoldSettings - fieldname:VelocityPI + fieldname:VerticalVelPID element:Ki scale:0.00001 haslimits:yes @@ -25323,7 +25322,7 @@ border-radius: 5; - + 0 @@ -25370,7 +25369,7 @@ border-radius: 5; - + 0 @@ -25434,10 +25433,9 @@ border-radius: 5; QSlider::TicksBelow - + objname:AltitudeHoldSettings - fieldname:AltitudePI - element:Kp + fieldname:VerticalPosP scale:0.01 haslimits:yes buttongroup:98 @@ -25446,7 +25444,7 @@ border-radius: 5; - + <html><head/><body><p>How much the vehicle should throttle up or down to compensate or achieve a certain vertical speed. Higher values lead to more aggressive throttle changes and could lead to oscillations. This is the most likely candidate to change depending on the crafts engine thrust. Heavy craft with weak engines might require higher values.</p></body></html> @@ -25465,7 +25463,7 @@ border-radius: 5; objname:AltitudeHoldSettings - fieldname:VelocityPI + fieldname:VerticalVelPID element:Kp scale:0.01 haslimits:yes @@ -27173,10 +27171,10 @@ Useful if you have accidentally changed some settings. pushButton_7 AltKpSlider AltKp - AltKiSlider - AltKi - AltKdSlider - AltKd + VelKpSlider + VelKp + VelKiSlider + VelKi pushButton_8 AltThrExpSlider_2 AltThrExp_2 From 443b3742cce7a324ff33bada5393ab171fde7b3d Mon Sep 17 00:00:00 2001 From: abeck70 Date: Thu, 23 Apr 2015 21:54:20 +1000 Subject: [PATCH 18/75] OP-1848 altvario 1. Build fixes 2. Additional UI components. --- .../discoveryf4bare/firmware/UAVObjects.inc | 3 + .../src/plugins/config/stabilization.ui | 328 +++++++++++++++--- 2 files changed, 274 insertions(+), 57 deletions(-) diff --git a/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc b/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc index b53518358..d411a525e 100644 --- a/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc +++ b/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc @@ -19,6 +19,9 @@ # These are the UAVObjects supposed to be build as part of the OpenPilot target # (all architectures) UAVOBJSRCFILENAMES = +UAVOBJSRCFILENAMES += statusgrounddrive +UAVOBJSRCFILENAMES += statusvtolautotakeoff +UAVOBJSRCFILENAMES += pidstatus UAVOBJSRCFILENAMES += statusvtolland UAVOBJSRCFILENAMES += vtolselftuningstats UAVOBJSRCFILENAMES += accelgyrosettings diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index ce1ba7c62..b330d061e 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -95,7 +95,7 @@ QTabWidget::Rounded - 0 + 3 false @@ -136,8 +136,8 @@ 0 0 - 939 - 776 + 950 + 775 @@ -8244,8 +8244,8 @@ border-radius: 5; 0 0 - 952 - 763 + 884 + 736 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 952 - 763 + 839 + 670 @@ -24082,8 +24082,8 @@ font:bold; 0 0 - 952 - 763 + 950 + 773 @@ -25321,53 +25321,6 @@ border-radius: 5; - - - - - 0 - 0 - - - - - 50 - 22 - - - - - 50 - 22 - - - - Qt::StrongFocus - - - - - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - - 100 - - - 51 - - - - objname:AltitudeHoldSettings - fieldname:VelocityPI - element:Kp - scale:0.01 - haslimits:yes - buttongroup:98,10 - - - - @@ -25406,7 +25359,7 @@ border-radius: 5; objname:AltitudeHoldSettings - fieldname:VelocityPI + fieldname:VerticalVelPID element:Ki scale:0.00001 haslimits:yes @@ -25415,6 +25368,267 @@ border-radius: 5; + + + + + 0 + 0 + + + + + 58 + 0 + + + + + 16777215 + 16777215 + + + + + + + Velocity Derivative + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> + + + 1000 + + + 50 + + + Qt::Horizontal + + + QSlider::TicksBelow + + + + objname:AltitudeHoldSettings + fieldname:VerticalVelPID + element:Kd + scale:0.00001 + haslimits:yes + buttongroup:98 + + + + + + + + + 0 + 0 + + + + + 50 + 22 + + + + + 50 + 22 + + + + Qt::StrongFocus + + + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1000 + + + 51 + + + + objname:AltitudeHoldSettings + fieldname:VerticalVelPID + element:Kd + scale:0.00001 + haslimits:yes + buttongroup:98,10 + + + + + + + + + 0 + 0 + + + + + 58 + 0 + + + + + 16777215 + 16777215 + + + + + + + Velocity Beta + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> + + + 1000 + + + 50 + + + Qt::Horizontal + + + QSlider::TicksBelow + + + + objname:AltitudeHoldSettings + fieldname:VerticalVelPID + element:Beta + scale:0.00001 + haslimits:yes + buttongroup:98 + + + + + + + + + 0 + 0 + + + + + 50 + 22 + + + + + 50 + 22 + + + + Qt::StrongFocus + + + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1000 + + + 51 + + + + objname:AltitudeHoldSettings + fieldname:VerticalVelPID + element:Beta + scale:0.00001 + haslimits:yes + buttongroup:98,10 + + + + + + + + + 0 + 0 + + + + + 50 + 22 + + + + + 50 + 22 + + + + Qt::StrongFocus + + + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 100 + + + 51 + + + + objname:AltitudeHoldSettings + fieldname:VerticalVelPID + element:Kp + scale:0.01 + haslimits:yes + buttongroup:98,10 + + + + From e36ab500409bdbac42560b070910421c671e9b72 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Thu, 23 Apr 2015 22:49:12 +1000 Subject: [PATCH 19/75] OP-1838 altvario Fixes and tidyup. TODO: 1. Fix UI for sliders 2. Disable vtol tuning on stabi input 3. Altitude loss feedback --- flight/modules/Stabilization/altitudeloop.cpp | 16 +++++------ .../src/plugins/config/stabilization.ui | 28 +++++++++---------- .../altitudeholdsettings.xml | 1 - 3 files changed, 21 insertions(+), 24 deletions(-) diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index 0577b9331..5b6b2d3ef 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -64,8 +64,6 @@ static PIDControlDown controlDown; static AltitudeHoldSettingsData altitudeHoldSettings; static ThrustModeType thrustMode; static float thrustDemand = 0.0f; -static float thrustRate; -static uint8_t thrustExp; // Private functions @@ -99,11 +97,11 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit } else if (mode == ALTITUDEVARIO && setpoint > DEADBAND_HIGH) { // being the two band symmetrical I can divide by DEADBAND_LOW to scale it to a value betweeon 0 and 1 // then apply an "exp" f(x,k) = (k*x*x*x + (255-k)*x) / 255 - controlDown.UpdateVelocitySetpoint(-((thrustExp * powf((setpoint - DEADBAND_HIGH) / (DEADBAND_LOW), 3) + (255 - thrustExp) * (setpoint - DEADBAND_HIGH) / DEADBAND_LOW) / 255 * thrustRate)); + controlDown.UpdateVelocitySetpoint(-((altitudeHoldSettings.ThrustExp * powf((setpoint - DEADBAND_HIGH) / (DEADBAND_LOW), 3.0f) + (255.0f - altitudeHoldSettings.ThrustExp) * (setpoint - DEADBAND_HIGH) / DEADBAND_LOW) / 255.0f * altitudeHoldSettings.ThrustRate)); thrustMode = ALTITUDEVARIO; newaltitude = true; } else if (mode == ALTITUDEVARIO && setpoint < DEADBAND_LOW) { - controlDown.UpdateVelocitySetpoint(-(-(thrustExp * powf((DEADBAND_LOW - (setpoint < 0 ? 0 : setpoint)) / DEADBAND_LOW, 3) + (255 - thrustExp) * (DEADBAND_LOW - setpoint) / DEADBAND_LOW) / 255 * thrustRate)); + controlDown.UpdateVelocitySetpoint(-(-(altitudeHoldSettings.ThrustExp * powf((DEADBAND_LOW - (setpoint < 0 ? 0 : setpoint)) / DEADBAND_LOW, 3.0f) + (255.0f - altitudeHoldSettings.ThrustExp) * (DEADBAND_LOW - setpoint) / DEADBAND_LOW) / 255.0f * altitudeHoldSettings.ThrustRate)); thrustMode = ALTITUDEVARIO; newaltitude = true; } else if (newaltitude == true) { @@ -131,6 +129,8 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit controlDown.ControlPosition(); altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); thrustDemand = controlDown.GetDownCommand(); + + // if thrust demand is high and we are below altitude by 2m, back off pitch } break; @@ -140,7 +140,7 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit break; case DIRECT: - altitudeHoldStatus.VelocityDesired = 0; + altitudeHoldStatus.VelocityDesired = 0.0f; break; } @@ -160,8 +160,8 @@ void stabilizationAltitudeloopInit() VelocityStateInitialize(); VtolSelfTuningStatsInitialize(); - // Create object queue AltitudeHoldSettingsConnectCallback(&SettingsUpdatedCb); + VtolSelfTuningStatsConnectCallback(&SettingsUpdatedCb); SettingsUpdatedCb(NULL); } @@ -175,7 +175,7 @@ static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) altitudeHoldSettings.VerticalVelPID.Kd, altitudeHoldSettings.VerticalVelPID.Beta, (float)(OUTERLOOP_SKIPCOUNT * UPDATE_EXPECTED), - altitudeHoldSettings.VerticalVelMax); + altitudeHoldSettings.ThrustRate); controlDown.UpdatePositionalParameters(altitudeHoldSettings.VerticalPosP); @@ -186,8 +186,6 @@ static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) // initialise limits on thrust but note the FSM can override. controlDown.SetThrustLimits(altitudeHoldSettings.ThrustLimits.Min, altitudeHoldSettings.ThrustLimits.Max); - AltitudeHoldSettingsThrustExpGet(&thrustExp); - AltitudeHoldSettingsThrustRateGet(&thrustRate); } diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index b330d061e..9956ebbb7 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -8244,8 +8244,8 @@ border-radius: 5; 0 0 - 884 - 736 + 950 + 773 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 839 - 670 + 950 + 773 @@ -25298,10 +25298,10 @@ border-radius: 5; <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> - 1000 + 10 - 50 + 10 Qt::Horizontal @@ -25351,10 +25351,10 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 1000 + 10 - 51 + 10 @@ -25458,10 +25458,10 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 1000 + 1 - 51 + 1 @@ -25512,10 +25512,10 @@ border-radius: 5; <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> - 1000 + 1 - 50 + 1 Qt::Horizontal @@ -25565,10 +25565,10 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 1000 + 1 - 51 + 1 diff --git a/shared/uavobjectdefinition/altitudeholdsettings.xml b/shared/uavobjectdefinition/altitudeholdsettings.xml index df4917954..f0a171b4b 100644 --- a/shared/uavobjectdefinition/altitudeholdsettings.xml +++ b/shared/uavobjectdefinition/altitudeholdsettings.xml @@ -5,7 +5,6 @@ - From 57ba5280ef0af43812afed280b0e1a88c493b688 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Fri, 24 Apr 2015 17:29:19 +1000 Subject: [PATCH 20/75] OP-1848 altvario UI scaling fixes and help text edits. --- .../src/plugins/config/stabilization.ui | 53 ++++++++++--------- 1 file changed, 28 insertions(+), 25 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index 9956ebbb7..c09db2c85 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -7,7 +7,7 @@ 0 0 974 - 857 + 755 @@ -8245,7 +8245,7 @@ border-radius: 5; 0 0 950 - 773 + 736 @@ -18237,7 +18237,7 @@ border-radius: 5; 0 0 950 - 773 + 671 @@ -24083,7 +24083,7 @@ font:bold; 0 0 950 - 773 + 671 @@ -25295,13 +25295,13 @@ border-radius: 5; - <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> + <html><head/><body><p>How fast the vehicle should attain its target velocity. For neutral throttle estimation, the altitude module assumes that when engaged the throttle thrust limit neutral setting is in the range required to hover. If the throttle required is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot;. Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> - 10 + 100 - 10 + 50 Qt::Horizontal @@ -25314,7 +25314,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Ki - scale:0.00001 + scale:0.01 haslimits:yes buttongroup:98 @@ -25351,17 +25351,17 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 10 + 100 - 10 + 51 objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Ki - scale:0.00001 + scale:0.001 haslimits:yes buttongroup:98,10 @@ -25402,10 +25402,10 @@ border-radius: 5; - <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> + <html><head/><body><p>Small abouts of Kd can reduce oscillations in the velocity controller.</p></body></html> - 1000 + 100 50 @@ -25421,7 +25421,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Kd - scale:0.00001 + scale:100 haslimits:yes buttongroup:98 @@ -25458,17 +25458,17 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 1 + 100 - 1 + 51 objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Kd - scale:0.00001 + scale:0.001 haslimits:yes buttongroup:98,10 @@ -25509,13 +25509,16 @@ border-radius: 5; - <html><head/><body><p>How fast the vehicle should adjust its neutral throttle estimation. Altitude assumes that when engaged the throttle is in the range required to hover. If the throttle is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot; Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> + <html><head/><body><p>The beta value applies a setpoint weighting that reduces the sensitivity to quick changes in the desired velocity. Transitions from altitude hold to descent/climb can be made smooth applying a Beta value of around 80 to 90%.</p></body></html> - 1 + 100 - 1 + 90 + + + 90 Qt::Horizontal @@ -25528,7 +25531,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Beta - scale:0.00001 + scale:0.001 haslimits:yes buttongroup:98 @@ -25565,17 +25568,17 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 1 + 100 - 1 + 90 objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Beta - scale:0.00001 + scale:100 haslimits:yes buttongroup:98,10 @@ -25632,7 +25635,7 @@ border-radius: 5; - <html><head/><body><p>How fast the vehicle should climb or descent to compensate a certain altitude difference. Higher values could result in more accurate altitude hold but also more violent control actions, lower values are safer and ensure smoother flight. The default value should be fine for the majority of crafts.</p></body></html> + <html><head/><body><p>How fast the vehicle should climb or descent to compensate a certain altitude difference. Higher values could result in more accurate altitude hold but also more violent control actions, lower values are safer and ensure smoother flight. The default value should be fine for the majority of crafts.</p></body></html> 100 From 95574494af5c2316838fa2451b0ffa5929294265 Mon Sep 17 00:00:00 2001 From: m_thread Date: Fri, 24 Apr 2015 14:06:47 +0200 Subject: [PATCH 21/75] OP-1848 Updated Ki ranges and scale. --- .../src/plugins/config/stabilization.ui | 33 ++++++++++--------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index c09db2c85..ea8e6c704 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -95,7 +95,7 @@ QTabWidget::Rounded - 3 + 0 false @@ -136,8 +136,8 @@ 0 0 - 950 - 775 + 936 + 768 @@ -8244,8 +8244,8 @@ border-radius: 5; 0 0 - 950 - 736 + 936 + 685 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 950 - 671 + 952 + 669 @@ -24082,8 +24082,8 @@ font:bold; 0 0 - 950 - 671 + 952 + 669 @@ -25298,10 +25298,13 @@ border-radius: 5; <html><head/><body><p>How fast the vehicle should attain its target velocity. For neutral throttle estimation, the altitude module assumes that when engaged the throttle thrust limit neutral setting is in the range required to hover. If the throttle required is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot;. Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> - 100 + 50 + + + 1 - 50 + 25 Qt::Horizontal @@ -25314,7 +25317,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Ki - scale:0.01 + scale:0.1 haslimits:yes buttongroup:98 @@ -25351,17 +25354,17 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 100 + 50 - 51 + 25 objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Ki - scale:0.001 + scale:0.1 haslimits:yes buttongroup:98,10 From b9a77d7e8513205cb5536fa89ea9763d36f1186d Mon Sep 17 00:00:00 2001 From: abeck70 Date: Fri, 24 Apr 2015 22:40:54 +1000 Subject: [PATCH 22/75] OP-1848 altvario ui scaling --- .../src/plugins/config/stabilization.ui | 36 +++++++++++-------- 1 file changed, 21 insertions(+), 15 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index ea8e6c704..54f50db6a 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -95,7 +95,7 @@ QTabWidget::Rounded - 0 + 3 false @@ -136,8 +136,8 @@ 0 0 - 936 - 768 + 950 + 775 @@ -8244,8 +8244,8 @@ border-radius: 5; 0 0 - 936 - 685 + 950 + 736 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 952 - 669 + 950 + 671 @@ -24082,8 +24082,8 @@ font:bold; 0 0 - 952 - 669 + 950 + 671 @@ -25408,7 +25408,7 @@ border-radius: 5; <html><head/><body><p>Small abouts of Kd can reduce oscillations in the velocity controller.</p></body></html> - 100 + 300 50 @@ -25424,7 +25424,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Kd - scale:100 + scale:0.000001 haslimits:yes buttongroup:98 @@ -25461,7 +25461,7 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 100 + 300 51 @@ -25471,7 +25471,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Kd - scale:0.001 + scale:0.000001 haslimits:yes buttongroup:98,10 @@ -25514,6 +25514,9 @@ border-radius: 5; <html><head/><body><p>The beta value applies a setpoint weighting that reduces the sensitivity to quick changes in the desired velocity. Transitions from altitude hold to descent/climb can be made smooth applying a Beta value of around 80 to 90%.</p></body></html> + + 70 + 100 @@ -25534,7 +25537,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Beta - scale:0.001 + scale:1 haslimits:yes buttongroup:98 @@ -25570,6 +25573,9 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + 70 + 100 @@ -25581,7 +25587,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Beta - scale:100 + scale:1 haslimits:yes buttongroup:98,10 From 45ceada471173f48835314bd3875d148810b9cfc Mon Sep 17 00:00:00 2001 From: abeck70 Date: Fri, 24 Apr 2015 23:34:03 +1000 Subject: [PATCH 23/75] OP-1848 altvario ui fixes --- .../openpilotgcs/src/plugins/config/stabilization.ui | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index 54f50db6a..f13ea2f4c 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -25408,7 +25408,7 @@ border-radius: 5; <html><head/><body><p>Small abouts of Kd can reduce oscillations in the velocity controller.</p></body></html> - 300 + 700 50 @@ -25424,7 +25424,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Kd - scale:0.000001 + scale:0.0001 haslimits:yes buttongroup:98 @@ -25461,7 +25461,7 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 300 + 700 51 @@ -25471,7 +25471,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Kd - scale:0.000001 + scale:0.0001 haslimits:yes buttongroup:98,10 @@ -25537,7 +25537,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Beta - scale:1 + scale:0.01 haslimits:yes buttongroup:98 @@ -25587,7 +25587,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Beta - scale:1 + scale:0.01 haslimits:yes buttongroup:98,10 From 7f93340f7fb351e99949d17850e4925c2a2e4b5d Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 24 Apr 2015 22:46:07 +0100 Subject: [PATCH 24/75] OP-1849 Initial commit --- flight/libraries/inc/CoordinateConversions.h | 8 +-- flight/pios/inc/pios_com.h | 10 ++++ flight/pios/inc/pios_instrumentation.h | 8 +-- flight/pios/stm32f4xx/pios_usart.c | 50 +++++++++++++++++-- .../boards/revolution/firmware/pios_board.c | 3 ++ shared/uavobjectdefinition/hwsettings.xml | 2 +- 6 files changed, 67 insertions(+), 14 deletions(-) diff --git a/flight/libraries/inc/CoordinateConversions.h b/flight/libraries/inc/CoordinateConversions.h index e9369bd26..02369c45c 100644 --- a/flight/libraries/inc/CoordinateConversions.h +++ b/flight/libraries/inc/CoordinateConversions.h @@ -112,7 +112,7 @@ static inline void matrix_mult_3x3f(float a[3][3], float b[3][3], float result[3 result[2][2] = a[0][2] * b[2][0] + a[1][2] * b[2][1] + a[2][2] * b[2][2]; } -inline void matrix_inline_scale_3f(float a[3][3], float scale) +static inline void matrix_inline_scale_3f(float a[3][3], float scale) { a[0][0] *= scale; a[0][1] *= scale; @@ -127,7 +127,7 @@ inline void matrix_inline_scale_3f(float a[3][3], float scale) a[2][2] *= scale; } -inline void rot_about_axis_x(const float rotation, float R[3][3]) +static inline void rot_about_axis_x(const float rotation, float R[3][3]) { float s = sinf(rotation); float c = cosf(rotation); @@ -145,7 +145,7 @@ inline void rot_about_axis_x(const float rotation, float R[3][3]) R[2][2] = c; } -inline void rot_about_axis_y(const float rotation, float R[3][3]) +static inline void rot_about_axis_y(const float rotation, float R[3][3]) { float s = sinf(rotation); float c = cosf(rotation); @@ -163,7 +163,7 @@ inline void rot_about_axis_y(const float rotation, float R[3][3]) R[2][2] = c; } -inline void rot_about_axis_z(const float rotation, float R[3][3]) +static inline void rot_about_axis_z(const float rotation, float R[3][3]) { float s = sinf(rotation); float c = cosf(rotation); diff --git a/flight/pios/inc/pios_com.h b/flight/pios/inc/pios_com.h index e2a9639c5..bf7fd6d84 100644 --- a/flight/pios/inc/pios_com.h +++ b/flight/pios/inc/pios_com.h @@ -8,6 +8,7 @@ * * @file pios_com.h * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. + * Parts by Thorsten Klose (tk@midibox.org) * @brief COM layer functions header * @see The GNU Public License (GPL) Version 3 * @@ -35,19 +36,28 @@ #include /* bool */ typedef uint16_t (*pios_com_callback)(uint32_t context, uint8_t *buf, uint16_t buf_len, uint16_t *headroom, bool *task_woken); +typedef void (*pios_com_callback_ctrl_line)(uint32_t context, uint32_t mask, uint32_t state); struct pios_com_driver { void (*init)(uint32_t id); void (*set_baud)(uint32_t id, uint32_t baud); + void (*set_ctrl_line)(uint32_t id, uint32_t mask, uint32_t state); void (*tx_start)(uint32_t id, uint16_t tx_bytes_avail); void (*rx_start)(uint32_t id, uint16_t rx_bytes_avail); void (*bind_rx_cb)(uint32_t id, pios_com_callback rx_in_cb, uint32_t context); void (*bind_tx_cb)(uint32_t id, pios_com_callback tx_out_cb, uint32_t context); + void (*bind_ctrl_line_cb)(uint32_t id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context); bool (*available)(uint32_t id); }; +/* Control line definitions */ +#define COM_CTRL_LINE_DTR_MASK 0x01 +#define COM_CTRL_LINE_RTS_MASK 0x02 + /* Public Functions */ +extern int32_t PIOS_COM_Init(uint32_t *com_id, const struct pios_com_driver *driver, uint32_t lower_id, uint8_t *rx_buffer, uint16_t rx_buffer_len, uint8_t *tx_buffer, uint16_t tx_buffer_len); extern int32_t PIOS_COM_ChangeBaud(uint32_t com_id, uint32_t baud); +extern int32_t PIOS_COM_SetCtrlLine(uint32_t com_id, uint32_t mask, uint32_t state); extern int32_t PIOS_COM_SendCharNonBlocking(uint32_t com_id, char c); extern int32_t PIOS_COM_SendChar(uint32_t com_id, char c); extern int32_t PIOS_COM_SendBufferNonBlocking(uint32_t com_id, const uint8_t *buffer, uint16_t len); diff --git a/flight/pios/inc/pios_instrumentation.h b/flight/pios/inc/pios_instrumentation.h index 6eeaf683c..49e243998 100644 --- a/flight/pios/inc/pios_instrumentation.h +++ b/flight/pios/inc/pios_instrumentation.h @@ -47,7 +47,7 @@ extern int8_t pios_instrumentation_last_used_counter; * @param counter_handle handle of the counter to update @see PIOS_Instrumentation_SearchCounter @see PIOS_Instrumentation_CreateCounter * @param newValue the updated value. */ -inline void PIOS_Instrumentation_updateCounter(pios_counter_t counter_handle, int32_t newValue) +static inline void PIOS_Instrumentation_updateCounter(pios_counter_t counter_handle, int32_t newValue) { PIOS_Assert(pios_instrumentation_perf_counters && counter_handle); vPortEnterCritical(); @@ -69,7 +69,7 @@ inline void PIOS_Instrumentation_updateCounter(pios_counter_t counter_handle, in * Used to determine the time duration of a code block, mark the begin of the block. @see PIOS_Instrumentation_TimeEnd * @param counter_handle handle of the counter @see PIOS_Instrumentation_SearchCounter @see PIOS_Instrumentation_CreateCounter */ -inline void PIOS_Instrumentation_TimeStart(pios_counter_t counter_handle) +static inline void PIOS_Instrumentation_TimeStart(pios_counter_t counter_handle) { PIOS_Assert(pios_instrumentation_perf_counters && counter_handle); vPortEnterCritical(); @@ -83,7 +83,7 @@ inline void PIOS_Instrumentation_TimeStart(pios_counter_t counter_handle) * Used to determine the time duration of a code block, mark the end of the block. @see PIOS_Instrumentation_TimeStart * @param counter_handle handle of the counter @see PIOS_Instrumentation_SearchCounter @see PIOS_Instrumentation_CreateCounter */ -inline void PIOS_Instrumentation_TimeEnd(pios_counter_t counter_handle) +static inline void PIOS_Instrumentation_TimeEnd(pios_counter_t counter_handle) { PIOS_Assert(pios_instrumentation_perf_counters && counter_handle); vPortEnterCritical(); @@ -106,7 +106,7 @@ inline void PIOS_Instrumentation_TimeEnd(pios_counter_t counter_handle) * Used to determine the mean period between each call to the function * @param counter_handle handle of the counter @see PIOS_Instrumentation_SearchCounter @see PIOS_Instrumentation_CreateCounter */ -inline void PIOS_Instrumentation_TrackPeriod(pios_counter_t counter_handle) +static inline void PIOS_Instrumentation_TrackPeriod(pios_counter_t counter_handle) { PIOS_Assert(pios_instrumentation_perf_counters && counter_handle); pios_perf_counter_t *counter = (pios_perf_counter_t *)counter_handle; diff --git a/flight/pios/stm32f4xx/pios_usart.c b/flight/pios/stm32f4xx/pios_usart.c index 3a41b08fd..fa7fefa17 100644 --- a/flight/pios/stm32f4xx/pios_usart.c +++ b/flight/pios/stm32f4xx/pios_usart.c @@ -40,17 +40,21 @@ /* Provide a COM driver */ static void PIOS_USART_ChangeBaud(uint32_t usart_id, uint32_t baud); +static void PIOS_USART_SetCtrlLine(uint32_t usart_id, uint32_t mask, uint32_t state); static void PIOS_USART_RegisterRxCallback(uint32_t usart_id, pios_com_callback rx_in_cb, uint32_t context); static void PIOS_USART_RegisterTxCallback(uint32_t usart_id, pios_com_callback tx_out_cb, uint32_t context); +static void PIOS_USART_RegisterCtrlLineCallback(uint32_t usart_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context); static void PIOS_USART_TxStart(uint32_t usart_id, uint16_t tx_bytes_avail); static void PIOS_USART_RxStart(uint32_t usart_id, uint16_t rx_bytes_avail); const struct pios_com_driver pios_usart_com_driver = { - .set_baud = PIOS_USART_ChangeBaud, - .tx_start = PIOS_USART_TxStart, - .rx_start = PIOS_USART_RxStart, - .bind_tx_cb = PIOS_USART_RegisterTxCallback, - .bind_rx_cb = PIOS_USART_RegisterRxCallback, + .set_baud = PIOS_USART_ChangeBaud, + .set_ctrl_line = PIOS_USART_SetCtrlLine, + .tx_start = PIOS_USART_TxStart, + .rx_start = PIOS_USART_RxStart, + .bind_tx_cb = PIOS_USART_RegisterTxCallback, + .bind_rx_cb = PIOS_USART_RegisterRxCallback, + .bind_ctrl_line_cb = PIOS_USART_RegisterCtrlLineCallback, }; enum pios_usart_dev_magic { @@ -65,6 +69,8 @@ struct pios_usart_dev { uint32_t rx_in_context; pios_com_callback tx_out_cb; uint32_t tx_out_context; + pios_com_callback_ctrl_line ctrl_line_cb; + uint32_t ctrl_line_context; }; static bool PIOS_USART_validate(struct pios_usart_dev *usart_dev) @@ -194,6 +200,11 @@ int32_t PIOS_USART_Init(uint32_t *usart_id, const struct pios_usart_cfg *cfg) *usart_id = (uint32_t)usart_dev; + /* Set initial control line state */ + PIOS_USART_SetCtrlLine((uint32_t)usart_dev, + COM_CTRL_LINE_DTR_MASK | COM_CTRL_LINE_RTS_MASK, + COM_CTRL_LINE_DTR_MASK | COM_CTRL_LINE_RTS_MASK); + /* Configure USART Interrupts */ switch ((uint32_t)usart_dev->cfg->regs) { case (uint32_t)USART1: @@ -276,6 +287,19 @@ static void PIOS_USART_ChangeBaud(uint32_t usart_id, uint32_t baud) USART_Init(usart_dev->cfg->regs, &USART_InitStructure); } +static void PIOS_USART_SetCtrlLine(uint32_t usart_id, uint32_t mask, uint32_t state) +{ + struct pios_usart_dev *usart_dev = (struct pios_usart_dev *)usart_id; + + bool valid = PIOS_USART_validate(usart_dev); + + PIOS_Assert(valid); + + if (usart_dev->ctrl_line_cb) { + (usart_dev->ctrl_line_cb)(usart_dev->ctrl_line_context, mask, state); + } +} + static void PIOS_USART_RegisterRxCallback(uint32_t usart_id, pios_com_callback rx_in_cb, uint32_t context) { struct pios_usart_dev *usart_dev = (struct pios_usart_dev *)usart_id; @@ -308,6 +332,22 @@ static void PIOS_USART_RegisterTxCallback(uint32_t usart_id, pios_com_callback t usart_dev->tx_out_cb = tx_out_cb; } +static void PIOS_USART_RegisterCtrlLineCallback(uint32_t usart_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context) +{ + struct pios_usart_dev *usart_dev = (struct pios_usart_dev *)usart_id; + + bool valid = PIOS_USART_validate(usart_dev); + + PIOS_Assert(valid); + + /* + * Order is important in these assignments since ISR uses _cb + * field to determine if it's ok to dereference _cb and _context + */ + usart_dev->ctrl_line_context = context; + usart_dev->ctrl_line_cb = ctrl_line_cb; +} + static void PIOS_USART_generic_irq_handler(uint32_t usart_id) { struct pios_usart_dev *usart_dev = (struct pios_usart_dev *)usart_id; diff --git a/flight/targets/boards/revolution/firmware/pios_board.c b/flight/targets/boards/revolution/firmware/pios_board.c index 23c6d88fc..6076cb87e 100644 --- a/flight/targets/boards/revolution/firmware/pios_board.c +++ b/flight/targets/boards/revolution/firmware/pios_board.c @@ -866,6 +866,9 @@ void PIOS_Board_Init(void) case HWSETTINGS_RM_RCVRPORT_TELEMETRY: PIOS_Board_configure_com(&pios_usart_rcvrport_cfg, PIOS_COM_TELEM_RF_RX_BUF_LEN, PIOS_COM_TELEM_RF_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_telem_rf_id); break; + case HWSETTINGS_RM_RCVRPORT_COMBRIDGE: + PIOS_Board_configure_com(&pios_usart_rcvrport_cfg, PIOS_COM_BRIDGE_RX_BUF_LEN, PIOS_COM_BRIDGE_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_bridge_id); + break; } diff --git a/shared/uavobjectdefinition/hwsettings.xml b/shared/uavobjectdefinition/hwsettings.xml index ed5af59d4..0e43947a4 100644 --- a/shared/uavobjectdefinition/hwsettings.xml +++ b/shared/uavobjectdefinition/hwsettings.xml @@ -12,7 +12,7 @@ - + From 7445add2803bea10fa6ad6877944aee7f650401a Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sun, 26 Apr 2015 03:05:47 +0100 Subject: [PATCH 25/75] OP-1849 Hooks all in place for CDC line state changes to drive port GPIO for DTR --- flight/modules/ComUsbBridge/ComUsbBridge.c | 21 +++++++- flight/pios/common/pios_com.c | 50 +++++++++++++++++++ flight/pios/inc/pios_com.h | 1 + flight/pios/inc/pios_usart_priv.h | 1 + flight/pios/stm32f4xx/pios_usart.c | 49 ++++++------------ flight/pios/stm32f4xx/pios_usb_cdc.c | 26 ++++++++++ .../targets/boards/revolution/board_hw_defs.c | 10 ++++ 7 files changed, 123 insertions(+), 35 deletions(-) diff --git a/flight/modules/ComUsbBridge/ComUsbBridge.c b/flight/modules/ComUsbBridge/ComUsbBridge.c index ad3cad4ce..400b921ac 100644 --- a/flight/modules/ComUsbBridge/ComUsbBridge.c +++ b/flight/modules/ComUsbBridge/ComUsbBridge.c @@ -43,6 +43,7 @@ static void com2UsbBridgeTask(void *parameters); static void usb2ComBridgeTask(void *parameters); static void updateSettings(UAVObjEvent *ev); +static void usb2ComBridgeSetCtrlLine(uint32_t com_id, uint32_t mask, uint32_t state); // **************** // Private constants @@ -95,8 +96,16 @@ static int32_t comUsbBridgeStart(void) static int32_t comUsbBridgeInitialize(void) { // TODO: Get from settings object - usart_port = PIOS_COM_BRIDGE; - vcp_port = PIOS_COM_VCP; + usart_port = PIOS_COM_BRIDGE; + vcp_port = PIOS_COM_VCP; + + // Register the call back handler for USB control line changes to simply + // pass these onto any handler registered on the USART + if (vcp_port) { + PIOS_COM_RegisterCtrlLineCallback(vcp_port, + usb2ComBridgeSetCtrlLine, + usart_port); + } #ifdef MODULE_COMUSBBRIDGE_BUILTIN bridge_enabled = true; @@ -168,6 +177,14 @@ static void usb2ComBridgeTask(__attribute__((unused)) void *parameters) } } +/* This routine is registered with the USB driver and will be called in the + * event of a control line state change. It will then call down to the USART + * driver to drive the required control line state. + */ +static void usb2ComBridgeSetCtrlLine(uint32_t com_id, uint32_t mask, uint32_t state) +{ + PIOS_COM_SetCtrlLine(com_id, mask, state); +} static void updateSettings(__attribute__((unused)) UAVObjEvent *ev) { diff --git a/flight/pios/common/pios_com.c b/flight/pios/common/pios_com.c index 07e703ba2..9a4b83f60 100644 --- a/flight/pios/common/pios_com.c +++ b/flight/pios/common/pios_com.c @@ -283,6 +283,56 @@ int32_t PIOS_COM_ChangeBaud(uint32_t com_id, uint32_t baud) return 0; } +/** + * Set control lines associated with the port + * \param[in] port COM port + * \param[in] mask Lines to change + * \param[in] state New state for lines + * \return -1 if port not available + * \return 0 on success + */ +int32_t PIOS_COM_SetCtrlLine(uint32_t com_id, uint32_t mask, uint32_t state) +{ + struct pios_com_dev *com_dev = (struct pios_com_dev *)com_id; + + if (!PIOS_COM_validate(com_dev)) { + /* Undefined COM port for this board (see pios_board.c) */ + return -1; + } + + /* Invoke the driver function if it exists */ + if (com_dev->driver->set_ctrl_line) { + com_dev->driver->set_ctrl_line(com_dev->lower_id, mask, state); + } + + return 0; +} + +/** + * Set control lines associated with the port + * \param[in] port COM port + * \param[in] ctrl_line_cb Callback function + * \param[in] context context to pass to the callback function + * \return -1 if port not available + * \return 0 on success + */ +int32_t PIOS_COM_RegisterCtrlLineCallback(uint32_t com_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context) +{ + struct pios_com_dev *com_dev = (struct pios_com_dev *)com_id; + + if (!PIOS_COM_validate(com_dev)) { + /* Undefined COM port for this board (see pios_board.c) */ + return -1; + } + + /* Invoke the driver function if it exists */ + if (com_dev->driver->bind_ctrl_line_cb) { + com_dev->driver->bind_ctrl_line_cb(com_dev->lower_id, ctrl_line_cb, context); + } + + return 0; +} + static int32_t PIOS_COM_SendBufferNonBlockingInternal(struct pios_com_dev *com_dev, const uint8_t *buffer, uint16_t len) { diff --git a/flight/pios/inc/pios_com.h b/flight/pios/inc/pios_com.h index bf7fd6d84..b2591e4f0 100644 --- a/flight/pios/inc/pios_com.h +++ b/flight/pios/inc/pios_com.h @@ -58,6 +58,7 @@ struct pios_com_driver { extern int32_t PIOS_COM_Init(uint32_t *com_id, const struct pios_com_driver *driver, uint32_t lower_id, uint8_t *rx_buffer, uint16_t rx_buffer_len, uint8_t *tx_buffer, uint16_t tx_buffer_len); extern int32_t PIOS_COM_ChangeBaud(uint32_t com_id, uint32_t baud); extern int32_t PIOS_COM_SetCtrlLine(uint32_t com_id, uint32_t mask, uint32_t state); +extern int32_t PIOS_COM_RegisterCtrlLineCallback(uint32_t usart_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context); extern int32_t PIOS_COM_SendCharNonBlocking(uint32_t com_id, char c); extern int32_t PIOS_COM_SendChar(uint32_t com_id, char c); extern int32_t PIOS_COM_SendBufferNonBlocking(uint32_t com_id, const uint8_t *buffer, uint16_t len); diff --git a/flight/pios/inc/pios_usart_priv.h b/flight/pios/inc/pios_usart_priv.h index 52394e5f4..68a44bc9d 100644 --- a/flight/pios/inc/pios_usart_priv.h +++ b/flight/pios/inc/pios_usart_priv.h @@ -44,6 +44,7 @@ struct pios_usart_cfg { USART_InitTypeDef init; struct stm32_gpio rx; struct stm32_gpio tx; + struct stm32_gpio dtr; struct stm32_irq irq; }; diff --git a/flight/pios/stm32f4xx/pios_usart.c b/flight/pios/stm32f4xx/pios_usart.c index fa7fefa17..3f030131a 100644 --- a/flight/pios/stm32f4xx/pios_usart.c +++ b/flight/pios/stm32f4xx/pios_usart.c @@ -43,18 +43,16 @@ static void PIOS_USART_ChangeBaud(uint32_t usart_id, uint32_t baud); static void PIOS_USART_SetCtrlLine(uint32_t usart_id, uint32_t mask, uint32_t state); static void PIOS_USART_RegisterRxCallback(uint32_t usart_id, pios_com_callback rx_in_cb, uint32_t context); static void PIOS_USART_RegisterTxCallback(uint32_t usart_id, pios_com_callback tx_out_cb, uint32_t context); -static void PIOS_USART_RegisterCtrlLineCallback(uint32_t usart_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context); static void PIOS_USART_TxStart(uint32_t usart_id, uint16_t tx_bytes_avail); static void PIOS_USART_RxStart(uint32_t usart_id, uint16_t rx_bytes_avail); const struct pios_com_driver pios_usart_com_driver = { - .set_baud = PIOS_USART_ChangeBaud, - .set_ctrl_line = PIOS_USART_SetCtrlLine, - .tx_start = PIOS_USART_TxStart, - .rx_start = PIOS_USART_RxStart, - .bind_tx_cb = PIOS_USART_RegisterTxCallback, - .bind_rx_cb = PIOS_USART_RegisterRxCallback, - .bind_ctrl_line_cb = PIOS_USART_RegisterCtrlLineCallback, + .set_baud = PIOS_USART_ChangeBaud, + .set_ctrl_line = PIOS_USART_SetCtrlLine, + .tx_start = PIOS_USART_TxStart, + .rx_start = PIOS_USART_RxStart, + .bind_tx_cb = PIOS_USART_RegisterTxCallback, + .bind_rx_cb = PIOS_USART_RegisterRxCallback, }; enum pios_usart_dev_magic { @@ -69,8 +67,6 @@ struct pios_usart_dev { uint32_t rx_in_context; pios_com_callback tx_out_cb; uint32_t tx_out_context; - pios_com_callback_ctrl_line ctrl_line_cb; - uint32_t ctrl_line_context; }; static bool PIOS_USART_validate(struct pios_usart_dev *usart_dev) @@ -195,16 +191,16 @@ int32_t PIOS_USART_Init(uint32_t *usart_id, const struct pios_usart_cfg *cfg) GPIO_Init(usart_dev->cfg->rx.gpio, (GPIO_InitTypeDef *)&usart_dev->cfg->rx.init); GPIO_Init(usart_dev->cfg->tx.gpio, (GPIO_InitTypeDef *)&usart_dev->cfg->tx.init); + /* If a DTR line is specified, initialize it */ + if (usart_dev->cfg->dtr.gpio) { + GPIO_Init(usart_dev->cfg->dtr.gpio, (GPIO_InitTypeDef *)&usart_dev->cfg->dtr.init); + } + /* Configure the USART */ USART_Init(usart_dev->cfg->regs, (USART_InitTypeDef *)&usart_dev->cfg->init); *usart_id = (uint32_t)usart_dev; - /* Set initial control line state */ - PIOS_USART_SetCtrlLine((uint32_t)usart_dev, - COM_CTRL_LINE_DTR_MASK | COM_CTRL_LINE_RTS_MASK, - COM_CTRL_LINE_DTR_MASK | COM_CTRL_LINE_RTS_MASK); - /* Configure USART Interrupts */ switch ((uint32_t)usart_dev->cfg->regs) { case (uint32_t)USART1: @@ -295,8 +291,11 @@ static void PIOS_USART_SetCtrlLine(uint32_t usart_id, uint32_t mask, uint32_t st PIOS_Assert(valid); - if (usart_dev->ctrl_line_cb) { - (usart_dev->ctrl_line_cb)(usart_dev->ctrl_line_context, mask, state); + /* Only attempt to drive DTR if this USART has a GPIO line defined */ + if (usart_dev->cfg->dtr.gpio && (mask & COM_CTRL_LINE_DTR_MASK)) { + GPIO_WriteBit(usart_dev->cfg->dtr.gpio, + usart_dev->cfg->dtr.init.GPIO_Pin, + state & COM_CTRL_LINE_DTR_MASK ? Bit_SET : Bit_RESET); } } @@ -332,22 +331,6 @@ static void PIOS_USART_RegisterTxCallback(uint32_t usart_id, pios_com_callback t usart_dev->tx_out_cb = tx_out_cb; } -static void PIOS_USART_RegisterCtrlLineCallback(uint32_t usart_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context) -{ - struct pios_usart_dev *usart_dev = (struct pios_usart_dev *)usart_id; - - bool valid = PIOS_USART_validate(usart_dev); - - PIOS_Assert(valid); - - /* - * Order is important in these assignments since ISR uses _cb - * field to determine if it's ok to dereference _cb and _context - */ - usart_dev->ctrl_line_context = context; - usart_dev->ctrl_line_cb = ctrl_line_cb; -} - static void PIOS_USART_generic_irq_handler(uint32_t usart_id) { struct pios_usart_dev *usart_dev = (struct pios_usart_dev *)usart_id; diff --git a/flight/pios/stm32f4xx/pios_usb_cdc.c b/flight/pios/stm32f4xx/pios_usb_cdc.c index 253295d94..277165af2 100644 --- a/flight/pios/stm32f4xx/pios_usb_cdc.c +++ b/flight/pios/stm32f4xx/pios_usb_cdc.c @@ -40,6 +40,7 @@ /* Implement COM layer driver API */ static void PIOS_USB_CDC_RegisterTxCallback(uint32_t usbcdc_id, pios_com_callback tx_out_cb, uint32_t context); static void PIOS_USB_CDC_RegisterRxCallback(uint32_t usbcdc_id, pios_com_callback rx_in_cb, uint32_t context); +static void PIOS_USB_CDC_RegisterCtrlLineCallback(uint32_t usbcdc_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context); static void PIOS_USB_CDC_TxStart(uint32_t usbcdc_id, uint16_t tx_bytes_avail); static void PIOS_USB_CDC_RxStart(uint32_t usbcdc_id, uint16_t rx_bytes_avail); static bool PIOS_USB_CDC_Available(uint32_t usbcdc_id); @@ -49,6 +50,7 @@ const struct pios_com_driver pios_usb_cdc_com_driver = { .rx_start = PIOS_USB_CDC_RxStart, .bind_tx_cb = PIOS_USB_CDC_RegisterTxCallback, .bind_rx_cb = PIOS_USB_CDC_RegisterRxCallback, + .bind_ctrl_line_cb = PIOS_USB_CDC_RegisterCtrlLineCallback, .available = PIOS_USB_CDC_Available, }; @@ -66,6 +68,8 @@ struct pios_usb_cdc_dev { uint32_t rx_in_context; pios_com_callback tx_out_cb; uint32_t tx_out_context; + pios_com_callback_ctrl_line ctrl_line_cb; + uint32_t ctrl_line_context; bool usb_ctrl_if_enabled; bool usb_data_if_enabled; @@ -323,6 +327,23 @@ static void PIOS_USB_CDC_RegisterTxCallback(uint32_t usbcdc_id, pios_com_callbac usb_cdc_dev->tx_out_cb = tx_out_cb; } +static void PIOS_USB_CDC_RegisterCtrlLineCallback(uint32_t usbcdc_id, pios_com_callback_ctrl_line ctrl_line_cb, uint32_t context) +{ + struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id; + + bool valid = PIOS_USB_CDC_validate(usb_cdc_dev); + + PIOS_Assert(valid); + + /* + * Order is important in these assignments since ISR uses _cb + * field to determine if it's ok to dereference _cb and _context + */ + usb_cdc_dev->ctrl_line_context = context; + usb_cdc_dev->ctrl_line_cb = ctrl_line_cb; +} + + static bool PIOS_USB_CDC_CTRL_EP_IN_Callback(uint32_t usb_cdc_id, uint8_t epnum, uint16_t len); static void PIOS_USB_CDC_CTRL_IF_Init(uint32_t usb_cdc_id) @@ -403,6 +424,11 @@ static bool PIOS_USB_CDC_CTRL_IF_Setup(uint32_t usb_cdc_id, struct usb_setup_req break; case USB_CDC_REQ_SET_CONTROL_LINE_STATE: control_line_state = req->wValue; + if (usb_cdc_dev->ctrl_line_cb) { + (usb_cdc_dev->ctrl_line_cb)(usb_cdc_dev->ctrl_line_context, + 0xff, + control_line_state); + } break; default: /* Unhandled class request */ diff --git a/flight/targets/boards/revolution/board_hw_defs.c b/flight/targets/boards/revolution/board_hw_defs.c index 4d5b8aa22..ea7f5fb92 100644 --- a/flight/targets/boards/revolution/board_hw_defs.c +++ b/flight/targets/boards/revolution/board_hw_defs.c @@ -1112,6 +1112,16 @@ static const struct pios_usart_cfg pios_usart_rcvrport_cfg = { }, }, + .dtr = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_13, // FlexIO pin 4 + .GPIO_Speed = GPIO_Speed_25MHz, + .GPIO_Mode = GPIO_Mode_OUT, + .GPIO_OType = GPIO_OType_PP, + }, + }, + .tx = { // * 7: PC6 = TIM8 CH1, USART6 TX .gpio = GPIOC, From 25b0b3df0f37bd5ae96bee8602ad950d5f6d3eab Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sun, 26 Apr 2015 11:26:04 +0100 Subject: [PATCH 26/75] OP-1849 For Revo put DTR on pin 9 of FlexIO port --- flight/targets/boards/revolution/board_hw_defs.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/flight/targets/boards/revolution/board_hw_defs.c b/flight/targets/boards/revolution/board_hw_defs.c index ea7f5fb92..f935f4fc2 100644 --- a/flight/targets/boards/revolution/board_hw_defs.c +++ b/flight/targets/boards/revolution/board_hw_defs.c @@ -1113,13 +1113,14 @@ static const struct pios_usart_cfg pios_usart_rcvrport_cfg = { }, .dtr = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_13, // FlexIO pin 4 + // FlexIO pin 9 + .gpio = GPIOC, + .init = { + .GPIO_Pin = GPIO_Pin_8, .GPIO_Speed = GPIO_Speed_25MHz, .GPIO_Mode = GPIO_Mode_OUT, .GPIO_OType = GPIO_OType_PP, - }, + }, }, .tx = { From e89356deb297cf9ddea50973a26bf5a2ed0fde11 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sun, 26 Apr 2015 14:18:40 +0100 Subject: [PATCH 27/75] OP-1849 Invert DTR and initialise --- flight/pios/stm32f4xx/pios_usart.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/flight/pios/stm32f4xx/pios_usart.c b/flight/pios/stm32f4xx/pios_usart.c index 3f030131a..bcc26cacf 100644 --- a/flight/pios/stm32f4xx/pios_usart.c +++ b/flight/pios/stm32f4xx/pios_usart.c @@ -194,6 +194,7 @@ int32_t PIOS_USART_Init(uint32_t *usart_id, const struct pios_usart_cfg *cfg) /* If a DTR line is specified, initialize it */ if (usart_dev->cfg->dtr.gpio) { GPIO_Init(usart_dev->cfg->dtr.gpio, (GPIO_InitTypeDef *)&usart_dev->cfg->dtr.init); + PIOS_USART_SetCtrlLine((uint32_t)usart_dev, COM_CTRL_LINE_DTR_MASK, 0); } /* Configure the USART */ @@ -295,7 +296,7 @@ static void PIOS_USART_SetCtrlLine(uint32_t usart_id, uint32_t mask, uint32_t st if (usart_dev->cfg->dtr.gpio && (mask & COM_CTRL_LINE_DTR_MASK)) { GPIO_WriteBit(usart_dev->cfg->dtr.gpio, usart_dev->cfg->dtr.init.GPIO_Pin, - state & COM_CTRL_LINE_DTR_MASK ? Bit_SET : Bit_RESET); + state & COM_CTRL_LINE_DTR_MASK ? Bit_RESET : Bit_SET); } } From 5c5c8b5947bd35e047f92529cbbfab32479bfe59 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sun, 26 Apr 2015 21:45:43 +0100 Subject: [PATCH 28/75] OP-1849 Uncrustify --- flight/targets/boards/revolution/board_hw_defs.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/flight/targets/boards/revolution/board_hw_defs.c b/flight/targets/boards/revolution/board_hw_defs.c index f935f4fc2..e8985eaf5 100644 --- a/flight/targets/boards/revolution/board_hw_defs.c +++ b/flight/targets/boards/revolution/board_hw_defs.c @@ -1113,14 +1113,14 @@ static const struct pios_usart_cfg pios_usart_rcvrport_cfg = { }, .dtr = { - // FlexIO pin 9 - .gpio = GPIOC, - .init = { - .GPIO_Pin = GPIO_Pin_8, + // FlexIO pin 9 + .gpio = GPIOC, + .init = { + .GPIO_Pin = GPIO_Pin_8, .GPIO_Speed = GPIO_Speed_25MHz, .GPIO_Mode = GPIO_Mode_OUT, .GPIO_OType = GPIO_OType_PP, - }, + }, }, .tx = { From 55f2b2fabbd510ef78ca99624052e102cc708c86 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Sun, 26 Apr 2015 22:19:51 +0100 Subject: [PATCH 29/75] OP-1849 Fix GCS HW Settings tab to only display receiver port com-bridge if available --- .../openpilotgcs/src/plugins/config/configrevohwwidget.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ground/openpilotgcs/src/plugins/config/configrevohwwidget.cpp b/ground/openpilotgcs/src/plugins/config/configrevohwwidget.cpp index ae224bd6c..5a0258da8 100644 --- a/ground/openpilotgcs/src/plugins/config/configrevohwwidget.cpp +++ b/ground/openpilotgcs/src/plugins/config/configrevohwwidget.cpp @@ -151,6 +151,12 @@ void ConfigRevoHWWidget::usbVCPPortChanged(int index) m_ui->cbMain->model()->setData(m_ui->cbMain->model()->index(HwSettings::RM_MAINPORT_COMBRIDGE, 0), !vcpComBridgeEnabled ? QVariant(0) : QVariant(1 | 32), Qt::UserRole - 1); + if (!vcpComBridgeEnabled && m_ui->cbRcvr->currentIndex() == HwSettings::RM_RCVRPORT_COMBRIDGE) { + m_ui->cbRcvr->setCurrentIndex(HwSettings::RM_RCVRPORT_DISABLED); + } + m_ui->cbRcvr->model()->setData(m_ui->cbRcvr->model()->index(HwSettings::RM_RCVRPORT_COMBRIDGE, 0), + !vcpComBridgeEnabled ? QVariant(0) : QVariant(1 | 32), Qt::UserRole - 1); + // _DEBUGCONSOLE modes are mutual exclusive if (m_ui->cbUSBVCPFunction->currentIndex() == HwSettings::USB_VCPPORT_DEBUGCONSOLE) { if (m_ui->cbMain->currentIndex() == HwSettings::RM_MAINPORT_DEBUGCONSOLE) { From 0f9218d3afff5da2186d15591b512afb96b985a1 Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Mon, 27 Apr 2015 15:45:45 -0400 Subject: [PATCH 30/75] X-Plane 10 HITL & SITL protocol changes that should have been in place long ago! --- .../src/plugins/hitl/hitlnoisegeneration.h | 3 +- .../src/plugins/hitl/hitlplugin.cpp | 3 +- .../openpilotgcs/src/plugins/hitl/plugin.pro | 6 +- .../src/plugins/hitl/xplanesimulator10.cpp | 360 ++++++++++++++++++ .../src/plugins/hitl/xplanesimulator10.h | 95 +++++ ...lanesimulator.cpp => xplanesimulator9.cpp} | 0 .../{xplanesimulator.h => xplanesimulator9.h} | 16 +- 7 files changed, 471 insertions(+), 12 deletions(-) create mode 100644 ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp create mode 100644 ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.h rename ground/openpilotgcs/src/plugins/hitl/{xplanesimulator.cpp => xplanesimulator9.cpp} (100%) rename ground/openpilotgcs/src/plugins/hitl/{xplanesimulator.h => xplanesimulator9.h} (88%) diff --git a/ground/openpilotgcs/src/plugins/hitl/hitlnoisegeneration.h b/ground/openpilotgcs/src/plugins/hitl/hitlnoisegeneration.h index 22df94b72..1e828f450 100644 --- a/ground/openpilotgcs/src/plugins/hitl/hitlnoisegeneration.h +++ b/ground/openpilotgcs/src/plugins/hitl/hitlnoisegeneration.h @@ -30,7 +30,8 @@ // #include // #include -#include "xplanesimulator.h" +#include "xplanesimulator9.h" +#include "xplanesimulator10.h" #include "hitlnoisegeneration.h" #include "extensionsystem/pluginmanager.h" #include diff --git a/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp b/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp index 0ce9e9141..adefb920a 100644 --- a/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp +++ b/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp @@ -32,7 +32,8 @@ #include "aerosimrcsimulator.h" #include "fgsimulator.h" #include "il2simulator.h" -#include "xplanesimulator.h" +#include "xplanesimulator9.h" +#include "xplanesimulator10.h" QList HITLPlugin::typeSimulators; diff --git a/ground/openpilotgcs/src/plugins/hitl/plugin.pro b/ground/openpilotgcs/src/plugins/hitl/plugin.pro index 066c60ec0..3eb167d74 100644 --- a/ground/openpilotgcs/src/plugins/hitl/plugin.pro +++ b/ground/openpilotgcs/src/plugins/hitl/plugin.pro @@ -16,7 +16,8 @@ HEADERS += hitlplugin.h \ aerosimrcsimulator.h \ fgsimulator.h \ il2simulator.h \ - xplanesimulator.h + xplanesimulator9.h + xplanesimulator10.h SOURCES += hitlplugin.cpp \ hitlwidget.cpp \ hitloptionspage.cpp \ @@ -28,7 +29,8 @@ SOURCES += hitlplugin.cpp \ aerosimrcsimulator.cpp \ fgsimulator.cpp \ il2simulator.cpp \ - xplanesimulator.cpp + xplanesimulator9.cpp + xplanesimulator10.cpp OTHER_FILES += hitl.pluginspec FORMS += hitloptionspage.ui \ hitlwidget.ui diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp new file mode 100644 index 000000000..6ca79f4f4 --- /dev/null +++ b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp @@ -0,0 +1,360 @@ +/** + ****************************************************************************** + * + * @file xplanesimulator10.cpp + * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. + * @brief + * @see The GNU Public License (GPL) Version 3 + * @defgroup hitlplugin + * @{ + * + *****************************************************************************/ +/* + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/** + * Description of X-Plane Protocol: + * + * To see what data can be sended/recieved to/from X-Plane, launch X-Plane -> goto main menu + * (cursor at top of main X-Plane window) -> Settings -> Data Input and Output -> Data Set. + * Data Set shown all X-Plane params, + * each row has four checkbox: 1st check - out to UDP; 4 check - show on screen + * All the UDP messages for X-Plane have the same format, which is: + * 5-character MESSAGE PROLOUGE (to indicate the type of message) + * and then a DATA INPUT STRUCTURE (containing the message data that you want to send or receive) + * + * DATA INPUT/OUTPUT STRUCTURE is the following stuct: + * + * struct data_struct + * { + * int index; // data index, the index into the list of variables + // you can output from the Data Output screen in X-Plane. + * float data[8]; // the up to 8 numbers you see in the data output screen associated with that selection.. + // many outputs do not use all 8, though. + * }; + * + * For Example, update of aileron/elevon/rudder in X-Plane (11 row in Data Set) + * bytes value description + * [0-3] DATA message type + * [4] none no matter + * [5-8] 11 code of setting param(row in Data Set) + * [9-41] data message data (8 float values) + * total size: 41 byte + * + */ + +#include "xplanesimulator10.h" +#include "extensionsystem/pluginmanager.h" +#include +#include +#include + +void TraceBuf(const char *buf, int len); + +XplaneSimulator10::XplaneSimulator10(const SimulatorSettings & params) : + Simulator(params) +{ + resetInitialHomePosition(); +} + + +XplaneSimulator10::~XplaneSimulator10() +{} + +void XplaneSimulator10::setupUdpPorts(const QString & host, int inPort, int outPort) +{ + Q_UNUSED(outPort); + + inSocket->bind(QHostAddress(host), inPort); + // outSocket->bind(QHostAddress(host), outPort); + resetInitialHomePosition(); +} + +bool XplaneSimulator10::setupProcess() +{ + emit processOutput(QString("Please start X-Plane 10 manually, and make sure it is setup to output its ") + + "data to host " + settings.hostAddress + " UDP port " + QString::number(settings.inPort)); + + return true; +} + +/** + * update data in X-Plane simulator + */ +void XplaneSimulator10::transmitUpdate() +{ + if (settings.manualControlEnabled) { + // Read ActuatorDesired from autopilot + ActuatorDesired::DataFields actData = actDesired->getData(); + float ailerons = actData.Roll; + float elevator = actData.Pitch; + float rudder = actData.Yaw; + float throttle = actData.Thrust > 0 ? actData.Thrust : 0; + float none = -999; + // quint32 none = *((quint32*)&tmp); // get float as 4 bytes + + quint32 code; + QByteArray buf; + QDataStream stream(&buf, QIODevice::ReadWrite); + + // !!! LAN byte order - Big Endian +#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN + stream.setByteOrder(QDataStream::LittleEndian); +#endif + + // 11th data settings (flight con: ail/elv/rud) + buf.clear(); + code = 11; + // quint8 header[] = "DATA"; + /* + stream << *((quint32*)header) << + (quint8)0x30 << + code << + *((quint32*)&elevator) << + *((quint32*)&ailerons) << + *((quint32*)&rudder) << + none << + *((quint32*)&ailerons) << + none << + none << + none; + */ + buf.append("DATA0"); + buf.append(reinterpret_cast(&code), sizeof(code)); + buf.append(reinterpret_cast(&elevator), sizeof(elevator)); + buf.append(reinterpret_cast(&ailerons), sizeof(ailerons)); + buf.append(reinterpret_cast(&rudder), sizeof(rudder)); + buf.append(reinterpret_cast(&none), sizeof(none)); + buf.append(reinterpret_cast(&rudder), sizeof(rudder)); + buf.append(reinterpret_cast(&none), sizeof(none)); + buf.append(reinterpret_cast(&none), sizeof(none)); + buf.append(reinterpret_cast(&none), sizeof(none)); +// TraceBuf(buf.data(),41); + + if (outSocket->writeDatagram(buf, QHostAddress(settings.remoteAddress), settings.outPort) == -1) { + emit processOutput("Error sending UDP packet to XPlane: " + outSocket->errorString() + "\n"); + } + // outSocket->write(buf); + + // 25th data settings (throttle command) + buf.clear(); + code = 25; + // stream << *((quint32*)header) << (quint8)0x30 << code << *((quint32*)&throttle) << none << none + // << none << none << none << none << none; + buf.append("DATA0"); + buf.append(reinterpret_cast(&code), sizeof(code)); + buf.append(reinterpret_cast(&throttle), sizeof(throttle)); + buf.append(reinterpret_cast(&throttle), sizeof(throttle)); + buf.append(reinterpret_cast(&throttle), sizeof(throttle)); + buf.append(reinterpret_cast(&throttle), sizeof(throttle)); + buf.append(reinterpret_cast(&none), sizeof(none)); + buf.append(reinterpret_cast(&none), sizeof(none)); + buf.append(reinterpret_cast(&none), sizeof(none)); + buf.append(reinterpret_cast(&none), sizeof(none)); + + if (outSocket->writeDatagram(buf, QHostAddress(settings.remoteAddress), settings.outPort) == -1) { + emit processOutput("Error sending UDP packet to XPlane: " + outSocket->errorString() + "\n"); + } + + // outSocket->write(buf); + + + /** !!! this settings was given from ardupilot X-Plane.pl, I comment them + but if it needed comment should be removed !!! + + // 8th data settings (joystick 1 ail/elv/rud) + stream << "DATA0" << quint32(11) << elevator << ailerons << rudder + << float(-999) << float(-999) << float(-999) << float(-999) << float(-999); + outSocket->write(buf); + */ + } +} + +/** + * process data string from X-Plane simulator + */ +void XplaneSimulator10::processUpdate(const QByteArray & dataBuf) +{ + float altitude_msl = 0; + float altitude_agl = 0; + float latitude = 0; + float longitude = 0; + float airspeed_keas = 0; + float groundspeed_ktgs = 0; + float pitch = 0; + float roll = 0; + float heading = 0; + float pressure = 0; + float temperature = 0; + float velX = 0; + float velY = 0; + float velZ = 0; + float dstX = 0; + float dstY = 0; + float dstZ = 0; + float accX = 0; + float accY = 0; + float accZ = 0; + float rollRate_rad = 0; + float pitchRate_rad = 0; + float yawRate_rad = 0; + + // QString str; + QByteArray & buf = const_cast(dataBuf); + QString data(buf); + + if (data.left(4) == "DATA") { // check type of packet + buf.remove(0, 5); + if (dataBuf.size() % 36) { + qDebug() << ("incorrect length of UDP packet: " + buf); + return; // incorrect length of struct + } + // check correctness of data length, length must be multiple of (id_size+8*float_size)=4+8*4=36 + int channelCounter = dataBuf.size() / 36; + do { + switch (buf[0]) { // switch by id + case XplaneSimulator10::LatitudeLongitudeAltitude: + latitude = *((float *)(buf.data() + 4 * 1)); + longitude = *((float *)(buf.data() + 4 * 2)); + altitude_msl = *((float *)(buf.data() + 4 * 3)) * FT2M; + altitude_agl = *((float *)(buf.data() + 4 * 4)) * FT2M; + break; + + case XplaneSimulator10::Speed: + airspeed_keas = *((float *)(buf.data() + 4 * 2)); + groundspeed_ktgs = *((float *)(buf.data() + 4 * 4)); + break; + + case XplaneSimulator10::PitchRollHeading: + pitch = *((float *)(buf.data() + 4 * 1)); + roll = *((float *)(buf.data() + 4 * 2)); + heading = *((float *)(buf.data() + 4 * 3)); + break; + + /* + case XplaneSimulator10::SystemPressures: + pressure = *((float*)(buf.data()+4*1)); + break; + */ + + case XplaneSimulator10::AtmosphereWeather: + pressure = *((float *)(buf.data() + 4 * 1)) * INHG2KPA; + temperature = *((float *)(buf.data() + 4 * 2)); + break; + + case XplaneSimulator10::LocVelDistTraveled: + dstX = *((float *)(buf.data() + 4 * 1)); + dstY = -*((float *)(buf.data() + 4 * 3)); + dstZ = *((float *)(buf.data() + 4 * 2)); + velX = *((float *)(buf.data() + 4 * 4)); + velY = -*((float *)(buf.data() + 4 * 6)); + velZ = *((float *)(buf.data() + 4 * 5)); + break; + + case XplaneSimulator10::AngularVelocities: // In [rad/s] + pitchRate_rad = *((float *)(buf.data() + 4 * 1)); + rollRate_rad = *((float *)(buf.data() + 4 * 2)); + yawRate_rad = *((float *)(buf.data() + 4 * 3)); + break; + + case XplaneSimulator10::Gload: + accX = *((float *)(buf.data() + 4 * 6)) * GEE; + accY = *((float *)(buf.data() + 4 * 7)) * GEE; + accZ = *((float *)(buf.data() + 4 * 5)) * GEE; + break; + + default: + break; + } + channelCounter--; + buf.remove(0, 36); + } while (channelCounter); + + + /////// + // Output formatting + /////// + Output2Hardware out; + memset(&out, 0, sizeof(Output2Hardware)); + + // Update GPS Position objects + out.latitude = latitude * 1e7; + out.longitude = longitude * 1e7; + out.altitude = altitude_msl; + out.agl = altitude_agl; + out.groundspeed = groundspeed_ktgs * 1.15 * 1.6089 / 3.6; // Convert from [kts] to [m/s] + + out.calibratedAirspeed = airspeed_keas * 1.15 * 1.6089 / 3.6; // Convert from [kts] to [m/s] + + // Update BaroSensor object + out.temperature = temperature; + out.pressure = pressure; + + // Update attState object + out.roll = roll; // roll; + out.pitch = pitch; // pitch + out.heading = heading; // yaw + + + out.dstN = dstY; + out.dstE = dstX; + out.dstD = -dstZ; + + // Update VelocityState.{North,East,Down} + out.velNorth = velY; + out.velEast = velX; + out.velDown = -velZ; + + // Update gyroscope sensor data - convert from rad/s to deg/s + out.rollRate = rollRate_rad * (180.0 / M_PI); + out.pitchRate = pitchRate_rad * (180.0 / M_PI); + out.yawRate = yawRate_rad * (180.0 / M_PI); + + // Update accelerometer sensor data + out.accX = accX; + out.accY = accY; + out.accZ = -accZ; + + updateUAVOs(out); + } + // issue manual update + // attState->updated(); + // altState->updated(); + // posState->updated(); +} + + +void TraceBuf(const char *buf, int len) +{ + QString str; + bool reminder = true; + + for (int i = 0; i < len; i++) { + if (!(i % 16)) { + if (i > 0) { + qDebug() << str; + str.clear(); + reminder = false; + } + reminder = true; + } + str += QString(" 0x%1").arg((quint8)buf[i], 2, 16, QLatin1Char('0')); + } + + if (reminder) { + qDebug() << str; + } +} diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.h b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.h new file mode 100644 index 000000000..7a7632296 --- /dev/null +++ b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.h @@ -0,0 +1,95 @@ +/** + ****************************************************************************** + * + * @file xplanesimulator10.h + * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. + * @brief + * @see The GNU Public License (GPL) Version 3 + * @defgroup hitlplugin + * @{ + * + *****************************************************************************/ +/* + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef XPLANESIMULATOR10_H +#define XPLANESIMULATOR10_H + +#include +#include + +class XplaneSimulator10 : public Simulator { + Q_OBJECT +public: + XplaneSimulator10(const SimulatorSettings & params); + ~XplaneSimulator10(); + bool setupProcess(); + + void setupUdpPorts(const QString & host, int inPort, int outPort); + +private slots: + void transmitUpdate(); + +private: + enum XplaneOutputData // ***WARNING***: Elements in this enum are in a precise order, do + { // not change. Cf. http://www.nuclearprojects.com/xplane/info.shtml (outdated version 9 info) + // These fields have been updated for X-Plane version 10.x + /* 0 */ FramRate, + /* 1 */ Times, + /* 2 */ SimStats, + /* 3 */ Speed, + /* 4 */ Gload, + /* 5 */ AtmosphereWeather, + /* 6 */ AtmosphereAircraft, + /* 7 */ SystemPressures, + /* 8 */ Joystick1, + /* 9 */ Joystick2, + /* 10 */ ArtStab, + /* 11 */ FlightCon, + /* 12 */ WingSweep, + /* 13 */ Trim, + /* 14 */ Brakes, + /* 15 */ AngularMoments, + /* 16 */ AngularVelocities, + /* 17 */ PitchRollHeading, + /* 18 */ AoA, + /* 19 */ MagCompass, + /* 20 */ LatitudeLongitude, + /* 21 */ LocVelDistTraveled, + /* 22 */ AllPlanesLat, + /* 23 */ AllPlanesLon, + /* 24 */ AllPlanesAlt, + /* 25 */ ThrottleCommand + /* .. */ + + }; + + void processUpdate(const QByteArray & data); +}; + +class XplaneSimulatorCreator10 : public SimulatorCreator { +public: + XplaneSimulatorCreator10(const QString & classId, const QString & description) + : SimulatorCreator(classId, description) + {} + + Simulator *createSimulator(const SimulatorSettings & params) + { + return new XplaneSimulator10(params); + } +}; + +#endif // XPLANESIMULATOR10_H diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator.cpp b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.cpp similarity index 100% rename from ground/openpilotgcs/src/plugins/hitl/xplanesimulator.cpp rename to ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.cpp diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator.h b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h similarity index 88% rename from ground/openpilotgcs/src/plugins/hitl/xplanesimulator.h rename to ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h index b1c33f36f..f785e425b 100644 --- a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator.h +++ b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h @@ -1,7 +1,7 @@ /** ****************************************************************************** * - * @file xplanesimulator.h + * @file xplanesimulator9.h * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. * @brief * @see The GNU Public License (GPL) Version 3 @@ -25,17 +25,17 @@ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#ifndef XPLANESIMULATOR_H -#define XPLANESIMULATOR_H +#ifndef XPLANESIMULATOR9_H +#define XPLANESIMULATOR9_H #include #include -class XplaneSimulator : public Simulator { +class XplaneSimulator9 : public Simulator { Q_OBJECT public: - XplaneSimulator(const SimulatorSettings & params); - ~XplaneSimulator(); + XplaneSimulator9(const SimulatorSettings & params); + ~XplaneSimulator9(); bool setupProcess(); void setupUdpPorts(const QString & host, int inPort, int outPort); @@ -81,8 +81,8 @@ public: Simulator *createSimulator(const SimulatorSettings & params) { - return new XplaneSimulator(params); + return new XplaneSimulator9(params); } }; -#endif // XPLANESIMULATOR_H +#endif // XPLANESIMULATOR9_H From 996d8a8f4897d7399e904a809ea718cb8b42698d Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Mon, 27 Apr 2015 15:47:48 -0400 Subject: [PATCH 31/75] Change the plugin names to match inclusion of both X-Plane 9 & 10 --- ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp b/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp index adefb920a..7760a8f0c 100644 --- a/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp +++ b/ground/openpilotgcs/src/plugins/hitl/hitlplugin.cpp @@ -58,7 +58,8 @@ bool HITLPlugin::initialize(const QStringList & args, QString *errMsg) addSimulator(new AeroSimRCSimulatorCreator("ASimRC", "AeroSimRC")); addSimulator(new FGSimulatorCreator("FG", "FlightGear")); addSimulator(new IL2SimulatorCreator("IL2", "IL2")); - addSimulator(new XplaneSimulatorCreator("X-Plane", "X-Plane")); + addSimulator(new XplaneSimulatorCreator9("X-Plane9", "X-Plane9")); + addSimulator(new XplaneSimulatorCreator10("X-Plane10", "X-Plane10")); return true; } From 7f2aeb371b64c2d2199b2ed1e6a7b984d75a3587 Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Mon, 27 Apr 2015 16:10:33 -0400 Subject: [PATCH 32/75] Cosmetic changes to get the X-Plane 10 plugin to compile --- .../openpilotgcs/src/plugins/hitl/plugin.pro | 4 +- .../src/plugins/hitl/xplanesimulator10.cpp | 8 ++-- .../src/plugins/hitl/xplanesimulator9.cpp | 38 +++++++++---------- .../src/plugins/hitl/xplanesimulator9.h | 4 +- 4 files changed, 27 insertions(+), 27 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/hitl/plugin.pro b/ground/openpilotgcs/src/plugins/hitl/plugin.pro index 3eb167d74..3b79330a5 100644 --- a/ground/openpilotgcs/src/plugins/hitl/plugin.pro +++ b/ground/openpilotgcs/src/plugins/hitl/plugin.pro @@ -16,7 +16,7 @@ HEADERS += hitlplugin.h \ aerosimrcsimulator.h \ fgsimulator.h \ il2simulator.h \ - xplanesimulator9.h + xplanesimulator9.h \ xplanesimulator10.h SOURCES += hitlplugin.cpp \ hitlwidget.cpp \ @@ -29,7 +29,7 @@ SOURCES += hitlplugin.cpp \ aerosimrcsimulator.cpp \ fgsimulator.cpp \ il2simulator.cpp \ - xplanesimulator9.cpp + xplanesimulator9.cpp \ xplanesimulator10.cpp OTHER_FILES += hitl.pluginspec FORMS += hitloptionspage.ui \ diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp index 6ca79f4f4..ada7726e1 100644 --- a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp +++ b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator10.cpp @@ -62,7 +62,7 @@ #include #include -void TraceBuf(const char *buf, int len); +void TraceBuf10(const char *buf, int len); XplaneSimulator10::XplaneSimulator10(const SimulatorSettings & params) : Simulator(params) @@ -142,7 +142,7 @@ void XplaneSimulator10::transmitUpdate() buf.append(reinterpret_cast(&none), sizeof(none)); buf.append(reinterpret_cast(&none), sizeof(none)); buf.append(reinterpret_cast(&none), sizeof(none)); -// TraceBuf(buf.data(),41); +// TraceBuf10(buf.data(),41); if (outSocket->writeDatagram(buf, QHostAddress(settings.remoteAddress), settings.outPort) == -1) { emit processOutput("Error sending UDP packet to XPlane: " + outSocket->errorString() + "\n"); @@ -226,7 +226,7 @@ void XplaneSimulator10::processUpdate(const QByteArray & dataBuf) int channelCounter = dataBuf.size() / 36; do { switch (buf[0]) { // switch by id - case XplaneSimulator10::LatitudeLongitudeAltitude: + case XplaneSimulator10::LatitudeLongitude: latitude = *((float *)(buf.data() + 4 * 1)); longitude = *((float *)(buf.data() + 4 * 2)); altitude_msl = *((float *)(buf.data() + 4 * 3)) * FT2M; @@ -337,7 +337,7 @@ void XplaneSimulator10::processUpdate(const QByteArray & dataBuf) } -void TraceBuf(const char *buf, int len) +void TraceBuf10(const char *buf, int len) { QString str; bool reminder = true; diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.cpp b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.cpp index fcc8b492f..78852b306 100644 --- a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.cpp +++ b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.cpp @@ -1,7 +1,7 @@ /** ****************************************************************************** * - * @file xplanesimulator.cpp + * @file xplanesimulator9.cpp * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. * @brief * @see The GNU Public License (GPL) Version 3 @@ -56,25 +56,25 @@ * */ -#include "xplanesimulator.h" +#include "xplanesimulator9.h" #include "extensionsystem/pluginmanager.h" #include #include #include -void TraceBuf(const char *buf, int len); +void TraceBuf9(const char *buf, int len); -XplaneSimulator::XplaneSimulator(const SimulatorSettings & params) : +XplaneSimulator9::XplaneSimulator9(const SimulatorSettings & params) : Simulator(params) { resetInitialHomePosition(); } -XplaneSimulator::~XplaneSimulator() +XplaneSimulator9::~XplaneSimulator9() {} -void XplaneSimulator::setupUdpPorts(const QString & host, int inPort, int outPort) +void XplaneSimulator9::setupUdpPorts(const QString & host, int inPort, int outPort) { Q_UNUSED(outPort); @@ -83,7 +83,7 @@ void XplaneSimulator::setupUdpPorts(const QString & host, int inPort, int outPor resetInitialHomePosition(); } -bool XplaneSimulator::setupProcess() +bool XplaneSimulator9::setupProcess() { emit processOutput(QString("Please start X-Plane manually, and make sure it is setup to output its ") + "data to host " + settings.hostAddress + " UDP port " + QString::number(settings.inPort)); @@ -94,7 +94,7 @@ bool XplaneSimulator::setupProcess() /** * update data in X-Plane simulator */ -void XplaneSimulator::transmitUpdate() +void XplaneSimulator9::transmitUpdate() { if (settings.manualControlEnabled) { // Read ActuatorDesired from autopilot @@ -142,7 +142,7 @@ void XplaneSimulator::transmitUpdate() buf.append(reinterpret_cast(&none), sizeof(none)); buf.append(reinterpret_cast(&none), sizeof(none)); buf.append(reinterpret_cast(&none), sizeof(none)); -// TraceBuf(buf.data(),41); +// TraceBuf9(buf.data(),41); if (outSocket->writeDatagram(buf, QHostAddress(settings.remoteAddress), settings.outPort) == -1) { emit processOutput("Error sending UDP packet to XPlane: " + outSocket->errorString() + "\n"); @@ -186,7 +186,7 @@ void XplaneSimulator::transmitUpdate() /** * process data string from X-Plane simulator */ -void XplaneSimulator::processUpdate(const QByteArray & dataBuf) +void XplaneSimulator9::processUpdate(const QByteArray & dataBuf) { float altitude_msl = 0; float altitude_agl = 0; @@ -226,36 +226,36 @@ void XplaneSimulator::processUpdate(const QByteArray & dataBuf) int channelCounter = dataBuf.size() / 36; do { switch (buf[0]) { // switch by id - case XplaneSimulator::LatitudeLongitudeAltitude: + case XplaneSimulator9::LatitudeLongitudeAltitude: latitude = *((float *)(buf.data() + 4 * 1)); longitude = *((float *)(buf.data() + 4 * 2)); altitude_msl = *((float *)(buf.data() + 4 * 3)) * FT2M; altitude_agl = *((float *)(buf.data() + 4 * 4)) * FT2M; break; - case XplaneSimulator::Speed: + case XplaneSimulator9::Speed: airspeed_keas = *((float *)(buf.data() + 4 * 2)); groundspeed_ktgs = *((float *)(buf.data() + 4 * 4)); break; - case XplaneSimulator::PitchRollHeading: + case XplaneSimulator9::PitchRollHeading: pitch = *((float *)(buf.data() + 4 * 1)); roll = *((float *)(buf.data() + 4 * 2)); heading = *((float *)(buf.data() + 4 * 3)); break; /* - case XplaneSimulator::SystemPressures: + case XplaneSimulator9::SystemPressures: pressure = *((float*)(buf.data()+4*1)); break; */ - case XplaneSimulator::AtmosphereWeather: + case XplaneSimulator9::AtmosphereWeather: pressure = *((float *)(buf.data() + 4 * 1)) * INHG2KPA; temperature = *((float *)(buf.data() + 4 * 2)); break; - case XplaneSimulator::LocVelDistTraveled: + case XplaneSimulator9::LocVelDistTraveled: dstX = *((float *)(buf.data() + 4 * 1)); dstY = -*((float *)(buf.data() + 4 * 3)); dstZ = *((float *)(buf.data() + 4 * 2)); @@ -264,13 +264,13 @@ void XplaneSimulator::processUpdate(const QByteArray & dataBuf) velZ = *((float *)(buf.data() + 4 * 5)); break; - case XplaneSimulator::AngularVelocities: // In [rad/s] + case XplaneSimulator9::AngularVelocities: // In [rad/s] pitchRate_rad = *((float *)(buf.data() + 4 * 1)); rollRate_rad = *((float *)(buf.data() + 4 * 2)); yawRate_rad = *((float *)(buf.data() + 4 * 3)); break; - case XplaneSimulator::Gload: + case XplaneSimulator9::Gload: accX = *((float *)(buf.data() + 4 * 6)) * GEE; accY = *((float *)(buf.data() + 4 * 7)) * GEE; accZ = *((float *)(buf.data() + 4 * 5)) * GEE; @@ -337,7 +337,7 @@ void XplaneSimulator::processUpdate(const QByteArray & dataBuf) } -void TraceBuf(const char *buf, int len) +void TraceBuf9(const char *buf, int len) { QString str; bool reminder = true; diff --git a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h index f785e425b..fa7925e3d 100644 --- a/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h +++ b/ground/openpilotgcs/src/plugins/hitl/xplanesimulator9.h @@ -73,9 +73,9 @@ private: void processUpdate(const QByteArray & data); }; -class XplaneSimulatorCreator : public SimulatorCreator { +class XplaneSimulatorCreator9 : public SimulatorCreator { public: - XplaneSimulatorCreator(const QString & classId, const QString & description) + XplaneSimulatorCreator9(const QString & classId, const QString & description) : SimulatorCreator(classId, description) {} From 48bea16ab97f6bd4231880f019c95c57a5f4afb6 Mon Sep 17 00:00:00 2001 From: Cliff Geerdes Date: Wed, 29 Apr 2015 23:46:47 -0400 Subject: [PATCH 33/75] OP-1840 GPS serial improvements initial coding --- flight/modules/GPS/GPS.c | 336 +++++++---- flight/modules/GPS/UBX.c | 6 +- flight/modules/GPS/inc/UBX.h | 319 +++++++++-- flight/modules/GPS/inc/ubx_autoconfig.h | 209 ++----- flight/modules/GPS/ubx_autoconfig.c | 704 +++++++++++++++++++----- 5 files changed, 1122 insertions(+), 452 deletions(-) diff --git a/flight/modules/GPS/GPS.c b/flight/modules/GPS/GPS.c index 460f6fdc1..a7671e714 100644 --- a/flight/modules/GPS/GPS.c +++ b/flight/modules/GPS/GPS.c @@ -50,6 +50,7 @@ #include "UBX.h" #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) #include "inc/ubx_autoconfig.h" +#include "../../libraries/inc/fifo_buffer.h" #endif #include @@ -60,7 +61,7 @@ PERF_DEFINE_COUNTER(counterParse); // Private functions static void gpsTask(void *parameters); -static void updateHwSettings(); +static void updateHwSettings(UAVObjEvent *ev); #ifdef PIOS_GPS_SETS_HOMELOCATION static void setHomeLocation(GPSPositionSensorData *gpsData); @@ -111,6 +112,8 @@ void updateGpsSettings(UAVObjEvent *ev); // **************** // Private variables +static GPSSettingsData gpsSettings; + static uint32_t gpsPort; static bool gpsEnabled = false; @@ -150,15 +153,15 @@ int32_t GPSStart(void) * \return -1 if initialisation failed * \return 0 on success */ + int32_t GPSInitialize(void) { gpsPort = PIOS_COM_GPS; - uint8_t gpsProtocol; + HwSettingsInitialize(); #ifdef MODULE_GPS_BUILTIN gpsEnabled = true; #else - HwSettingsInitialize(); HwSettingsOptionalModulesData optionalModules; HwSettingsOptionalModulesGet(&optionalModules); @@ -188,7 +191,11 @@ int32_t GPSInitialize(void) AuxMagSettingsUpdatedCb(NULL); AuxMagSettingsConnectCallback(AuxMagSettingsUpdatedCb); #endif - updateHwSettings(); + GPSSettingsInitialize(); + // updateHwSettings() uses gpsSettings + GPSSettingsGet(&gpsSettings); + // must updateHwSettings() before updateGpsSettings() so baud rate is set before GPS serial code starts running + updateHwSettings(0); #else if (gpsPort && gpsEnabled) { GPSPositionSensorInitialize(); @@ -200,27 +207,29 @@ int32_t GPSInitialize(void) #if defined(PIOS_GPS_SETS_HOMELOCATION) HomeLocationInitialize(); #endif - updateHwSettings(); + GPSSettingsInitialize(); + // updateHwSettings() uses gpsSettings + GPSSettingsGet(&gpsSettings); + // must updateHwSettings() before updateGpsSettings() so baud rate is set before GPS serial code starts running + updateHwSettings(0); } #endif /* if defined(REVOLUTION) */ if (gpsPort && gpsEnabled) { - GPSSettingsInitialize(); - GPSSettingsDataProtocolGet(&gpsProtocol); - switch (gpsProtocol) { -#if defined(PIOS_INCLUDE_GPS_NMEA_PARSER) - case GPSSETTINGS_DATAPROTOCOL_NMEA: - gps_rx_buffer = pios_malloc(NMEA_MAX_PACKET_LENGTH); - break; +#if defined(PIOS_INCLUDE_GPS_NMEA_PARSER) && defined(PIOS_INCLUDE_GPS_UBX_PARSER) + gps_rx_buffer = pios_malloc((sizeof(struct UBXPacket) > NMEA_MAX_PACKET_LENGTH) ? sizeof(struct UBXPacket) : NMEA_MAX_PACKET_LENGTH); +#elif defined(PIOS_INCLUDE_GPS_UBX_PARSER) + gps_rx_buffer = pios_malloc(sizeof(struct UBXPacket)); +#elif defined(PIOS_INCLUDE_GPS_NMEA_PARSER) + gps_rx_buffer = pios_malloc(NMEA_MAX_PACKET_LENGTH); +#else + gps_rx_buffer = NULL; #endif - case GPSSETTINGS_DATAPROTOCOL_UBX: - gps_rx_buffer = pios_malloc(sizeof(struct UBXPacket)); - break; - default: - gps_rx_buffer = NULL; - } +#if defined(PIOS_INCLUDE_GPS_NMEA_PARSER) || defined(PIOS_INCLUDE_GPS_UBX_PARSER) PIOS_Assert(gps_rx_buffer); +#endif #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) + HwSettingsConnectCallback(updateHwSettings); // allow changing baud rate even after startup GPSSettingsConnectCallback(updateGpsSettings); #endif return 0; @@ -235,6 +244,27 @@ MODULE_INITCALL(GPSInitialize, GPSStart); /** * Main gps task. It does not return. */ +enum pios_com_dev_magic { + PIOS_COM_DEV_MAGIC = 0xaa55aa55, +}; + +struct pios_com_dev { + enum pios_com_dev_magic magic; + uint32_t lower_id; + const struct pios_com_driver *driver; + +#if defined(PIOS_INCLUDE_FREERTOS) + xSemaphoreHandle tx_sem; + xSemaphoreHandle rx_sem; + xSemaphoreHandle sendbuffer_sem; +#endif + + bool has_rx; + bool has_tx; + + t_fifo_buffer rx; + t_fifo_buffer tx; +}; static void gpsTask(__attribute__((unused)) void *parameters) { @@ -245,15 +275,13 @@ static void gpsTask(__attribute__((unused)) void *parameters) portTickType homelocationSetDelay = 0; #endif GPSPositionSensorData gpspositionsensor; - GPSSettingsData gpsSettings; - - GPSSettingsGet(&gpsSettings); timeOfLastUpdateMs = timeNowMs; timeOfLastCommandMs = timeNowMs; GPSPositionSensorGet(&gpspositionsensor); #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) + // this should be done in the task because it calls out to actually start the GPS serial reads updateGpsSettings(0); #endif @@ -270,9 +298,8 @@ static void gpsTask(__attribute__((unused)) void *parameters) if (gpsSettings.DataProtocol == GPSSETTINGS_DATAPROTOCOL_UBX) { char *buffer = 0; uint16_t count = 0; - uint8_t status; - GPSPositionSensorStatusGet(&status); - ubx_autoconfig_run(&buffer, &count, status != GPSPOSITIONSENSOR_STATUS_NOGPS); + + ubx_autoconfig_run(&buffer, &count); // Something to send? if (count) { // clear ack/nak @@ -284,10 +311,28 @@ static void gpsTask(__attribute__((unused)) void *parameters) PIOS_COM_SendBuffer(gpsPort, (uint8_t *)buffer, count); } } + + // need to do this whether there is received data or not, or the status (e.g. gcs) is not always correct + int32_t ac_status = ubx_autoconfig_get_status(); + static uint8_t lastStatus = GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DISABLED + + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_RUNNING + + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DONE + + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_ERROR; + gpspositionsensor.AutoConfigStatus = + ac_status == UBX_AUTOCONFIG_STATUS_DISABLED ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DISABLED : + ac_status == UBX_AUTOCONFIG_STATUS_DONE ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DONE : + ac_status == UBX_AUTOCONFIG_STATUS_ERROR ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_ERROR : + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_RUNNING; + if (gpspositionsensor.AutoConfigStatus != lastStatus) { + GPSPositionSensorAutoConfigStatusSet(&gpspositionsensor.AutoConfigStatus); + lastStatus = gpspositionsensor.AutoConfigStatus; + } #endif - // This blocks the task until there is something on the buffer + + // This blocks the task until there is something on the buffer (or 100ms? passes) uint16_t cnt; - while ((cnt = PIOS_COM_ReceiveBuffer(gpsPort, c, GPS_READ_BUFFER, xDelay)) > 0) { + cnt = PIOS_COM_ReceiveBuffer(gpsPort, c, GPS_READ_BUFFER, xDelay); + if (cnt > 0) { PERF_TIMED_SECTION_START(counterParse); PERF_TRACK_VALUE(counterBytesIn, cnt); PERF_MEASURE_PERIOD(counterRate); @@ -300,24 +345,8 @@ static void gpsTask(__attribute__((unused)) void *parameters) #endif #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) case GPSSETTINGS_DATAPROTOCOL_UBX: - { -#if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) - int32_t ac_status = ubx_autoconfig_get_status(); - static uint8_t lastStatus = 0; - - gpspositionsensor.AutoConfigStatus = - ac_status == UBX_AUTOCONFIG_STATUS_DISABLED ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DISABLED : - ac_status == UBX_AUTOCONFIG_STATUS_DONE ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DONE : - ac_status == UBX_AUTOCONFIG_STATUS_ERROR ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_ERROR : - GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_RUNNING; - if (gpspositionsensor.AutoConfigStatus != lastStatus) { - GPSPositionSensorAutoConfigStatusSet(&gpspositionsensor.AutoConfigStatus); - lastStatus = gpspositionsensor.AutoConfigStatus; - } -#endif res = parse_ubx_stream(c, cnt, gps_rx_buffer, &gpspositionsensor, &gpsRxStats); - } - break; + break; #endif default: res = NO_PARSER; // this should not happen @@ -435,40 +464,139 @@ static void setHomeLocation(GPSPositionSensorData *gpsData) * like protocol, etc. Thus the HwSettings object which contains the * GPS port speed is used for now. */ -static void updateHwSettings() -{ - if (gpsPort) { - // Retrieve settings - uint8_t speed; - HwSettingsGPSSpeedGet(&speed); - // Set port speed - switch (speed) { - case HWSETTINGS_GPSSPEED_2400: - PIOS_COM_ChangeBaud(gpsPort, 2400); - break; - case HWSETTINGS_GPSSPEED_4800: - PIOS_COM_ChangeBaud(gpsPort, 4800); - break; - case HWSETTINGS_GPSSPEED_9600: - PIOS_COM_ChangeBaud(gpsPort, 9600); - break; - case HWSETTINGS_GPSSPEED_19200: - PIOS_COM_ChangeBaud(gpsPort, 19200); - break; - case HWSETTINGS_GPSSPEED_38400: - PIOS_COM_ChangeBaud(gpsPort, 38400); - break; - case HWSETTINGS_GPSSPEED_57600: - PIOS_COM_ChangeBaud(gpsPort, 57600); - break; - case HWSETTINGS_GPSSPEED_115200: - PIOS_COM_ChangeBaud(gpsPort, 115200); - break; - case HWSETTINGS_GPSSPEED_230400: - PIOS_COM_ChangeBaud(gpsPort, 230400); - break; +// must updateHwSettings() before updateGpsSettings() so baud rate is set before GPS serial code starts running +static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) +{ + // with these changes, no one (not even OP board makers) should ever need u-center (the complex UBlox configuration program) + // no booting of Revo should be required during any setup or testing, just Send the settings you want to play with + // with autoconfig enabled, just change the baud rate in HwSettings and it will change the GPS internal baud and then the Revo port + // with autoconfig disabled, it will only change the Revo port, so you can try to find the current GPS baud rate if you don't know it + + // Use cases: + // - the user can plug in a default GPS, use autoconfig-store once and then always use autoconfig-disabled + // - the user can plug in a default GPS that can't store settings (defaults to 9600 baud) and always use autoconfig-nostore + // - - this is my main reason for coding this: cheap eBay GPS's that loose their settings sometimes + // - the user can plug in a default GPS that _can_ store settings and always use autoconfig-nostore with that too + // - - if settings change in newer releases of OP, this will make sure to use the correct settings with whatever code you are running + // - the user can plug in a correctly configured GPS and use autoconfig-disabled + // - the user can recover an old or incorrectly configured GPS (internal GPS baud rate or other GPS settings wrong) + // - - disable UBX GPS autoconfig + // - - set HwSettings GPS baud rate to the current GPS internal baud rate to get it to connect at current (especially non-9600) baud rate + // - - - you can tell the baud rate is correct when GPSPositionSensor.SensorType is known (not "Unknown") (e.g. UBX6) + // - - - the SensorType and AutoConfigStatus may fail at 9600 and will fail at 4800 or lower if the GPS is configured to send OP data + // - - - (way more than default) at 4800 baud or slower + // - - enable autoconfig-nostore GPSSettings to set correct messages and enable further magic baud rate settings + // - - change the baud rate to what you want in HwSettings (it will change the baud rate in the GPS and then in the Revo port) + // - - wait for the baud rate change to complete, GPSPositionSensor.AutoConfigStatus will say "DONE" + // - - enable autoconfig-store and it will save the new baud rate and the correct message configuration + // - - wait for the store to complete, GPSPositionSensor.AutoConfigStatus will say "DONE" + // - - for the new baud rate, the user should either choose 9600 for use with autoconfig-nostore or can choose 57600 for use with autoconfig-disabled + // - the user (Dave :)) can configure a whole bunch of default GPS's with no intervention by using autoconfig-store as a saved Revo setting + // - - just plug the default (9600 baud) GPS in to an unpowered Revo, power the Revo/GPS through the servo connector, wait some time, unplug + // - - or with this code, OP could and even should just ship GPS's with default settings + + // if we add an "initial baud rate" instead of assuming 9600 for autoconfig-nostore/store + // - the user can use the same GPS with both an older release of OP (e.g. GPS settings at 38400) and the current release (autoconfig-nostore) + // - should the 57600 be fixed as part of autoconfig-store/nostore and the HwSettings.GPSSpeed be the initial baud rate? + + // About using UBlox GPS's with default settings (9600 baud and NEMA data): + // - the default uBlox settings (different than OP settings) are NEMA and 9600 baud + // - - and that is OK and you use autoconfig-nostore + // - - I personally feel that this is the best way to set it up because if OP dev changes GPS settings, + // - - you get them automatically changed to match whatever version of OP code you are running + // - - but 9600 is only OK for startup and only if you NEVER enable and store (even once) OP messages (a lot more data) at 9600 + // - - using autoconfig-store just one time at 9600 will pretty much force you to use 57600 + // - by my testing, the 9600 initial to 57600 final baud startup takes: + // - - 1:13 if the GPS has been configured to send OP data at 9600 + // - - 0:12 if the GPS has default data settings (NEMA) + // - - reminder that even 1:13 isn't that bad. You need to wait for the GPS to acquire satellites, + // - - and it does that the whole time it is being configured + + // Some things you want to know if you want to play around with this: + // - 57600 baud is what you want stored inside the GPS settings if you autoconfig-store it even once at any baud rate + // - - then use autoconfig-disabled once the GPS settings are stored in the GPS + // - don't play with low baud rates, with OP data settings (lots of data) at best it takes a long time to auto-configure + // - - at 19200 or lower it will fail to autoconfig and set the status to 'ERROR' + // - - at 19200 or lower the autoconfig is skipped and only the baud rate is changed + // - if you autoconfigure-store an OP configuration at 19200 baud or lower + // - - it will actually store a factory default configuration at that baud rate + // - - you will probably have to use u-center to fix it + // - - default settings (NEMA) at 9600 are OK because there is not nearly as much data as the OP config uses, + // - remember that there are two baud rates (inside the GPS and the Revo port) and you can get them out of sync + // - - rebooting the Revo from the Ground Control Station (without powering the GPS down too) + // - - can leave the baud rates out of sync if you are using autoconfig-nostore + // - - just power off and on both the Revo and the GPS + + // my OP GPS #2 will NOT save 115200 baud or higher, but it will use all bauds, even 230400 + + // since 9600 baud and lower are not usable, and are best left at NEMA, I could / should / will code it to do a factory reset + // - if set to 9600 baud (or lower???) + + if (gpsPort) { + // static uint8_t old_speed = HWSETTINGS_GPSSPEED_230400+1; + uint8_t speed; + +#if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) + // use 9600 baud during startup if autoconfig is enabled + // that is the flag that the code should assumes a factory default baud rate + if (ev == NULL && gpsSettings.UbxAutoConfig != GPSSETTINGS_UBXAUTOCONFIG_DISABLED) { + speed = HWSETTINGS_GPSSPEED_9600; } + else +#endif + { + // Retrieve settings + HwSettingsGPSSpeedGet(&speed); + } + + // must always set the baud here, even if it looks like it is the same + // e.g. startup sets 9600 here, ubx_autoconfig sets 57600 there, then the user selects a change back to 9600 here + + // on startup (ev == NULL) we must set the Revo port baud rate + // after startup (ev != NULL) we must set the Revo port baud rate only if autoconfig is disabled + // always we must set the Revo port baud rate if not using UBX +#if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) + if (ev == NULL || gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED || gpsSettings.DataProtocol != GPSSETTINGS_DATAPROTOCOL_UBX) +#endif + { + // Set Revo port speed + switch (speed) { + case HWSETTINGS_GPSSPEED_2400: + PIOS_COM_ChangeBaud(gpsPort, 2400); + break; + case HWSETTINGS_GPSSPEED_4800: + PIOS_COM_ChangeBaud(gpsPort, 4800); + break; + case HWSETTINGS_GPSSPEED_9600: + PIOS_COM_ChangeBaud(gpsPort, 9600); + break; + case HWSETTINGS_GPSSPEED_19200: + PIOS_COM_ChangeBaud(gpsPort, 19200); + break; + case HWSETTINGS_GPSSPEED_38400: + PIOS_COM_ChangeBaud(gpsPort, 38400); + break; + case HWSETTINGS_GPSSPEED_57600: + PIOS_COM_ChangeBaud(gpsPort, 57600); + break; + case HWSETTINGS_GPSSPEED_115200: + PIOS_COM_ChangeBaud(gpsPort, 115200); + break; + case HWSETTINGS_GPSSPEED_230400: + PIOS_COM_ChangeBaud(gpsPort, 230400); + break; + } + // even changing the baud rate will make it re-verify the sensor type + // that way the user can just try some baud rates and it when the sensor type is valid, the baud rate is correct + ubx_reset_sensor_type(); + } +#if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) + else { + // it will never do this during startup because ev == NULL + ubx_autoconfig_set(NULL); + } +#endif } } @@ -480,32 +608,26 @@ void AuxMagSettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) void updateGpsSettings(__attribute__((unused)) UAVObjEvent *ev) { - uint8_t ubxAutoConfig; - uint8_t ubxDynamicModel; - uint8_t ubxSbasMode; ubx_autoconfig_settings_t newconfig; - uint8_t ubxSbasSats; - uint8_t ubxGnssMode; - GPSSettingsUbxRateGet(&newconfig.navRate); + GPSSettingsGet(&gpsSettings); - GPSSettingsUbxAutoConfigGet(&ubxAutoConfig); - newconfig.autoconfigEnabled = ubxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED ? false : true; - newconfig.storeSettings = ubxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_CONFIGUREANDSTORE; + newconfig.navRate = gpsSettings.UbxRate; - GPSSettingsUbxDynamicModelGet(&ubxDynamicModel); - newconfig.dynamicModel = ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_PORTABLE ? UBX_DYNMODEL_PORTABLE : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_STATIONARY ? UBX_DYNMODEL_STATIONARY : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_PEDESTRIAN ? UBX_DYNMODEL_PEDESTRIAN : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AUTOMOTIVE ? UBX_DYNMODEL_AUTOMOTIVE : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_SEA ? UBX_DYNMODEL_SEA : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AIRBORNE1G ? UBX_DYNMODEL_AIRBORNE1G : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AIRBORNE2G ? UBX_DYNMODEL_AIRBORNE2G : - ubxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AIRBORNE4G ? UBX_DYNMODEL_AIRBORNE4G : + newconfig.autoconfigEnabled = gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED ? false : true; + newconfig.storeSettings = gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_CONFIGUREANDSTORE; + + newconfig.dynamicModel = gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_PORTABLE ? UBX_DYNMODEL_PORTABLE : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_STATIONARY ? UBX_DYNMODEL_STATIONARY : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_PEDESTRIAN ? UBX_DYNMODEL_PEDESTRIAN : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AUTOMOTIVE ? UBX_DYNMODEL_AUTOMOTIVE : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_SEA ? UBX_DYNMODEL_SEA : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AIRBORNE1G ? UBX_DYNMODEL_AIRBORNE1G : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AIRBORNE2G ? UBX_DYNMODEL_AIRBORNE2G : + gpsSettings.UbxDynamicModel == GPSSETTINGS_UBXDYNAMICMODEL_AIRBORNE4G ? UBX_DYNMODEL_AIRBORNE4G : UBX_DYNMODEL_AIRBORNE1G; - GPSSettingsUbxSBASModeGet(&ubxSbasMode); - switch ((GPSSettingsUbxSBASModeOptions)ubxSbasMode) { + switch ((GPSSettingsUbxSBASModeOptions)gpsSettings.UbxSBASMode) { case GPSSETTINGS_UBXSBASMODE_RANGINGCORRECTION: case GPSSETTINGS_UBXSBASMODE_CORRECTION: case GPSSETTINGS_UBXSBASMODE_RANGINGCORRECTIONINTEGRITY: @@ -516,7 +638,7 @@ void updateGpsSettings(__attribute__((unused)) UAVObjEvent *ev) newconfig.SBASCorrection = false; } - switch ((GPSSettingsUbxSBASModeOptions)ubxSbasMode) { + switch ((GPSSettingsUbxSBASModeOptions)gpsSettings.UbxSBASMode) { case GPSSETTINGS_UBXSBASMODE_RANGING: case GPSSETTINGS_UBXSBASMODE_RANGINGCORRECTION: case GPSSETTINGS_UBXSBASMODE_RANGINGINTEGRITY: @@ -527,7 +649,7 @@ void updateGpsSettings(__attribute__((unused)) UAVObjEvent *ev) newconfig.SBASRanging = false; } - switch ((GPSSettingsUbxSBASModeOptions)ubxSbasMode) { + switch ((GPSSettingsUbxSBASModeOptions)gpsSettings.UbxSBASMode) { case GPSSETTINGS_UBXSBASMODE_INTEGRITY: case GPSSETTINGS_UBXSBASMODE_RANGINGINTEGRITY: case GPSSETTINGS_UBXSBASMODE_RANGINGCORRECTIONINTEGRITY: @@ -538,19 +660,15 @@ void updateGpsSettings(__attribute__((unused)) UAVObjEvent *ev) newconfig.SBASIntegrity = false; } - GPSSettingsUbxSBASChannelsUsedGet(&newconfig.SBASChannelsUsed); + newconfig.SBASChannelsUsed = gpsSettings.UbxSBASChannelsUsed; - GPSSettingsUbxSBASSatsGet(&ubxSbasSats); + newconfig.SBASSats = gpsSettings.UbxSBASSats == GPSSETTINGS_UBXSBASSATS_WAAS ? UBX_SBAS_SATS_WAAS : + gpsSettings.UbxSBASSats == GPSSETTINGS_UBXSBASSATS_EGNOS ? UBX_SBAS_SATS_EGNOS : + gpsSettings.UbxSBASSats == GPSSETTINGS_UBXSBASSATS_MSAS ? UBX_SBAS_SATS_MSAS : + gpsSettings.UbxSBASSats == GPSSETTINGS_UBXSBASSATS_GAGAN ? UBX_SBAS_SATS_GAGAN : + gpsSettings.UbxSBASSats == GPSSETTINGS_UBXSBASSATS_SDCM ? UBX_SBAS_SATS_SDCM : UBX_SBAS_SATS_AUTOSCAN; - newconfig.SBASSats = ubxSbasSats == GPSSETTINGS_UBXSBASSATS_WAAS ? UBX_SBAS_SATS_WAAS : - ubxSbasSats == GPSSETTINGS_UBXSBASSATS_EGNOS ? UBX_SBAS_SATS_EGNOS : - ubxSbasSats == GPSSETTINGS_UBXSBASSATS_MSAS ? UBX_SBAS_SATS_MSAS : - ubxSbasSats == GPSSETTINGS_UBXSBASSATS_GAGAN ? UBX_SBAS_SATS_GAGAN : - ubxSbasSats == GPSSETTINGS_UBXSBASSATS_SDCM ? UBX_SBAS_SATS_SDCM : UBX_SBAS_SATS_AUTOSCAN; - - GPSSettingsUbxGNSSModeGet(&ubxGnssMode); - - switch (ubxGnssMode) { + switch (gpsSettings.UbxGNSSMode) { case GPSSETTINGS_UBXGNSSMODE_GPSGLONASS: newconfig.enableGPS = true; newconfig.enableGLONASS = true; @@ -583,7 +701,7 @@ void updateGpsSettings(__attribute__((unused)) UAVObjEvent *ev) break; } - ubx_autoconfig_set(newconfig); + ubx_autoconfig_set(&newconfig); } #endif /* if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) */ /** diff --git a/flight/modules/GPS/UBX.c b/flight/modules/GPS/UBX.c index a75efd28a..74ebc78e8 100644 --- a/flight/modules/GPS/UBX.c +++ b/flight/modules/GPS/UBX.c @@ -43,7 +43,7 @@ static bool useMag = false; #endif -static GPSPositionSensorSensorTypeOptions sensorType = GPSPOSITIONSENSOR_SENSORTYPE_UNKNOWN; +GPSPositionSensorSensorTypeOptions sensorType = GPSPOSITIONSENSOR_SENSORTYPE_UNKNOWN; static bool usePvt = false; static uint32_t lastPvtTime = 0; @@ -466,9 +466,11 @@ static void parse_ubx_mon_ver(struct UBXPacket *ubx, __attribute__((unused)) GPS struct UBX_MON_VER *mon_ver = &ubx->payload.mon_ver; ubxHwVersion = atoi(mon_ver->hwVersion); - sensorType = (ubxHwVersion >= 80000) ? GPSPOSITIONSENSOR_SENSORTYPE_UBX8 : ((ubxHwVersion >= 70000) ? GPSPOSITIONSENSOR_SENSORTYPE_UBX7 : GPSPOSITIONSENSOR_SENSORTYPE_UBX); + // send sensor type right now because on UBX NEMA we don't get a full set of messages + // and we want to be able to see sensor type even on UBX NEMA GPS's + GPSPositionSensorSensorTypeSet((uint8_t *) &sensorType); } static void parse_ubx_op_sys(struct UBXPacket *ubx, __attribute__((unused)) GPSPositionSensorData *GpsPosition) diff --git a/flight/modules/GPS/inc/UBX.h b/flight/modules/GPS/inc/UBX.h index a7e938f46..51c8552fa 100644 --- a/flight/modules/GPS/inc/UBX.h +++ b/flight/modules/GPS/inc/UBX.h @@ -102,7 +102,8 @@ typedef enum { UBX_ID_CFG_MSG = 0x01, UBX_ID_CFG_CFG = 0x09, UBX_ID_CFG_SBAS = 0x16, - UBX_ID_CFG_GNSS = 0x3E + UBX_ID_CFG_GNSS = 0x3E, + UBX_ID_CFG_PRT = 0x00 } ubx_class_cfg_id; typedef enum { @@ -129,6 +130,39 @@ typedef enum { UBX_ID_RXM_SFRB = 0x11, UBX_ID_RXM_SVSI = 0x20, } ubx_class_rxm_id; + +typedef enum { + UBX_GNSS_ID_GPS = 0, + UBX_GNSS_ID_SBAS = 1, + UBX_GNSS_ID_GALILEO = 2, + UBX_GNSS_ID_BEIDOU = 3, + UBX_GNSS_ID_IMES = 4, + UBX_GNSS_ID_QZSS = 5, + UBX_GNSS_ID_GLONASS = 6, + UBX_GNSS_ID_MAX +} ubx_config_gnss_id_t; + +// Enumeration options for field UBXDynamicModel +typedef enum { + UBX_DYNMODEL_PORTABLE = 0, + UBX_DYNMODEL_STATIONARY = 2, + UBX_DYNMODEL_PEDESTRIAN = 3, + UBX_DYNMODEL_AUTOMOTIVE = 4, + UBX_DYNMODEL_SEA = 5, + UBX_DYNMODEL_AIRBORNE1G = 6, + UBX_DYNMODEL_AIRBORNE2G = 7, + UBX_DYNMODEL_AIRBORNE4G = 8 +} ubx_config_dynamicmodel_t; + +typedef enum { + UBX_SBAS_SATS_AUTOSCAN = 0, + UBX_SBAS_SATS_WAAS = 1, + UBX_SBAS_SATS_EGNOS = 2, + UBX_SBAS_SATS_MSAS = 3, + UBX_SBAS_SATS_GAGAN = 4, + UBX_SBAS_SATS_SDCM = 5 +} ubx_config_sats_t; + // private structures // Geodetic Position Solution @@ -140,10 +174,9 @@ struct UBX_NAV_POSLLH { int32_t hMSL; // Height above mean sea level (mm) uint32_t hAcc; // Horizontal Accuracy Estimate (mm) uint32_t vAcc; // Vertical Accuracy Estimate (mm) -}; +} __attribute__((packed)); // Receiver Navigation Status - #define STATUS_GPSFIX_NOFIX 0x00 #define STATUS_GPSFIX_DRONLY 0x01 #define STATUS_GPSFIX_2DFIX 0x02 @@ -164,7 +197,7 @@ struct UBX_NAV_STATUS { uint8_t flags2; // Additional navigation output information uint32_t ttff; // Time to first fix (ms) uint32_t msss; // Milliseconds since startup/reset (ms) -}; +} __attribute__((packed)); // Dilution of precision struct UBX_NAV_DOP { @@ -176,10 +209,9 @@ struct UBX_NAV_DOP { uint16_t hDOP; // Horizontal DOP uint16_t nDOP; // Northing DOP uint16_t eDOP; // Easting DOP -}; +} __attribute__((packed)); // Navigation solution - struct UBX_NAV_SOL { uint32_t iTOW; // GPS Millisecond Time of Week (ms) int32_t fTOW; // fractional nanoseconds (ns) @@ -198,41 +230,9 @@ struct UBX_NAV_SOL { uint8_t reserved1; // Reserved uint8_t numSV; // Number of SVs used in Nav Solution uint32_t reserved2; // Reserved -}; - -// North/East/Down velocity - -struct UBX_NAV_VELNED { - uint32_t iTOW; // ms GPS Millisecond Time of Week - int32_t velN; // cm/s NED north velocity - int32_t velE; // cm/s NED east velocity - int32_t velD; // cm/s NED down velocity - uint32_t speed; // cm/s Speed (3-D) - uint32_t gSpeed; // cm/s Ground Speed (2-D) - int32_t heading; // 1e-5 *deg Heading of motion 2-D - uint32_t sAcc; // cm/s Speed Accuracy Estimate - uint32_t cAcc; // 1e-5 *deg Course / Heading Accuracy Estimate -}; - -// UTC Time Solution - -#define TIMEUTC_VALIDTOW (1 << 0) -#define TIMEUTC_VALIDWKN (1 << 1) -#define TIMEUTC_VALIDUTC (1 << 2) - -struct UBX_NAV_TIMEUTC { - uint32_t iTOW; // GPS Millisecond Time of Week (ms) - uint32_t tAcc; // Time Accuracy Estimate (ns) - int32_t nano; // Nanoseconds of second - uint16_t year; - uint8_t month; - uint8_t day; - uint8_t hour; - uint8_t min; - uint8_t sec; - uint8_t valid; // Validity Flags -}; +} __attribute__((packed)); +// PVT Navigation Position Velocity Time Solution #define PVT_VALID_VALIDDATE 0x01 #define PVT_VALID_VALIDTIME 0x02 #define PVT_VALID_FULLYRESOLVED 0x04 @@ -252,7 +252,6 @@ struct UBX_NAV_TIMEUTC { #define PVT_FLAGS_PSMSTATE_PO_TRACKING (4 << 2) #define PVT_FLAGS_PSMSTATE_INACTIVE (5 << 2) -// PVT Navigation Position Velocity Time Solution struct UBX_NAV_PVT { uint32_t iTOW; uint16_t year; @@ -286,10 +285,39 @@ struct UBX_NAV_PVT { uint32_t reserved3; } __attribute__((packed)); +// North/East/Down velocity +struct UBX_NAV_VELNED { + uint32_t iTOW; // ms GPS Millisecond Time of Week + int32_t velN; // cm/s NED north velocity + int32_t velE; // cm/s NED east velocity + int32_t velD; // cm/s NED down velocity + uint32_t speed; // cm/s Speed (3-D) + uint32_t gSpeed; // cm/s Ground Speed (2-D) + int32_t heading; // 1e-5 *deg Heading of motion 2-D + uint32_t sAcc; // cm/s Speed Accuracy Estimate + uint32_t cAcc; // 1e-5 *deg Course / Heading Accuracy Estimate +} __attribute__((packed)); + +// UTC Time Solution +#define TIMEUTC_VALIDTOW (1 << 0) +#define TIMEUTC_VALIDWKN (1 << 1) +#define TIMEUTC_VALIDUTC (1 << 2) + +struct UBX_NAV_TIMEUTC { + uint32_t iTOW; // GPS Millisecond Time of Week (ms) + uint32_t tAcc; // Time Accuracy Estimate (ns) + int32_t nano; // Nanoseconds of second + uint16_t year; + uint8_t month; + uint8_t day; + uint8_t hour; + uint8_t min; + uint8_t sec; + uint8_t valid; // Validity Flags +} __attribute__((packed)); + // Space Vehicle (SV) Information - // Single SV information block - #define SVUSED (1 << 0) // This SV is used for navigation #define DIFFCORR (1 << 1) // Differential correction available #define ORBITAVAIL (1 << 2) // Orbit information available @@ -308,7 +336,7 @@ struct UBX_NAV_SVINFO_SV { int8_t elev; // Elevation (integer degrees) int16_t azim; // Azimuth (integer degrees) int32_t prRes; // Pseudo range residual (cm) -}; +} __attribute__((packed)); // SV information message #define MAX_SVS 32 @@ -319,19 +347,179 @@ struct UBX_NAV_SVINFO { uint8_t globalFlags; // uint16_t reserved2; // Reserved struct UBX_NAV_SVINFO_SV sv[MAX_SVS]; // Repeated 'numCh' times -}; +} __attribute__((packed)); // ACK message class - struct UBX_ACK_ACK { uint8_t clsID; // ClassID uint8_t msgID; // MessageID -}; +} __attribute__((packed)); struct UBX_ACK_NAK { uint8_t clsID; // ClassID uint8_t msgID; // MessageID -}; +} __attribute__((packed)); + +// Communication port information +// default cfg_prt packet at 9600,N,8,1 (from u-center) +// 0000 B5 62 06 00 14 00-01 00 +// 0008 00 00 D0 08 00 00 80 25 +// 0010 00 00 07 00 03 00 00 00 +// 0018 00 00-A2 B5 +#define UBX_CFG_PRT_PORTID_DDC 0 +#define UBX_CFG_PRT_PORTID_UART1 1 +#define UBX_CFG_PRT_PORTID_UART2 2 +#define UBX_CFG_PRT_PORTID_USB 3 +#define UBX_CFG_PRT_PORTID_SPI 4 +#define UBX_CFG_PRT_MODE_DATABITS5 0x00 +#define UBX_CFG_PRT_MODE_DATABITS6 0x40 +#define UBX_CFG_PRT_MODE_DATABITS7 0x80 +#define UBX_CFG_PRT_MODE_DATABITS8 0xC0 +#define UBX_CFG_PRT_MODE_EVENPARITY 0x000 +#define UBX_CFG_PRT_MODE_ODDPARITY 0x200 +#define UBX_CFG_PRT_MODE_NOPARITY 0x800 +#define UBX_CFG_PRT_MODE_STOPBITS1_0 0x0000 +#define UBX_CFG_PRT_MODE_STOPBITS1_5 0x1000 +#define UBX_CFG_PRT_MODE_STOPBITS2_0 0x2000 +#define UBX_CFG_PRT_MODE_STOPBITS0_5 0x3000 +#define UBX_CFG_PRT_MODE_RESERVED 0x10 + +#define UBX_CFG_PRT_MODE_DEFAULT (UBX_CFG_PRT_MODE_DATABITS8 | UBX_CFG_PRT_MODE_NOPARITY | UBX_CFG_PRT_MODE_STOPBITS1_0 | UBX_CFG_PRT_MODE_RESERVED) + +struct UBX_CFG_PRT { + uint8_t portID; // 1 or 2 for UART ports + uint8_t res0; // reserved + uint16_t res1; // reserved + uint32_t mode; // bit masks for databits, stopbits, parity, and non-zero reserved + uint32_t baudRate; // bits per second, 9600 means 9600 + uint16_t inProtoMask; // bit 0 on = UBX, bit 1 on = NEMA + uint16_t outProtoMask; // bit 0 on = UBX, bit 1 on = NEMA + uint16_t flags; // reserved + uint16_t pad; // reserved +} __attribute__((packed)); + +struct UBX_CFG_MSG { + uint8_t msgClass; + uint8_t msgID; + uint8_t rate; +} __attribute__((packed)); + +struct UBX_CFG_RATE { + uint16_t measRate; + uint16_t navRate; + uint16_t timeRef; +} __attribute__((packed)); + +// Mask for "all supported devices": battery backed RAM, Flash, EEPROM, SPI Flash +#define UBX_CFG_CFG_DEVICE_BBR 0x01 +#define UBX_CFG_CFG_DEVICE_FLASH 0x02 +#define UBX_CFG_CFG_DEVICE_EEPROM 0x04 +#define UBX_CFG_CFG_DEVICE_SPIFLASH 0x10 +#define UBX_CFG_CFG_DEVICE_ALL (UBX_CFG_CFG_DEVICE_BBR | UBX_CFG_CFG_DEVICE_FLASH | UBX_CFG_CFG_DEVICE_EEPROM | UBX_CFG_CFG_DEVICE_SPIFLASH) +#define UBX_CFG_CFG_SETTINGS_NONE 0x000 +#define UBX_CFG_CFG_SETTINGS_IOPORT 0x001 +#define UBX_CFG_CFG_SETTINGS_MSGCONF 0x002 +#define UBX_CFG_CFG_SETTINGS_INFMSG 0x004 +#define UBX_CFG_CFG_SETTINGS_NAVCONF 0x008 +#define UBX_CFG_CFG_SETTINGS_TPCONF 0x010 +#define UBX_CFG_CFG_SETTINGS_SFDRCONF 0x100 +#define UBX_CFG_CFG_SETTINGS_RINVCONF 0x200 +#define UBX_CFG_CFG_SETTINGS_ANTCONF 0x400 + +#define UBX_CFG_CFG_SETTINGS_ALL (UBX_CFG_CFG_SETTINGS_IOPORT | \ + UBX_CFG_CFG_SETTINGS_MSGCONF | \ + UBX_CFG_CFG_SETTINGS_INFMSG | \ + UBX_CFG_CFG_SETTINGS_NAVCONF | \ + UBX_CFG_CFG_SETTINGS_TPCONF | \ + UBX_CFG_CFG_SETTINGS_SFDRCONF | \ + UBX_CFG_CFG_SETTINGS_RINVCONF | \ + UBX_CFG_CFG_SETTINGS_ANTCONF) + +// Sent messages for configuration support +struct UBX_CFG_CFG { + uint32_t clearMask; + uint32_t saveMask; + uint32_t loadMask; + uint8_t deviceMask; +} __attribute__((packed)); + +#define UBX_CFG_SBAS_MODE_ENABLED 0x01 +#define UBX_CFG_SBAS_MODE_TEST 0x02 +#define UBX_CFG_SBAS_USAGE_RANGE 0x01 +#define UBX_CFG_SBAS_USAGE_DIFFCORR 0x02 +#define UBX_CFG_SBAS_USAGE_INTEGRITY 0x04 + +// SBAS used satellite PNR bitmask (120-151) +// -------------------------------------1---------1---------1---------1 +// -------------------------------------5---------4---------3---------2 +// ------------------------------------10987654321098765432109876543210 +// WAAS 122, 133, 134, 135, 138---------|---------|---------|---------| +#define UBX_CFG_SBAS_SCANMODE1_WAAS 0b00000000000001001110000000000100 +// EGNOS 120, 124, 126, 131-------------|---------|---------|---------| +#define UBX_CFG_SBAS_SCANMODE1_EGNOS 0b00000000000000000000100001010001 +// MSAS 129, 137------------------------|---------|---------|---------| +#define UBX_CFG_SBAS_SCANMODE1_MSAS 0b00000000000000100000001000000000 +// GAGAN 127, 128-----------------------|---------|---------|---------| +#define UBX_CFG_SBAS_SCANMODE1_GAGAN 0b00000000000000000000000110000000 +// SDCM 125, 140, 141-------------------|---------|---------|---------| +#define UBX_CFG_SBAS_SCANMODE1_SDCM 0b00000000001100000000000000100000 + +#define UBX_CFG_SBAS_SCANMODE2 0x00 +struct UBX_CFG_SBAS { + uint8_t mode; + uint8_t usage; + uint8_t maxSBAS; + uint8_t scanmode2; + uint32_t scanmode1; +} __attribute__((packed)); + +#define UBX_CFG_GNSS_FLAGS_ENABLED 0x000001 +#define UBX_CFG_GNSS_FLAGS_GPS_L1CA 0x010000 +#define UBX_CFG_GNSS_FLAGS_SBAS_L1CA 0x010000 +#define UBX_CFG_GNSS_FLAGS_BEIDOU_B1I 0x010000 +#define UBX_CFG_GNSS_FLAGS_QZSS_L1CA 0x010000 +#define UBX_CFG_GNSS_FLAGS_QZSS_L1SAIF 0x040000 +#define UBX_CFG_GNSS_FLAGS_GLONASS_L1OF 0x010000 + +#define UBX_CFG_GNSS_NUMCH_VER7 22 +#define UBX_CFG_GNSS_NUMCH_VER8 32 + +struct UBX_CFG_GNSS_CFGBLOCK { + uint8_t gnssId; + uint8_t resTrkCh; + uint8_t maxTrkCh; + uint8_t resvd; + uint32_t flags; +} __attribute__((packed)); + +struct UBX_CFG_GNSS { + uint8_t msgVer; + uint8_t numTrkChHw; + uint8_t numTrkChUse; + uint8_t numConfigBlocks; + struct UBX_CFG_GNSS_CFGBLOCK cfgBlocks[UBX_GNSS_ID_MAX]; +} __attribute__((packed)); + +struct UBX_CFG_NAV5 { + uint16_t mask; + uint8_t dynModel; + uint8_t fixMode; + int32_t fixedAlt; + uint32_t fixedAltVar; + int8_t minElev; + uint8_t drLimit; + uint16_t pDop; + uint16_t tDop; + uint16_t pAcc; + uint16_t tAcc; + uint8_t staticHoldThresh; + uint8_t dgpsTimeOut; + uint8_t cnoThreshNumSVs; + uint8_t cnoThresh; + uint16_t reserved2; + uint32_t reserved3; + uint32_t reserved4; +} __attribute__((packed)); // MON message Class #define UBX_MON_MAX_EXT 5 @@ -341,8 +529,7 @@ struct UBX_MON_VER { #if UBX_MON_MAX_EXT > 0 char extension[UBX_MON_MAX_EXT][30]; #endif -}; - +} __attribute__((packed)); // OP custom messages struct UBX_OP_SYSINFO { @@ -360,7 +547,7 @@ struct UBX_OP_MAG { int16_t y; int16_t z; uint16_t Status; -}; +} __attribute__((packed)); typedef union { uint8_t payload[0]; @@ -374,6 +561,7 @@ typedef union { struct UBX_NAV_PVT nav_pvt; struct UBX_NAV_TIMEUTC nav_timeutc; struct UBX_NAV_SVINFO nav_svinfo; + struct UBX_CFG_PRT cfg_prt; // Ack Class struct UBX_ACK_ACK ack_ack; struct UBX_ACK_NAK ack_nak; @@ -390,15 +578,40 @@ struct UBXHeader { uint16_t len; uint8_t ck_a; uint8_t ck_b; -}; +} __attribute__((packed)); struct UBXPacket { struct UBXHeader header; UBXPayload payload; -}; +} __attribute__((packed)); + +struct UBXSENTHEADER { + uint8_t prolog[2]; + uint8_t class; + uint8_t id; + uint16_t len; +} __attribute__((packed)); + +union UBXSENTPACKET { + uint8_t buffer[0]; + struct { + struct UBXSENTHEADER header; + union { + struct UBX_CFG_CFG cfg_cfg; + struct UBX_CFG_MSG cfg_msg; + struct UBX_CFG_NAV5 cfg_nav5; + struct UBX_CFG_PRT cfg_prt; + struct UBX_CFG_RATE cfg_rate; + struct UBX_CFG_SBAS cfg_sbas; + struct UBX_CFG_GNSS cfg_gnss; + } payload; + uint8_t resvd[2]; // added space for checksum bytes + } message; +} __attribute__((packed)); // Used by AutoConfig code extern int32_t ubxHwVersion; +extern GPSPositionSensorSensorTypeOptions sensorType; extern struct UBX_ACK_ACK ubxLastAck; extern struct UBX_ACK_NAK ubxLastNak; diff --git a/flight/modules/GPS/inc/ubx_autoconfig.h b/flight/modules/GPS/inc/ubx_autoconfig.h index 0dcb13397..343b755d8 100644 --- a/flight/modules/GPS/inc/ubx_autoconfig.h +++ b/flight/modules/GPS/inc/ubx_autoconfig.h @@ -37,16 +37,42 @@ #define UBX_MAX_RATE_VER7 10 #define UBX_MAX_RATE 5 -// time to wait before reinitializing the fsm due to disconnection -#define UBX_CONNECTION_TIMEOUT (2000 * 1000) -// times between retries in case an error does occurs -#define UBX_ERROR_RETRY_TIMEOUT (1000 * 1000) +// reset to factory (and 9600 baud), and baud changes are not acked +// it could be 31 (full PIOS buffer) + 60 (gnss) + overhead bytes at 240 bytes per second +// = .42 seconds for the longest sentence to be fully transmitted +// and then it may have to do something like erase flash before replying... + +// at low baud rates and high data rates the ubx gps simply must drop some outgoing data +// and when a lot of data is being dropped, the MON VER reply often gets dropped +// on the other hand, uBlox documents that some versions discard data that is over a second old +// implying that it could be over 1 second before a reply is received +// later versions dropped this and drop data when the send buffer is full and that could be even longer +// rather than have long timeouts, we will let timeouts * retries handle that if it happens + // timeout for ack reception -#define UBX_REPLY_TIMEOUT (500 * 1000) +#define UBX_REPLY_TIMEOUT (500 * 1000) +// timeout for a settings save, in case it has to erase flash +#define UBX_REPLY_TO_SAVE_TIMEOUT (3000 * 1000) // max retries in case of timeout -#define UBX_MAX_RETRIES 5 -// pause between each configuration step -#define UBX_STEP_WAIT_TIME (10 * 1000) +#define UBX_MAX_RETRIES 5 +// pause between each verifiably correct configuration step +#define UBX_VERIFIED_STEP_WAIT_TIME (50 * 1000) +// pause between each unverifiably correct configuration step +#define UBX_UNVERIFIED_STEP_WAIT_TIME (500 * 1000) + +#define UBX_CFG_CFG_OP_STORE_SETTINGS (UBX_CFG_CFG_SETTINGS_IOPORT | \ + UBX_CFG_CFG_SETTINGS_MSGCONF | \ + UBX_CFG_CFG_SETTINGS_NAVCONF) +#define UBX_CFG_CFG_OP_CLEAR_SETTINGS ((~UBX_CFG_CFG_OP_STORE_SETTINGS) & UBX_CFG_CFG_SETTINGS_ALL) +// don't clear rinv as that is just text as configured by the owner +#define UBX_CFG_CFG_OP_RESET_SETTINGS (UBX_CFG_CFG_SETTINGS_IOPORT | \ + UBX_CFG_CFG_SETTINGS_MSGCONF | \ + UBX_CFG_CFG_SETTINGS_INFMSG | \ + UBX_CFG_CFG_SETTINGS_NAVCONF | \ + UBX_CFG_CFG_SETTINGS_TPCONF | \ + UBX_CFG_CFG_SETTINGS_SFDRCONF | \ + UBX_CFG_CFG_SETTINGS_ANTCONF) + // types typedef enum { UBX_AUTOCONFIG_STATUS_DISABLED = 0, @@ -54,26 +80,6 @@ typedef enum { UBX_AUTOCONFIG_STATUS_DONE, UBX_AUTOCONFIG_STATUS_ERROR } ubx_autoconfig_status_t; -// Enumeration options for field UBXDynamicModel -typedef enum { - UBX_DYNMODEL_PORTABLE = 0, - UBX_DYNMODEL_STATIONARY = 2, - UBX_DYNMODEL_PEDESTRIAN = 3, - UBX_DYNMODEL_AUTOMOTIVE = 4, - UBX_DYNMODEL_SEA = 5, - UBX_DYNMODEL_AIRBORNE1G = 6, - UBX_DYNMODEL_AIRBORNE2G = 7, - UBX_DYNMODEL_AIRBORNE4G = 8 -} ubx_config_dynamicmodel_t; - -typedef enum { - UBX_SBAS_SATS_AUTOSCAN = 0, - UBX_SBAS_SATS_WAAS = 1, - UBX_SBAS_SATS_EGNOS = 2, - UBX_SBAS_SATS_MSAS = 3, - UBX_SBAS_SATS_GAGAN = 4, - UBX_SBAS_SATS_SDCM = 5 -} ubx_config_sats_t; #define UBX_ typedef struct { @@ -94,142 +100,21 @@ typedef struct { bool enableBeiDou; } ubx_autoconfig_settings_t; -// Mask for "all supported devices": battery backed RAM, Flash, EEPROM, SPI Flash -#define UBX_CFG_CFG_ALL_DEVICES_MASK (0x01 | 0x02 | 0x04 | 0x10) - // Sent messages for configuration support -typedef struct { - uint32_t clearMask; - uint32_t saveMask; - uint32_t loadMask; - uint8_t deviceMask; -} __attribute__((packed)) ubx_cfg_cfg_t; +typedef struct UBX_CFG_CFG ubx_cfg_cfg_t; +typedef struct UBX_CFG_NAV5 ubx_cfg_nav5_t; +typedef struct UBX_CFG_RATE ubx_cfg_rate_t; +typedef struct UBX_CFG_MSG ubx_cfg_msg_t; +typedef struct UBX_CFG_PRT ubx_cfg_prt_t; +typedef struct UBX_CFG_SBAS ubx_cfg_sbas_t; +typedef struct UBX_CFG_GNSS_CFGBLOCK ubx_cfg_gnss_cfgblock_t; +typedef struct UBX_CFG_GNSS ubx_cfg_gnss_t; +typedef struct UBXSENTHEADER UBXSentHeader_t; +typedef union UBXSENTPACKET UBXSentPacket_t; -typedef struct { - uint16_t mask; - uint8_t dynModel; - uint8_t fixMode; - int32_t fixedAlt; - uint32_t fixedAltVar; - int8_t minElev; - uint8_t drLimit; - uint16_t pDop; - uint16_t tDop; - uint16_t pAcc; - uint16_t tAcc; - uint8_t staticHoldThresh; - uint8_t dgpsTimeOut; - uint8_t cnoThreshNumSVs; - uint8_t cnoThresh; - uint16_t reserved2; - uint32_t reserved3; - uint32_t reserved4; -} __attribute__((packed)) ubx_cfg_nav5_t; +void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send); +void ubx_autoconfig_set(ubx_autoconfig_settings_t *config); +void ubx_reset_sensor_type(); -typedef struct { - uint16_t measRate; - uint16_t navRate; - uint16_t timeRef; -} __attribute__((packed)) ubx_cfg_rate_t; - -typedef struct { - uint8_t msgClass; - uint8_t msgID; - uint8_t rate; -} __attribute__((packed)) ubx_cfg_msg_t; - -#define UBX_CFG_SBAS_MODE_ENABLED 0x01 -#define UBX_CFG_SBAS_MODE_TEST 0x02 -#define UBX_CFG_SBAS_USAGE_RANGE 0x01 -#define UBX_CFG_SBAS_USAGE_DIFFCORR 0x02 -#define UBX_CFG_SBAS_USAGE_INTEGRITY 0x04 - -// SBAS used satellite PNR bitmask (120-151) -// -------------------------------------1---------1---------1---------1 -// -------------------------------------5---------4---------3---------2 -// ------------------------------------10987654321098765432109876543210 -// WAAS 122, 133, 134, 135, 138---------|---------|---------|---------| -#define UBX_CFG_SBAS_SCANMODE1_WAAS 0b00000000000001001110000000000100 -// EGNOS 120, 124, 126, 131-------------|---------|---------|---------| -#define UBX_CFG_SBAS_SCANMODE1_EGNOS 0b00000000000000000000100001010001 -// MSAS 129, 137------------------------|---------|---------|---------| -#define UBX_CFG_SBAS_SCANMODE1_MSAS 0b00000000000000100000001000000000 -// GAGAN 127, 128-----------------------|---------|---------|---------| -#define UBX_CFG_SBAS_SCANMODE1_GAGAN 0b00000000000000000000000110000000 -// SDCM 125, 140, 141-------------------|---------|---------|---------| -#define UBX_CFG_SBAS_SCANMODE1_SDCM 0b00000000001100000000000000100000 - -#define UBX_CFG_SBAS_SCANMODE2 0x00 -typedef struct { - uint8_t mode; - uint8_t usage; - uint8_t maxSBAS; - uint8_t scanmode2; - uint32_t scanmode1; -} __attribute__((packed)) ubx_cfg_sbas_t; - -typedef enum { - UBX_GNSS_ID_GPS = 0, - UBX_GNSS_ID_SBAS = 1, - UBX_GNSS_ID_GALILEO = 2, - UBX_GNSS_ID_BEIDOU = 3, - UBX_GNSS_ID_IMES = 4, - UBX_GNSS_ID_QZSS = 5, - UBX_GNSS_ID_GLONASS = 6, - UBX_GNSS_ID_MAX -} ubx_config_gnss_id_t; - -#define UBX_CFG_GNSS_FLAGS_ENABLED 0x01 -#define UBX_CFG_GNSS_FLAGS_GPS_L1CA 0x010000 -#define UBX_CFG_GNSS_FLAGS_SBAS_L1CA 0x010000 -#define UBX_CFG_GNSS_FLAGS_BEIDOU_B1I 0x010000 -#define UBX_CFG_GNSS_FLAGS_QZSS_L1CA 0x010000 -#define UBX_CFG_GNSS_FLAGS_QZSS_L1SAIF 0x040000 -#define UBX_CFG_GNSS_FLAGS_GLONASS_L1OF 0x010000 - -#define UBX_CFG_GNSS_NUMCH_VER7 22 -#define UBX_CFG_GNSS_NUMCH_VER8 32 - -typedef struct { - uint8_t gnssId; - uint8_t resTrkCh; - uint8_t maxTrkCh; - uint8_t resvd; - uint32_t flags; -} __attribute__((packed)) ubx_cfg_gnss_cfgblock_t; - -typedef struct { - uint8_t msgVer; - uint8_t numTrkChHw; - uint8_t numTrkChUse; - uint8_t numConfigBlocks; - ubx_cfg_gnss_cfgblock_t cfgBlocks[UBX_GNSS_ID_MAX]; -} __attribute__((packed)) ubx_cfg_gnss_t; - -typedef struct { - uint8_t prolog[2]; - uint8_t class; - uint8_t id; - uint16_t len; -} __attribute__((packed)) UBXSentHeader_t; - -typedef union { - uint8_t buffer[0]; - struct { - UBXSentHeader_t header; - union { - ubx_cfg_cfg_t cfg_cfg; - ubx_cfg_msg_t cfg_msg; - ubx_cfg_nav5_t cfg_nav5; - ubx_cfg_rate_t cfg_rate; - ubx_cfg_sbas_t cfg_sbas; - ubx_cfg_gnss_t cfg_gnss; - } payload; - uint8_t resvd[2]; // added space for checksum bytes - } message; -} __attribute__((packed)) UBXSentPacket_t; - -void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send, bool gps_connected); -void ubx_autoconfig_set(ubx_autoconfig_settings_t config); int32_t ubx_autoconfig_get_status(); #endif /* UBX_AUTOCONFIG_H_ */ diff --git a/flight/modules/GPS/ubx_autoconfig.c b/flight/modules/GPS/ubx_autoconfig.c index c86fbb445..5fa036596 100644 --- a/flight/modules/GPS/ubx_autoconfig.c +++ b/flight/modules/GPS/ubx_autoconfig.c @@ -27,29 +27,48 @@ * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include +#include "hwsettings.h" + #include "inc/ubx_autoconfig.h" #include + // private type definitions + typedef enum { INIT_STEP_DISABLED = 0, INIT_STEP_START, - INIT_STEP_ASK_VER, - INIT_STEP_WAIT_VER, + INIT_STEP_RESET_GPS, + INIT_STEP_REVO_9600_BAUD, + INIT_STEP_GPS_BAUD, + INIT_STEP_REVO_BAUD, INIT_STEP_ENABLE_SENTENCES, INIT_STEP_ENABLE_SENTENCES_WAIT_ACK, INIT_STEP_CONFIGURE, INIT_STEP_CONFIGURE_WAIT_ACK, + INIT_STEP_SAVE, + INIT_STEP_SAVE_WAIT_ACK, INIT_STEP_DONE, - INIT_STEP_ERROR, + INIT_STEP_ERROR } initSteps_t; typedef struct { initSteps_t currentStep; // Current configuration "fsm" status + initSteps_t currentStepSave; // Current configuration "fsm" status uint32_t lastStepTimestampRaw; // timestamp of last operation uint32_t lastConnectedRaw; // timestamp of last time gps was connected - UBXSentPacket_t working_packet; // outbound "buffer" - ubx_autoconfig_settings_t currentSettings; - int8_t lastConfigSent; // index of last configuration string sent + struct { + UBXSentPacket_t working_packet; // outbound "buffer" + // bufferPaddingForPiosBugAt2400Baud must exist for baud rate change to work at 2400 or 4800 + // failure mode otherwise: + // - send message with baud rate change + // - wait 1 second (even at 2400, the baud rate change command should clear even an initially full 31 byte PIOS buffer much more quickly) + // - change Revo port baud rate + // sometimes fails (much worse for lowest baud rates) + uint8_t bufferPaddingForPiosBugAt2400Baud[2]; // must be at least 2 for 2400 to work, probably 1 for 4800 and 0 for 9600+ + } __attribute__((packed)); + volatile ubx_autoconfig_settings_t currentSettings; + int8_t lastConfigSent; // index of last configuration string sent struct UBX_ACK_ACK requiredAck; // Class and id of the message we are waiting for an ACK from GPS uint8_t retryCount; } status_t; @@ -114,15 +133,24 @@ ubx_cfg_msg_t msg_config_ubx7[] = { }; // private defines + #define LAST_CONFIG_SENT_START (-1) #define LAST_CONFIG_SENT_COMPLETED (-2) +// always reset the stored GPS configuration, even when doing autoconfig.nostore +// that is required to do a 100% correct configuration +// but is unexpected because it changes the stored configuration when doing autoconfig.nostore +// note that a reset is always done with autoconfig.store +//#define ALWAYS_RESET // private variables // enable the autoconfiguration system -static bool enabled; +static volatile bool enabled = false; +static volatile bool current_step_touched = false; +// both the pointer and what it points to are volatile. Yuk. +static volatile status_t * volatile status = 0; +static uint8_t hwsettings_baud; -static status_t *status = 0; static void append_checksum(UBXSentPacket_t *packet) { @@ -139,29 +167,152 @@ static void append_checksum(UBXSentPacket_t *packet) packet->buffer[len] = ck_a; packet->buffer[len + 1] = ck_b; } + + /** * prepare a packet to be sent, fill the header and appends the checksum. * return the total packet lenght comprising header and checksum */ static uint16_t prepare_packet(UBXSentPacket_t *packet, uint8_t classID, uint8_t messageID, uint16_t len) { + memset((uint8_t *)status->working_packet.buffer + len + sizeof(UBXSentHeader_t) + 2, 0, sizeof(status->bufferPaddingForPiosBugAt2400Baud)); packet->message.header.prolog[0] = UBX_SYNC1; packet->message.header.prolog[1] = UBX_SYNC2; packet->message.header.class = classID; packet->message.header.id = messageID; packet->message.header.len = len; append_checksum(packet); - return packet->message.header.len + sizeof(UBXSentHeader_t) + 2; // header + payload + checksum + + status->requiredAck.clsID = classID; + status->requiredAck.msgID = messageID; + + return (len + sizeof(UBXSentHeader_t) + 2 + sizeof(status->bufferPaddingForPiosBugAt2400Baud)); // payload + header + checksum + extra bytes } + static void build_request(UBXSentPacket_t *packet, uint8_t classID, uint8_t messageID, uint16_t *bytes_to_send) { *bytes_to_send = prepare_packet(packet, classID, messageID, 0); } -void config_rate(uint16_t *bytes_to_send) + +static void set_current_step_if_untouched(initSteps_t new_steps) { - memset(status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_rate_t)); + // assume this one byte initSteps_t is atomic + // take care of some but not all concurrency issues + + if (!current_step_touched) { + status->currentStep = new_steps; + } + if (current_step_touched) { + status->currentStep = status->currentStepSave; + } +} + + +void ubx_reset_sensor_type() +{ + ubxHwVersion = -1; + sensorType = GPSPOSITIONSENSOR_SENSORTYPE_UNKNOWN; + GPSPositionSensorSensorTypeSet((uint8_t *) &sensorType); +} + + +static void config_reset(uint16_t *bytes_to_send) +{ + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_cfg_t)); + // mask LSB=ioPort|msgConf|infMsg|navConf|rxmConf|||||rinvConf|antConf|....|= MSB + // ioPort=1, msgConf=2, infMsg=4, navConf=8, tpConf=0x10, sfdrConf=0x100, rinvConf=0x200, antConf=0x400 + // first: reset (permanent settings to default) all but rinv = e.g. owner name + status->working_packet.message.payload.cfg_cfg.clearMask = UBX_CFG_CFG_OP_RESET_SETTINGS; + // then: don't store any current settings to permanent + status->working_packet.message.payload.cfg_cfg.saveMask = UBX_CFG_CFG_SETTINGS_NONE; + // lastly: load (immediately start to use) all but rinv = e.g. owner name + status->working_packet.message.payload.cfg_cfg.loadMask = UBX_CFG_CFG_OP_RESET_SETTINGS; + // all devices + status->working_packet.message.payload.cfg_cfg.deviceMask = UBX_CFG_CFG_DEVICE_ALL; + + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_CFG, sizeof(ubx_cfg_cfg_t)); +} + + +// set the GPS baud rate to the user specified baud rate +// because we may have started up with 9600 baud (for a GPS with no permanent settings) +static void config_gps_baud(uint16_t *bytes_to_send) +{ + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_prt_t)); + status->working_packet.message.payload.cfg_prt.mode = UBX_CFG_PRT_MODE_DEFAULT; // 8databits, 1stopbit, noparity, and non-zero reserved + status->working_packet.message.payload.cfg_prt.portID = 1; // 1 = UART1, 2 = UART2 + status->working_packet.message.payload.cfg_prt.inProtoMask = 1; // 1 = UBX only (bit 0) + status->working_packet.message.payload.cfg_prt.outProtoMask = 1; // 1 = UBX only (bit 0) + // Ask GPS to change it's speed + switch (hwsettings_baud) { + case HWSETTINGS_GPSSPEED_2400: + status->working_packet.message.payload.cfg_prt.baudRate = 2400; + break; + case HWSETTINGS_GPSSPEED_4800: + status->working_packet.message.payload.cfg_prt.baudRate = 4800; + break; + case HWSETTINGS_GPSSPEED_9600: + status->working_packet.message.payload.cfg_prt.baudRate = 9600; + break; + case HWSETTINGS_GPSSPEED_19200: + status->working_packet.message.payload.cfg_prt.baudRate = 19200; + break; + case HWSETTINGS_GPSSPEED_38400: + status->working_packet.message.payload.cfg_prt.baudRate = 38400; + break; + case HWSETTINGS_GPSSPEED_57600: + status->working_packet.message.payload.cfg_prt.baudRate = 57600; + break; + case HWSETTINGS_GPSSPEED_115200: + status->working_packet.message.payload.cfg_prt.baudRate = 115200; + break; + case HWSETTINGS_GPSSPEED_230400: + status->working_packet.message.payload.cfg_prt.baudRate = 230400; + break; + } + + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_PRT, sizeof(ubx_cfg_prt_t)); +} + + +// having already set the GPS's baud rate with a serial command, set the local Revo port baud rate +static void config_baud(uint8_t baud) +{ + // Set Revo port hwsettings_baud + switch (baud) { + case HWSETTINGS_GPSSPEED_2400: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 2400); + break; + case HWSETTINGS_GPSSPEED_4800: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 4800); + break; + case HWSETTINGS_GPSSPEED_9600: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 9600); + break; + case HWSETTINGS_GPSSPEED_19200: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 19200); + break; + case HWSETTINGS_GPSSPEED_38400: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 38400); + break; + case HWSETTINGS_GPSSPEED_57600: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 57600); + break; + case HWSETTINGS_GPSSPEED_115200: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 115200); + break; + case HWSETTINGS_GPSSPEED_230400: + PIOS_COM_ChangeBaud(PIOS_COM_GPS, 230400); + break; + } +} + + +static void config_rate(uint16_t *bytes_to_send) +{ + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_rate_t)); // if rate is less than 1 uses the highest rate for current hardware uint16_t rate = status->currentSettings.navRate > 0 ? status->currentSettings.navRate : 99; if (ubxHwVersion < UBX_HW_VERSION_7 && rate > UBX_MAX_RATE) { @@ -172,36 +323,31 @@ void config_rate(uint16_t *bytes_to_send) rate = UBX_MAX_RATE_VER8; } uint16_t period = 1000 / rate; - status->working_packet.message.payload.cfg_rate.measRate = period; status->working_packet.message.payload.cfg_rate.navRate = 1; // must be set to 1 status->working_packet.message.payload.cfg_rate.timeRef = 1; // 0 = UTC Time, 1 = GPS Time - *bytes_to_send = prepare_packet(&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_RATE, sizeof(ubx_cfg_rate_t)); - status->requiredAck.clsID = UBX_CLASS_CFG; - status->requiredAck.msgID = UBX_ID_CFG_RATE; + + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_RATE, sizeof(ubx_cfg_rate_t)); } -void config_nav(uint16_t *bytes_to_send) -{ - memset(status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_nav5_t)); +static void config_nav(uint16_t *bytes_to_send) +{ + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_nav5_t)); status->working_packet.message.payload.cfg_nav5.dynModel = status->currentSettings.dynamicModel; status->working_packet.message.payload.cfg_nav5.fixMode = 2; // 1=2D only, 2=3D only, 3=Auto 2D/3D // mask LSB=dyn|minEl|posFixMode|drLim|posMask|statisticHoldMask|dgpsMask|......|reservedBit0 = MSB - status->working_packet.message.payload.cfg_nav5.mask = 0x01 + 0x04; // Dyn Model | posFixMode configuration - *bytes_to_send = prepare_packet(&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_NAV5, sizeof(ubx_cfg_nav5_t)); - status->requiredAck.clsID = UBX_CLASS_CFG; - status->requiredAck.msgID = UBX_ID_CFG_NAV5; + + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_NAV5, sizeof(ubx_cfg_nav5_t)); } -void config_sbas(uint16_t *bytes_to_send) + +static void config_sbas(uint16_t *bytes_to_send) { - memset(status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_sbas_t)); - - status->working_packet.message.payload.cfg_sbas.maxSBAS = status->currentSettings.SBASChannelsUsed < 4 ? - status->currentSettings.SBASChannelsUsed : 3; - + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_sbas_t)); + status->working_packet.message.payload.cfg_sbas.maxSBAS = + status->currentSettings.SBASChannelsUsed < 4 ? status->currentSettings.SBASChannelsUsed : 3; status->working_packet.message.payload.cfg_sbas.usage = (status->currentSettings.SBASCorrection ? UBX_CFG_SBAS_USAGE_DIFFCORR : 0) | (status->currentSettings.SBASIntegrity ? UBX_CFG_SBAS_USAGE_INTEGRITY : 0) | @@ -209,34 +355,28 @@ void config_sbas(uint16_t *bytes_to_send) // If sbas is used for anything then set mode as enabled status->working_packet.message.payload.cfg_sbas.mode = status->working_packet.message.payload.cfg_sbas.usage != 0 ? UBX_CFG_SBAS_MODE_ENABLED : 0; - status->working_packet.message.payload.cfg_sbas.scanmode1 = status->currentSettings.SBASSats == UBX_SBAS_SATS_WAAS ? UBX_CFG_SBAS_SCANMODE1_WAAS : status->currentSettings.SBASSats == UBX_SBAS_SATS_EGNOS ? UBX_CFG_SBAS_SCANMODE1_EGNOS : status->currentSettings.SBASSats == UBX_SBAS_SATS_MSAS ? UBX_CFG_SBAS_SCANMODE1_MSAS : status->currentSettings.SBASSats == UBX_SBAS_SATS_GAGAN ? UBX_CFG_SBAS_SCANMODE1_GAGAN : status->currentSettings.SBASSats == UBX_SBAS_SATS_SDCM ? UBX_CFG_SBAS_SCANMODE1_SDCM : UBX_SBAS_SATS_AUTOSCAN; + status->working_packet.message.payload.cfg_sbas.scanmode2 = + UBX_CFG_SBAS_SCANMODE2; - status->working_packet.message.payload.cfg_sbas.scanmode2 = UBX_CFG_SBAS_SCANMODE2; - - *bytes_to_send = prepare_packet(&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_SBAS, sizeof(ubx_cfg_sbas_t)); - status->requiredAck.clsID = UBX_CLASS_CFG; - status->requiredAck.msgID = UBX_ID_CFG_SBAS; + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_SBAS, sizeof(ubx_cfg_sbas_t)); } -void config_gnss(uint16_t *bytes_to_send) + +static void config_gnss(uint16_t *bytes_to_send) { - int32_t i; - - memset(status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_gnss_t)); - + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_gnss_t)); status->working_packet.message.payload.cfg_gnss.numConfigBlocks = UBX_GNSS_ID_MAX; status->working_packet.message.payload.cfg_gnss.numTrkChHw = (ubxHwVersion > UBX_HW_VERSION_7) ? UBX_CFG_GNSS_NUMCH_VER8 : UBX_CFG_GNSS_NUMCH_VER7; status->working_packet.message.payload.cfg_gnss.numTrkChUse = status->working_packet.message.payload.cfg_gnss.numTrkChHw; - for (i = 0; i < UBX_GNSS_ID_MAX; i++) { + for (int32_t i = 0; i < UBX_GNSS_ID_MAX; i++) { status->working_packet.message.payload.cfg_gnss.cfgBlocks[i].gnssId = i; - switch (i) { case UBX_GNSS_ID_GPS: if (status->currentSettings.enableGPS) { @@ -278,30 +418,35 @@ void config_gnss(uint16_t *bytes_to_send) } } - *bytes_to_send = prepare_packet(&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_GNSS, sizeof(ubx_cfg_gnss_t)); - status->requiredAck.clsID = UBX_CLASS_CFG; - status->requiredAck.msgID = UBX_ID_CFG_GNSS; + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_GNSS, sizeof(ubx_cfg_gnss_t)); } -void config_save(uint16_t *bytes_to_send) + +static void config_save(uint16_t *bytes_to_send) { - memset(status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_cfg_t)); + memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_cfg_t)); // mask LSB=ioPort|msgConf|infMsg|navConf|rxmConf|||||rinvConf|antConf|....|= MSB - status->working_packet.message.payload.cfg_cfg.saveMask = 0x02 | 0x08; // msgConf + navConf - status->working_packet.message.payload.cfg_cfg.deviceMask = UBX_CFG_CFG_ALL_DEVICES_MASK; - *bytes_to_send = prepare_packet(&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_CFG, sizeof(ubx_cfg_cfg_t)); - status->requiredAck.clsID = UBX_CLASS_CFG; - status->requiredAck.msgID = UBX_ID_CFG_CFG; + // ioPort=1, msgConf=2, infMsg=4, navConf=8, tpConf=0x10, sfdrConf=0x100, rinvConf=0x200, antConf=0x400 + status->working_packet.message.payload.cfg_cfg.saveMask = UBX_CFG_CFG_OP_STORE_SETTINGS; // a list of settings we just set + status->working_packet.message.payload.cfg_cfg.clearMask = UBX_CFG_CFG_OP_CLEAR_SETTINGS; // everything else gets factory default + status->working_packet.message.payload.cfg_cfg.deviceMask = UBX_CFG_CFG_DEVICE_ALL; + + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_CFG, sizeof(ubx_cfg_cfg_t)); } + + static void configure(uint16_t *bytes_to_send) { switch (status->lastConfigSent) { case LAST_CONFIG_SENT_START: + // increase message rates to 5 fixes per second config_rate(bytes_to_send); break; + case LAST_CONFIG_SENT_START + 1: config_nav(bytes_to_send); break; + case LAST_CONFIG_SENT_START + 2: if (status->currentSettings.enableGLONASS || status->currentSettings.enableGPS) { config_gnss(bytes_to_send); @@ -310,24 +455,19 @@ static void configure(uint16_t *bytes_to_send) // Skip and fall through to next step status->lastConfigSent++; } + // in the else case we must fall through because we must send something each time because successful send is tested externally + case LAST_CONFIG_SENT_START + 3: config_sbas(bytes_to_send); - if (!status->currentSettings.storeSettings) { - // skips saving - status->lastConfigSent = LAST_CONFIG_SENT_COMPLETED; - } break; - case LAST_CONFIG_SENT_START + 4: - config_save(bytes_to_send); - status->lastConfigSent = LAST_CONFIG_SENT_COMPLETED; - return; default: status->lastConfigSent = LAST_CONFIG_SENT_COMPLETED; - return; + break; } } + static void enable_sentences(__attribute__((unused)) uint16_t *bytes_to_send) { int8_t msg = status->lastConfigSent + 1; @@ -338,66 +478,303 @@ static void enable_sentences(__attribute__((unused)) uint16_t *bytes_to_send) if (msg >= 0 && msg < msg_count) { status->working_packet.message.payload.cfg_msg = msg_config[msg]; - - *bytes_to_send = prepare_packet(&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_MSG, sizeof(ubx_cfg_msg_t)); - status->requiredAck.clsID = UBX_CLASS_CFG; - status->requiredAck.msgID = UBX_ID_CFG_MSG; + *bytes_to_send = prepare_packet((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_CFG, UBX_ID_CFG_MSG, sizeof(ubx_cfg_msg_t)); } else { status->lastConfigSent = LAST_CONFIG_SENT_COMPLETED; } } -void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send, bool gps_connected) + +// End User Documentation + +// There are two baud rates of interest +// The baud rate the GPS is talking at +// The baud rate Revo or CC/3D is talking at +// These two must match for the GPS to work +// You only have direct control of the Revo baud rate +// The two baud rates must be the same for the Revo to send a command to the GPS +// to tell the GPS to change it's baud rate +// So you start out by changing Revo's baud rate to match the GPS's +// and then enable UbxAutoConfig to tell Revo to change the GPS baud every time, just before it changes the Revo baud +// That is the basis of these instructions + +// There are microprocessors and they each have internal settings +// Revo +// GPS +// and each of these settings can be temporary or permanent + +// To change a Revo setting +// Use the System tab in the GCS for all the following +// Example: in Settings->GPSSettings click on the VALUE for UbxAutoConfig and change it to Disabled +// Click on UbxAutoConfig itself and the line will turn green and blue +// To change this setting permanently, press the red up arrow (Save) at the top of the screen +// Permanently means that it uses this setting, even if you reboot Revo, e.g. power off and on +// To change this setting temporarily, press the green up arrow (Send) at the top of the screen +// Temporarily means that it overrides the permanent setting, but it goes back to the permanent setting when you reboot Revo, e.g. power off and on + +// To change an internal GPS setting you use the OP GCS System tab to tell Revo to make the GPS changes +// This only works correctly after you have matching baud rates so Revo and GPS can talk together +// "Settings->GPSSettings->UbxAutoConfig = Configure" sets the internal GPS setting temporarily +// "Settings->GPSSettings->UbxAutoConfig = ConfigureAndStore" sets the internal GPS setting permanently + +// You want to wind up with a set of permanent settings that work together +// There are two different sets of permanent settings that work together +// GPS at 9600 baud and factory defaults +// Revo configured to start out at 9600 baud, but then completely configure the GPS and switch both to 57600 baud +// (takes 6 seconds at boot up while you are waiting for it to acquire satellites anyway) +// This is the preferred way so that if we change the settings in the future, the new release will automatically use the correct settings +// GPS at 57600 baud with all the settings for the current release stored in the GPS +// Revo configured to disable UbxAutoConfig since all the GPS settings are permanently stored correctly +// May require reconfiguring in a future release + +// Changable settings of interest +// AutoConfig mode +// Settings->GPSSettings->UbxAutoConfig (Disabled, Configure, ConfigureAndStore, default=Configure) +// Disabled means that changes to the GPS baud setting only affect the Revo port +// It doesn't try to change the GPS's internal baud rate setting +// Configure means change the GPS's internal baud setting temporarily (GPS settings revert to the permanent values when GPS is powered off/on) +// ConfigureAndStore means change the GPS's internal baud setting permanently (even after the GPS is powered off/on) +// GPS baud rate +// Settings->HwSettings->GPSSpeed +// If the baud rates are the same and an AutoConfig mode is enabled this will change both the GPS baud rate and the Revo baud rate +// If the baud rates are not the same and an AutoConfig mode is enabled it will fail +// If AutoConfig mode is disabled this will only change the Revo baud rate + +// View only settings of interest +// Detected GPS type +// Data Objects -> GPSPositionSensor -> SensorType (Unknown, NMEA, UBX, UBX7, UBX8) +// When it says something other than Unknown, the GPS and Revo baud rates are synced and talking +// Real time progress of the GPS detection process +// Data Objects -> GPSPositionSensor -> AutoConfigStatus (DISABLED, RUNNING, DONE, ERROR) + +// Syncing the baud rates means that the GPS's internal baud rate setting is the same as the Revo (or CC/3D) port setting +// This is necessary for the GPS to work with Revo +// To sync to and find out an unknown GPS baud rate (or sync to and use a known GPS baud rate) +// Temporarily change the AutoConfig mode to Disabled +// Temporarily change the GPS baud rate to a value you think it might be (or go up the list) +// See if that baud rate is correct (Data Objects->GPSPositionSensor->SensorType will be something besides Unknown) +// Repeat, changing the GPS baud rate, until found + +// Some very important facts: +// For 9600 baud or lower, the autoconfig will configure it to factory default settings +// For 19200 baud or higher, the autoconfig will configure it to OP required settings +// If autoconfig is enabled permanently in Revo, it will assume that the GPS is configured to power up at 9600 baud +// 57600 baud is recommended for the current release +// That can be achieved either by +// autoconfiging the GPS from a permanent 9600 baud (and factory settings) to a temporary 57600 (with OP settings) on each power up +// or by configuring the GPS with a permanent 57600 (with OP settings) and then permanently disabling autoconfig +// Some previous releases used 38400 and had some other settings differences + +// The user should either: +// Permanently configure their GPS to 9600 baud factory settings and tell the Revo configuration to load volatile settings at each startup by: +// (Recommended method because new versions could require new settings and this handles future changes automatically) +// Syncing the baud rates +// Setting it to autoconfig.nostore and waiting for it to complete +// Setting HwSettings.GPSSpeed to 9600 and waiting for it to complete +// Setting it to autoconfig.store and waiting for it to complete (this tells the GPS to store the 9600 permanently) +// Permanently setting it to autoconfig.nostore and waiting for it to complete +// Permanently setting HwSettings.GPSSpeed to 57600 and waiting for it to complete +// Permanently configure their GPS to 57600 baud, including OpenPilot settings and telling the Revo configuration to just set the baud to 57600 at each startup by: +// (Less recommended method because new versions could require new settings so you would have to do this again) +// Syncing the baud rates +// Setting it to autoconfig.nostore and waiting for it to complete +// Permanently setting HwSettings.GPSSpeed to 57600 and waiting for it to complete +// Setting it to autoconfig.store +// Permanently setting it to autoconfig.disabled + +// The algorithm is: +// If autoconfig is enabled at all +// It will assume that the GPS boot up baud rate is 9600 and the user wants that changed to HwSettings.GPSSpeed +// and that change can be either volatile (must be done each boot up) or non-volatile (stored in GPS's non-volatile settings storage) +// according to whether CONFIGURE is used or CONFIGUREANDSTORE is used +// The only user who should need CONFIGUREANDSTORE stored permanently in Revo is Dave, who configures many OP GPS's before shipping +// plug a factory default GPS in to a Revo, power up, wait for it to configure and permanently store in the GPS, power down, ship +// If autoconfig is not enabled +// it will use HwSettings.GPSSpeed for the baud rate and not do any configuration changes +// If GPSSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_CONFIGUREANDSTORE it will +// 1 Reset the permanent configuration back to factory default +// 2 Disable NEMA message settings +// 3 Add some volatile UBX settings to the copies of the non-volatile ones that are currently running +// 4 Save the current volatile settings to non-volatile storage +// If GPSSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_CONFIGURE it will +// 2 Disable NEMA message settings +// 3 Add some volatile UBX settings to the copies of the non-volatile ones that are currently running +// If the requested baud rate is 9600 or less it skips the step (3) of adding some volatile UBX settings + +// Talking points to point out: +// U-center is no longer needed for any use case with this code +// 9600 is factory default for GPS's +// Some GPS can't even permanently store settings and must start at 9600 baud? +// I have a GPS that sometimes looses settings and reverts to 9600 and this is a fix for that too :) +// This code handles a GPS configured either way (9600 with factory default settings or e.g. 57600 with OP settings) +// Autoconfig.nostore at each boot for 9600, autoconfig.disabled for the 57600 with OP settings (or custom settings and baud) +// This code can permanently configure a GPS to be e.g. 9600 with factory default settings or 57600 with OP settings +// GPS's with 9600 baud and factory default settings would be a good default for future OP releases +// Changing the GPS internal settings multiple times in the future is handled automatically +// This code is written to do a configure from 9600 to 57600 +// (actually 9600 to whatever is stored in HwSettings.GPSSpeed) +// if autoconfig is enabled at boot up +// When autoconfiging to 9600 baud or lower, the autoconfig will configure it to factory default settings, not OP settings +// That is because 9600 baud drops many of the OP messages and because 9600 baud is factory default +// For 19200 baud or higher, the autoconfig will configure it to OP required settings +// If autoconfig is enabled permanently in Revo, it will assume that the GPS is configured to power up at 9600 baud +// This is good for factory default GPS's +// This is good in case we change some settings in a future release + + +void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) { *bytes_to_send = 0; *buffer = (char *)status->working_packet.buffer; - if (!status || !enabled || status->currentStep == INIT_STEP_DISABLED) { - return; // autoconfig not enabled - } - if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_STEP_WAIT_TIME) { + current_step_touched = false; + + // autoconfig struct not yet allocated + if (!status) { return; } - // when gps is disconnected it will replay the autoconfig sequence. - if (!gps_connected) { - if (status->currentStep == INIT_STEP_DONE) { - // if some operation is in progress and it is not running into issues it maybe that - // the disconnection is only due to wrong message rates, so reinit only when done. - // errors caused by disconnection are handled by error retry logic - if (PIOS_DELAY_DiffuS(status->lastConnectedRaw) > UBX_CONNECTION_TIMEOUT) { - status->currentStep = INIT_STEP_START; - return; - } + // smallest delay between each step + if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_VERIFIED_STEP_WAIT_TIME) { + return; + } + // get UBX version whether autoconfig is enabled or not + // this allows the user to try some baud rates and visibly see when it works + // ubxHwVersion is a global set externally by the caller of this function + if (ubxHwVersion <= 0) { + // at low baud rates and high data rates the ubx gps simply must drop some outgoing data + // this isn't really an error + // and when a lot of data is being dropped, the MON VER reply often gets dropped + // on the other hand, uBlox documents that some versions discard data that is over 1 second old + // implying a 1 second send buffer and that it could be over 1 second before a reply is received + // later uBlox versions dropped this 1 second constraint and drop data when the send buffer is full + // and that could be even longer than 1 second + // send this more quickly and it will get a reply more quickly if a fixed percentage of replies are being dropped + + // wait for the normal reply timeout before sending it over and over + if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_REPLY_TIMEOUT) { + return; } - } else { - // reset connection timer - status->lastConnectedRaw = PIOS_DELAY_GetRaw(); + build_request((UBXSentPacket_t *)&status->working_packet, UBX_CLASS_MON, UBX_ID_MON_VER, bytes_to_send); + // keep timeouts running properly, we (will have) just sent a packet that generates a reply + status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + return; + } + if (!enabled) { + // keep resetting the timeouts here if we are not actually going to run the configure code + // not really necessary, but it keeps the timer from wrapping every 50 seconds + status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + return; // autoconfig not enabled + } + + // replaying constantly could wear the settings memory out + // don't allow constant reconfiging when offline + // don't even allow program bugs that could constantly toggle between connected and disconnected to cause configuring + if (status->currentStep == INIT_STEP_DONE || status->currentStep == INIT_STEP_ERROR) { + return; } switch (status->currentStep) { - case INIT_STEP_ERROR: - case INIT_STEP_DISABLED: - case INIT_STEP_DONE: - return; - case INIT_STEP_START: - case INIT_STEP_ASK_VER: - status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); - build_request(&status->working_packet, UBX_CLASS_MON, UBX_ID_MON_VER, bytes_to_send); - status->currentStep = INIT_STEP_WAIT_VER; + // we should look for the GPS version again + ubx_reset_sensor_type(); + // do not fall through to next state + // or it might try to get the sensor type when the baud rate is half changed + set_current_step_if_untouched(INIT_STEP_RESET_GPS); + // allow it to get the sensor type immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); break; - case INIT_STEP_WAIT_VER: - if (ubxHwVersion > 0) { - status->lastConfigSent = LAST_CONFIG_SENT_START; - status->currentStep = INIT_STEP_ENABLE_SENTENCES; + case INIT_STEP_RESET_GPS: + // make sure we don't change the baud rate too soon and garble the packet being sent + // even after pios says the buffer is empty, the serial port buffer still has data in it + // and changing the baud will screw it up + // when the GPS is configured to send a lot of data, but has a low baud rate + // it has way too many messages to send and has to drop most of them + + // Retrieve desired GPS baud rate once for use throughout this module + HwSettingsGPSSpeedGet(&hwsettings_baud); +#if !defined(ALWAYS_RESET) + // ALWAYS_RESET is undefined because it causes stored settings to change even with autoconfig.nostore + // but with it off, some settings may be enabled that should really be disabled (but aren't) after autoconfig.nostore + // if user requests a low baud rate then we just reset and leave it set to NEMA + // because low baud and high OP data rate doesn't play nice + // if user requests that settings be saved, we will reset here too + // that makes sure that all strange settings are reset to factory default + // else these strange settings may persist because we don't reset all settings by table + if (status->currentSettings.storeSettings) +#endif + { + // reset all GPS parameters to factory default (configure low rate NEMA for low baud rates) + // this is not usable by OP code for either baud rate or types of messages sent + // but it starts up very quickly for use with autoconfig-nostore (which sets a high baud and enables all the necessary messages) + config_reset(bytes_to_send); status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + } + // else allow it enter the next state immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + set_current_step_if_untouched(INIT_STEP_REVO_9600_BAUD); + break; + + case INIT_STEP_REVO_9600_BAUD: +#if !defined(ALWAYS_RESET) + // if user requests a low baud rate then we just reset and leave it set to NEMA + // because low baud and high OP data rate doesn't play nice + // if user requests that settings be saved, we will reset here too + // that makes sure that all strange settings are reset to factory default + // else these strange settings may persist because we don't reset all settings by hand + if (status->currentSettings.storeSettings) +#endif + { + // wait for previous step + if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_UNVERIFIED_STEP_WAIT_TIME) { + return; + } + // set the Revo GPS port to 9600 baud to match the reset to factory default that has already been done + config_baud(HWSETTINGS_GPSSPEED_9600); + } + // at most, we just set Revo baud and that doesn't send any data + // fall through to next state + // we can do that if we choose because we haven't sent any data in this state + // set_current_step_if_untouched(INIT_STEP_GPS_BAUD); + // allow it enter the next state immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + // break; + + case INIT_STEP_GPS_BAUD: + // https://www.u-blox.com/images/downloads/Product_Docs/u-bloxM8_ReceiverDescriptionProtocolSpec_%28UBX-13003221%29_Public.pdf + // It is possible to change the current communications port settings using a UBX-CFG-CFG message. This could + // affect baud rate and other transmission parameters. Because there may be messages queued for transmission + // there may be uncertainty about which protocol applies to such messages. In addition a message currently in + // transmission may be corrupted by a protocol change. Host data reception parameters may have to be changed to + // be able to receive future messages, including the acknowledge message associated with the UBX-CFG-CFG message. + + // so the message that changes the baud rate will send it's acknowledgement back at the new baud rate; this is not good. + // if your message was corrupted, you didn't change the baud rate and you have to guess; try pinging at both baud rates. + // also, you would have to change the baud rate instantly after the last byte of the sentence was sent, + // and you would have to poll the port in real time for that, and there may be messages ahead of the baud rate change. + // + // so we ignore the ack from this. it has proven to be reliable (with the addition of two dummy bytes after the packet) + + // set the GPS internal baud rate to the user configured value + config_gps_baud(bytes_to_send); + set_current_step_if_untouched(INIT_STEP_REVO_BAUD); + status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + break; + + case INIT_STEP_REVO_BAUD: + // wait for previous step + if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_UNVERIFIED_STEP_WAIT_TIME) { return; } - - if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) > UBX_REPLY_TIMEOUT) { - status->currentStep = INIT_STEP_ASK_VER; + // set the Revo GPS port baud rate to the (same) user configured value + config_baud(hwsettings_baud); + status->lastConfigSent = LAST_CONFIG_SENT_START; + status->retryCount = 0; + // skip enabling UBX sentences for low baud rates + // low baud rates are not usable, and higher data rates just makes it harder for this code to change the configuration + if (hwsettings_baud <= HWSETTINGS_GPSSPEED_9600) { + set_current_step_if_untouched(INIT_STEP_SAVE); + } else { + set_current_step_if_untouched(INIT_STEP_ENABLE_SENTENCES); } - return; + // allow it enter the next state immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + break; case INIT_STEP_ENABLE_SENTENCES: case INIT_STEP_CONFIGURE: @@ -409,61 +786,136 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send, bool gps_connec enable_sentences(bytes_to_send); } - status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + // for some branches, allow it enter the next state immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); if (status->lastConfigSent == LAST_CONFIG_SENT_COMPLETED) { - status->lastConfigSent = LAST_CONFIG_SENT_START; - status->currentStep = step_configure ? INIT_STEP_DONE : INIT_STEP_CONFIGURE; + if (step_configure) { + // zero retries for the next state that needs it (INIT_STEP_SAVE) + status->retryCount = 0; + set_current_step_if_untouched(INIT_STEP_SAVE); + } else { + // finished enabling sentences, now configure() needs to start at the beginning + status->lastConfigSent = LAST_CONFIG_SENT_START; + set_current_step_if_untouched(INIT_STEP_CONFIGURE); + } } else { - status->currentStep = step_configure ? INIT_STEP_CONFIGURE_WAIT_ACK : INIT_STEP_ENABLE_SENTENCES_WAIT_ACK; + set_current_step_if_untouched(step_configure ? INIT_STEP_CONFIGURE_WAIT_ACK : INIT_STEP_ENABLE_SENTENCES_WAIT_ACK); + status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); } - return; + break; } + case INIT_STEP_ENABLE_SENTENCES_WAIT_ACK: case INIT_STEP_CONFIGURE_WAIT_ACK: // Wait for an ack from GPS { bool step_configure = (status->currentStep == INIT_STEP_CONFIGURE_WAIT_ACK); if (ubxLastAck.clsID == status->requiredAck.clsID && ubxLastAck.msgID == status->requiredAck.msgID) { // Continue with next configuration option + // start retries over for the next setting to be sent status->retryCount = 0; status->lastConfigSent++; - } else if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) > UBX_REPLY_TIMEOUT || - (ubxLastNak.clsID == status->requiredAck.clsID && ubxLastNak.msgID == status->requiredAck.msgID)) { + } else if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_REPLY_TIMEOUT && + (ubxLastNak.clsID != status->requiredAck.clsID || ubxLastNak.msgID != status->requiredAck.msgID)) { + // allow timeouts to count up by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + break; + } else { // timeout or NAK, resend the message or abort status->retryCount++; if (status->retryCount > UBX_MAX_RETRIES) { - status->currentStep = INIT_STEP_ERROR; + set_current_step_if_untouched(INIT_STEP_ERROR); status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); - return; + break; } } - // no abort condition, continue or retries., + // success or failure here, retries are handled elsewhere if (step_configure) { - status->currentStep = INIT_STEP_CONFIGURE; + set_current_step_if_untouched(INIT_STEP_CONFIGURE); } else { - status->currentStep = INIT_STEP_ENABLE_SENTENCES; + set_current_step_if_untouched(INIT_STEP_ENABLE_SENTENCES); } - return; + break; } + + case INIT_STEP_SAVE: + if (status->currentSettings.storeSettings) { + config_save(bytes_to_send); + set_current_step_if_untouched(INIT_STEP_SAVE_WAIT_ACK); + status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + } else { + set_current_step_if_untouched(INIT_STEP_DONE); + // allow it enter INIT_STEP_DONE immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + } + break; + + // we could remove this state + // if we retry, it writes to settings storage a few more times + // and it is probably the ack that was dropped, with the save actually performed correctly + case INIT_STEP_SAVE_WAIT_ACK: + if (ubxLastAck.clsID == status->requiredAck.clsID && ubxLastAck.msgID == status->requiredAck.msgID) { + // Continue with next configuration option + set_current_step_if_untouched(INIT_STEP_DONE); + // note that we increase the reply timeout in case the GPS must do a flash erase + } else if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_REPLY_TO_SAVE_TIMEOUT && + (ubxLastNak.clsID != status->requiredAck.clsID || ubxLastNak.msgID != status->requiredAck.msgID)) { + // allow timeouts to count up by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + break; + } else { + // timeout or NAK, resend the message or abort + status->retryCount++; + if (status->retryCount > UBX_MAX_RETRIES/2) { + // give up on the retries + set_current_step_if_untouched(INIT_STEP_ERROR); + status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + } else { + // retry a few times + set_current_step_if_untouched(INIT_STEP_SAVE); + } + } + break; + + case INIT_STEP_ERROR: + // on error we should get the GPS version immediately + ubx_reset_sensor_type(); + // fall through + case INIT_STEP_DISABLED: + case INIT_STEP_DONE: + break; } } -void ubx_autoconfig_set(ubx_autoconfig_settings_t config) + +void ubx_autoconfig_set(ubx_autoconfig_settings_t *config) { + initSteps_t new_step; + enabled = false; - if (config.autoconfigEnabled) { - if (!status) { - status = (status_t *)pios_malloc(sizeof(status_t)); - PIOS_Assert(status); - memset(status, 0, sizeof(status_t)); - status->currentStep = INIT_STEP_DISABLED; - } - status->currentSettings = config; - status->currentStep = INIT_STEP_START; + + if (!status) { + status = (status_t *)pios_malloc(sizeof(status_t)); + PIOS_Assert(status); + memset((status_t *)status, 0, sizeof(status_t)); + } + + // if caller used NULL, just use current settings to restart autoconfig process + if (config != NULL) { + status->currentSettings = *config; + } + if (status->currentSettings.autoconfigEnabled) { + new_step = INIT_STEP_START; + } else { + new_step = INIT_STEP_DISABLED; + } + + // assume this one byte initSteps_t is atomic + // take care of some but not all concurrency issues + + status->currentStep = new_step; + status->currentStepSave = new_step; + current_step_touched = true; + status->currentStep = new_step; + status->currentStepSave = new_step; + + if (status->currentSettings.autoconfigEnabled) { enabled = true; - } else { - if (status) { - status->currentStep = INIT_STEP_DISABLED; - } } } From f331ca0daf86b9b3a8e635dcadc58d23d9a7975c Mon Sep 17 00:00:00 2001 From: Cliff Geerdes Date: Thu, 30 Apr 2015 01:27:19 -0400 Subject: [PATCH 34/75] OP-1840 CC3D wouldn't build and update some comments --- flight/modules/GPS/GPS.c | 69 ++++++++++++++-------------------------- 1 file changed, 23 insertions(+), 46 deletions(-) diff --git a/flight/modules/GPS/GPS.c b/flight/modules/GPS/GPS.c index a7671e714..794fd30a4 100644 --- a/flight/modules/GPS/GPS.c +++ b/flight/modules/GPS/GPS.c @@ -244,27 +244,6 @@ MODULE_INITCALL(GPSInitialize, GPSStart); /** * Main gps task. It does not return. */ -enum pios_com_dev_magic { - PIOS_COM_DEV_MAGIC = 0xaa55aa55, -}; - -struct pios_com_dev { - enum pios_com_dev_magic magic; - uint32_t lower_id; - const struct pios_com_driver *driver; - -#if defined(PIOS_INCLUDE_FREERTOS) - xSemaphoreHandle tx_sem; - xSemaphoreHandle rx_sem; - xSemaphoreHandle sendbuffer_sem; -#endif - - bool has_rx; - bool has_tx; - - t_fifo_buffer rx; - t_fifo_buffer tx; -}; static void gpsTask(__attribute__((unused)) void *parameters) { @@ -472,11 +451,13 @@ static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) // no booting of Revo should be required during any setup or testing, just Send the settings you want to play with // with autoconfig enabled, just change the baud rate in HwSettings and it will change the GPS internal baud and then the Revo port // with autoconfig disabled, it will only change the Revo port, so you can try to find the current GPS baud rate if you don't know it + // GPSPositionSensor.SensorType and .UbxAutoConfigStatus now give correct values at all times, so use .SensorType to prove it is + // connected, even to an incorrectly configured (e.g. factory default) GPS // Use cases: // - the user can plug in a default GPS, use autoconfig-store once and then always use autoconfig-disabled // - the user can plug in a default GPS that can't store settings (defaults to 9600 baud) and always use autoconfig-nostore - // - - this is my main reason for coding this: cheap eBay GPS's that loose their settings sometimes + // - - this is one reason for coding this: cheap eBay GPS's that loose their settings sometimes // - the user can plug in a default GPS that _can_ store settings and always use autoconfig-nostore with that too // - - if settings change in newer releases of OP, this will make sure to use the correct settings with whatever code you are running // - the user can plug in a correctly configured GPS and use autoconfig-disabled @@ -496,45 +477,39 @@ static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) // - - just plug the default (9600 baud) GPS in to an unpowered Revo, power the Revo/GPS through the servo connector, wait some time, unplug // - - or with this code, OP could and even should just ship GPS's with default settings - // if we add an "initial baud rate" instead of assuming 9600 for autoconfig-nostore/store + // if we add an "initial baud rate" instead of assuming 9600 at boot up for autoconfig-nostore/store // - the user can use the same GPS with both an older release of OP (e.g. GPS settings at 38400) and the current release (autoconfig-nostore) - // - should the 57600 be fixed as part of autoconfig-store/nostore and the HwSettings.GPSSpeed be the initial baud rate? + // - the 57600 could be fixed instead of the 9600 as part of autoconfig-store/nostore and the HwSettings.GPSSpeed be the initial baud rate? // About using UBlox GPS's with default settings (9600 baud and NEMA data): // - the default uBlox settings (different than OP settings) are NEMA and 9600 baud // - - and that is OK and you use autoconfig-nostore // - - I personally feel that this is the best way to set it up because if OP dev changes GPS settings, // - - you get them automatically changed to match whatever version of OP code you are running - // - - but 9600 is only OK for startup and only if you NEVER enable and store (even once) OP messages (a lot more data) at 9600 - // - - using autoconfig-store just one time at 9600 will pretty much force you to use 57600 + // - - but 9600 is only OK for this autoconfig startup // - by my testing, the 9600 initial to 57600 final baud startup takes: - // - - 1:13 if the GPS has been configured to send OP data at 9600 - // - - 0:12 if the GPS has default data settings (NEMA) - // - - reminder that even 1:13 isn't that bad. You need to wait for the GPS to acquire satellites, - // - - and it does that the whole time it is being configured + // - - 0:10 if the GPS has been configured to send OP data at 9600 + // - - 0:06 if the GPS has default data settings (NEMA) at 9600 + // - - reminder that even 0:10 isn't that bad. You need to wait for the GPS to acquire satellites, - // Some things you want to know if you want to play around with this: - // - 57600 baud is what you want stored inside the GPS settings if you autoconfig-store it even once at any baud rate - // - - then use autoconfig-disabled once the GPS settings are stored in the GPS - // - don't play with low baud rates, with OP data settings (lots of data) at best it takes a long time to auto-configure - // - - at 19200 or lower it will fail to autoconfig and set the status to 'ERROR' - // - - at 19200 or lower the autoconfig is skipped and only the baud rate is changed - // - if you autoconfigure-store an OP configuration at 19200 baud or lower - // - - it will actually store a factory default configuration at that baud rate - // - - you will probably have to use u-center to fix it - // - - default settings (NEMA) at 9600 are OK because there is not nearly as much data as the OP config uses, + // Some things you want to think about if you want to play around with this: + // - don't play with low baud rates, with OP data settings (lots of data) it can take a long time to auto-configure + // - - at 2400 it could take a long time to autoconfig or error out + // - - at 9600 or lower the autoconfig is skipped and only the baud rate is changed + // - if you autoconfigure an OP configuration at 9600 baud or lower + // - - it will actually make a factory default configuration (not an OP configuration) at that baud rate // - remember that there are two baud rates (inside the GPS and the Revo port) and you can get them out of sync // - - rebooting the Revo from the Ground Control Station (without powering the GPS down too) - // - - can leave the baud rates out of sync if you are using autoconfig-nostore + // - - can leave the baud rates out of sync if you are using autoconfig // - - just power off and on both the Revo and the GPS + // - my OP GPS #2 will NOT save 115200 baud or higher, but it will use all bauds, even 230400 + // - - so you could use autoconfig.nostore with this high baud rate, but not autoconfig.store (once) followed by autoconfig.disabled + // - - I haven't tested other GPS's in regard to this - // my OP GPS #2 will NOT save 115200 baud or higher, but it will use all bauds, even 230400 - - // since 9600 baud and lower are not usable, and are best left at NEMA, I could / should / will code it to do a factory reset - // - if set to 9600 baud (or lower???) + // since 9600 baud and lower are not usable, and are best left at NEMA, I could have coded it to do a factory reset + // - if set to 9600 baud (or lower) if (gpsPort) { - // static uint8_t old_speed = HWSETTINGS_GPSSPEED_230400+1; uint8_t speed; #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) @@ -587,9 +562,11 @@ static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) PIOS_COM_ChangeBaud(gpsPort, 230400); break; } +#if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) // even changing the baud rate will make it re-verify the sensor type // that way the user can just try some baud rates and it when the sensor type is valid, the baud rate is correct ubx_reset_sensor_type(); +#endif } #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) else { From c365bd30329e336581d3d490283559445dbd2567 Mon Sep 17 00:00:00 2001 From: Cliff Geerdes Date: Fri, 1 May 2015 02:46:38 -0400 Subject: [PATCH 35/75] OP-1840 Removed unused debug .h and update comments --- flight/modules/GPS/GPS.c | 4 ++-- flight/modules/GPS/ubx_autoconfig.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/flight/modules/GPS/GPS.c b/flight/modules/GPS/GPS.c index 794fd30a4..cbd5ba2b4 100644 --- a/flight/modules/GPS/GPS.c +++ b/flight/modules/GPS/GPS.c @@ -50,7 +50,7 @@ #include "UBX.h" #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) #include "inc/ubx_autoconfig.h" -#include "../../libraries/inc/fifo_buffer.h" +//#include "../../libraries/inc/fifo_buffer.h" #endif #include @@ -535,7 +535,7 @@ static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) if (ev == NULL || gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED || gpsSettings.DataProtocol != GPSSETTINGS_DATAPROTOCOL_UBX) #endif { - // Set Revo port speed + // Set Revo / Nano port speed switch (speed) { case HWSETTINGS_GPSSPEED_2400: PIOS_COM_ChangeBaud(gpsPort, 2400); diff --git a/flight/modules/GPS/ubx_autoconfig.c b/flight/modules/GPS/ubx_autoconfig.c index 5fa036596..15f17f610 100644 --- a/flight/modules/GPS/ubx_autoconfig.c +++ b/flight/modules/GPS/ubx_autoconfig.c @@ -489,7 +489,7 @@ static void enable_sentences(__attribute__((unused)) uint16_t *bytes_to_send) // There are two baud rates of interest // The baud rate the GPS is talking at -// The baud rate Revo or CC/3D is talking at +// The baud rate Revo is talking at // These two must match for the GPS to work // You only have direct control of the Revo baud rate // The two baud rates must be the same for the Revo to send a command to the GPS @@ -547,7 +547,7 @@ static void enable_sentences(__attribute__((unused)) uint16_t *bytes_to_send) // Real time progress of the GPS detection process // Data Objects -> GPSPositionSensor -> AutoConfigStatus (DISABLED, RUNNING, DONE, ERROR) -// Syncing the baud rates means that the GPS's internal baud rate setting is the same as the Revo (or CC/3D) port setting +// Syncing the baud rates means that the GPS's internal baud rate setting is the same as the Revo port setting // This is necessary for the GPS to work with Revo // To sync to and find out an unknown GPS baud rate (or sync to and use a known GPS baud rate) // Temporarily change the AutoConfig mode to Disabled From dad8f40c4d72830b79c4447aa624f1d6a7c244b5 Mon Sep 17 00:00:00 2001 From: Cliff Geerdes Date: Fri, 1 May 2015 02:49:15 -0400 Subject: [PATCH 36/75] OP-1840 Remove reference to unreleased hardware --- flight/modules/GPS/GPS.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flight/modules/GPS/GPS.c b/flight/modules/GPS/GPS.c index cbd5ba2b4..438177f6f 100644 --- a/flight/modules/GPS/GPS.c +++ b/flight/modules/GPS/GPS.c @@ -535,7 +535,7 @@ static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) if (ev == NULL || gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED || gpsSettings.DataProtocol != GPSSETTINGS_DATAPROTOCOL_UBX) #endif { - // Set Revo / Nano port speed + // Set Revo port speed switch (speed) { case HWSETTINGS_GPSSPEED_2400: PIOS_COM_ChangeBaud(gpsPort, 2400); From 11e83bd0e807eaa06d74ae0661d74ff0d0aa0736 Mon Sep 17 00:00:00 2001 From: Laurent Lalanne Date: Fri, 1 May 2015 13:00:36 +0200 Subject: [PATCH 37/75] OP-1869 Analog Airspeed sensor : Allow scale (voltage divider), change alpha/LowPassFilter behavior --- flight/modules/Airspeed/baro_airspeed_mpxv.c | 7 ++++--- flight/pios/common/pios_mpxv.c | 4 ++-- flight/pios/inc/pios_mpxv.h | 1 + 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/flight/modules/Airspeed/baro_airspeed_mpxv.c b/flight/modules/Airspeed/baro_airspeed_mpxv.c index 086159e49..2869a5d12 100644 --- a/flight/modules/Airspeed/baro_airspeed_mpxv.c +++ b/flight/modules/Airspeed/baro_airspeed_mpxv.c @@ -46,7 +46,7 @@ #define CALIBRATION_IDLE_MS 2000 // Time to wait before calibrating, in [ms] #define CALIBRATION_COUNT_MS 2000 // Time to spend calibrating, in [ms] -#define ANALOG_BARO_AIRSPEED_TIME_CONSTANT_MS 100 // low pass filter +#define ANALOG_BARO_AIRSPEED_TIME_CONSTANT_MS 256 // low pass filter // Private types @@ -104,9 +104,10 @@ void baro_airspeedGetMPXV(AirspeedSensorData *airspeedSensor, AirspeedSettingsDa } } sensor.zeroPoint = airspeedSettings->ZeroPoint; + sensor.Scale = airspeedSettings->Scale; - // Filter CAS - float alpha = airspeedSettings->SamplePeriod / (airspeedSettings->SamplePeriod + ANALOG_BARO_AIRSPEED_TIME_CONSTANT_MS); // Low pass filter. + // Filter CAS : airspeedSettings->SamplePeriod value is 0 - 255 range + float alpha = 1 - (airspeedSettings->SamplePeriod / ANALOG_BARO_AIRSPEED_TIME_CONSTANT_MS); // Low pass filter. airspeedSensor->CalibratedAirspeed = PIOS_MPXV_CalcAirspeed(&sensor, airspeedSensor->SensorValue) * (alpha) + airspeedSensor->CalibratedAirspeed * (1.0f - alpha); airspeedSensor->SensorConnected = AIRSPEEDSENSOR_SENSORCONNECTED_TRUE; diff --git a/flight/pios/common/pios_mpxv.c b/flight/pios/common/pios_mpxv.c index 4e6e3ce82..9c9c88aa1 100644 --- a/flight/pios/common/pios_mpxv.c +++ b/flight/pios/common/pios_mpxv.c @@ -68,8 +68,8 @@ uint16_t PIOS_MPXV_Calibrate(PIOS_MPXV_descriptor *desc, uint16_t measurement) */ float PIOS_MPXV_CalcAirspeed(PIOS_MPXV_descriptor *desc, uint16_t measurement) { - // Calculate dynamic pressure, as per docs - float Qc = 3.3f / 4096.0f * (float)(measurement - desc->zeroPoint); + // Calculate dynamic pressure, as per docs - Apply scale factor (voltage divider) + float Qc = 3.3f / 4096.0f * (float)((measurement - desc->zeroPoint) * desc->Scale); // Saturate Qc on the lower bound, in order to make sure we don't have negative airspeeds. No need // to saturate on the upper bound, we'll handle that later with calibratedAirspeed. diff --git a/flight/pios/inc/pios_mpxv.h b/flight/pios/inc/pios_mpxv.h index 6b60eacdf..f68b1f386 100644 --- a/flight/pios/inc/pios_mpxv.h +++ b/flight/pios/inc/pios_mpxv.h @@ -38,6 +38,7 @@ typedef struct { uint16_t calibrationCount; uint32_t calibrationSum; uint16_t zeroPoint; + float Scale; float maxSpeed; } PIOS_MPXV_descriptor; From b479bd54367c408fc529432c1172843128611b9c Mon Sep 17 00:00:00 2001 From: abeck70 Date: Sat, 2 May 2015 23:57:18 +1000 Subject: [PATCH 38/75] OP-1848 altvario TxPID support --- flight/modules/Stabilization/altitudeloop.cpp | 1 - flight/modules/TxPID/txpid.c | 132 +++++++++++------- shared/uavobjectdefinition/txpidsettings.xml | 2 +- 3 files changed, 79 insertions(+), 56 deletions(-) diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index 5b6b2d3ef..d1b115454 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -185,7 +185,6 @@ static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) // initialise limits on thrust but note the FSM can override. controlDown.SetThrustLimits(altitudeHoldSettings.ThrustLimits.Min, altitudeHoldSettings.ThrustLimits.Max); - } diff --git a/flight/modules/TxPID/txpid.c b/flight/modules/TxPID/txpid.c index c4e94fbc8..8cd8c0d08 100644 --- a/flight/modules/TxPID/txpid.c +++ b/flight/modules/TxPID/txpid.c @@ -55,6 +55,7 @@ #include "accessorydesired.h" #include "manualcontrolcommand.h" #include "stabilizationsettings.h" +#include "altitudeholdsettings.h" #include "stabilizationbank.h" #include "stabilizationsettingsbank1.h" #include "stabilizationsettingsbank2.h" @@ -95,6 +96,8 @@ int32_t TxPIDInitialize(void) bool txPIDEnabled; HwSettingsOptionalModulesData optionalModules; + AltitudeHoldSettingsInitialize(); + HwSettingsInitialize(); HwSettingsOptionalModulesGet(&optionalModules); @@ -188,10 +191,13 @@ static void updatePIDs(UAVObjEvent *ev) } StabilizationSettingsData stab; StabilizationSettingsGet(&stab); + AltitudeHoldSettingsData altitude; + AltitudeHoldSettingsGet(&altitude); AccessoryDesiredData accessory; - uint8_t needsUpdateBank = 0; - uint8_t needsUpdateStab = 0; + uint8_t needsUpdateBank = 0; + uint8_t needsUpdateStab = 0; + uint8_t needsUpdateAltitude = 0; // Loop through every enabled instance for (uint8_t i = 0; i < TXPIDSETTINGS_PIDS_NUMELEM; i++) { @@ -216,140 +222,155 @@ static void updatePIDs(UAVObjEvent *ev) switch (TxPIDSettingsPIDsToArray(inst.PIDs)[i]) { case TXPIDSETTINGS_PIDS_ROLLRATEKP: - needsUpdateBank |= update(&bank.RollRatePID.Kp, value); + needsUpdateBank |= update(&bank.RollRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLRATEKI: - needsUpdateBank |= update(&bank.RollRatePID.Ki, value); + needsUpdateBank |= update(&bank.RollRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLRATEKD: - needsUpdateBank |= update(&bank.RollRatePID.Kd, value); + needsUpdateBank |= update(&bank.RollRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_ROLLRATEILIMIT: - needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); + needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Roll, value); + needsUpdateBank |= update(&bank.ManualRate.Roll, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDEKP: - needsUpdateBank |= update(&bank.RollPI.Kp, value); + needsUpdateBank |= update(&bank.RollPI.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDEKI: - needsUpdateBank |= update(&bank.RollPI.Ki, value); + needsUpdateBank |= update(&bank.RollPI.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDEILIMIT: - needsUpdateBank |= update(&bank.RollPI.ILimit, value); + needsUpdateBank |= update(&bank.RollPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.RollMax, value); + needsUpdateBank |= updateUint8(&bank.RollMax, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEKP: - needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEKI: - needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); + needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEKD: - needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEILIMIT: - needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); + needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_PITCHRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Pitch, value); + needsUpdateBank |= update(&bank.ManualRate.Pitch, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDEKP: - needsUpdateBank |= update(&bank.PitchPI.Kp, value); + needsUpdateBank |= update(&bank.PitchPI.Kp, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDEKI: - needsUpdateBank |= update(&bank.PitchPI.Ki, value); + needsUpdateBank |= update(&bank.PitchPI.Ki, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDEILIMIT: - needsUpdateBank |= update(&bank.PitchPI.ILimit, value); + needsUpdateBank |= update(&bank.PitchPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.PitchMax, value); + needsUpdateBank |= updateUint8(&bank.PitchMax, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKP: - needsUpdateBank |= update(&bank.RollRatePID.Kp, value); - needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); + needsUpdateBank |= update(&bank.RollRatePID.Kp, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKI: - needsUpdateBank |= update(&bank.RollRatePID.Ki, value); - needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); + needsUpdateBank |= update(&bank.RollRatePID.Ki, value); + needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKD: - needsUpdateBank |= update(&bank.RollRatePID.Kd, value); - needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); + needsUpdateBank |= update(&bank.RollRatePID.Kd, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEILIMIT: - needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); - needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); + needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); + needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Roll, value); - needsUpdateBank |= update(&bank.ManualRate.Pitch, value); + needsUpdateBank |= update(&bank.ManualRate.Roll, value); + needsUpdateBank |= update(&bank.ManualRate.Pitch, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEKP: - needsUpdateBank |= update(&bank.RollPI.Kp, value); - needsUpdateBank |= update(&bank.PitchPI.Kp, value); + needsUpdateBank |= update(&bank.RollPI.Kp, value); + needsUpdateBank |= update(&bank.PitchPI.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEKI: - needsUpdateBank |= update(&bank.RollPI.Ki, value); - needsUpdateBank |= update(&bank.PitchPI.Ki, value); + needsUpdateBank |= update(&bank.RollPI.Ki, value); + needsUpdateBank |= update(&bank.PitchPI.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEILIMIT: - needsUpdateBank |= update(&bank.RollPI.ILimit, value); - needsUpdateBank |= update(&bank.PitchPI.ILimit, value); + needsUpdateBank |= update(&bank.RollPI.ILimit, value); + needsUpdateBank |= update(&bank.PitchPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.RollMax, value); - needsUpdateBank |= updateUint8(&bank.PitchMax, value); + needsUpdateBank |= updateUint8(&bank.RollMax, value); + needsUpdateBank |= updateUint8(&bank.PitchMax, value); break; case TXPIDSETTINGS_PIDS_YAWRATEKP: - needsUpdateBank |= update(&bank.YawRatePID.Kp, value); + needsUpdateBank |= update(&bank.YawRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_YAWRATEKI: - needsUpdateBank |= update(&bank.YawRatePID.Ki, value); + needsUpdateBank |= update(&bank.YawRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_YAWRATEKD: - needsUpdateBank |= update(&bank.YawRatePID.Kd, value); + needsUpdateBank |= update(&bank.YawRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_YAWRATEILIMIT: - needsUpdateBank |= update(&bank.YawRatePID.ILimit, value); + needsUpdateBank |= update(&bank.YawRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_YAWRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Yaw, value); + needsUpdateBank |= update(&bank.ManualRate.Yaw, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDEKP: - needsUpdateBank |= update(&bank.YawPI.Kp, value); + needsUpdateBank |= update(&bank.YawPI.Kp, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDEKI: - needsUpdateBank |= update(&bank.YawPI.Ki, value); + needsUpdateBank |= update(&bank.YawPI.Ki, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDEILIMIT: - needsUpdateBank |= update(&bank.YawPI.ILimit, value); + needsUpdateBank |= update(&bank.YawPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.YawMax, value); + needsUpdateBank |= updateUint8(&bank.YawMax, value); break; case TXPIDSETTINGS_PIDS_ROLLEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); break; case TXPIDSETTINGS_PIDS_PITCHEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); - needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); break; case TXPIDSETTINGS_PIDS_YAWEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Yaw, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Yaw, value); break; case TXPIDSETTINGS_PIDS_GYROTAU: - needsUpdateStab |= update(&stab.GyroTau, value); + needsUpdateStab |= update(&stab.GyroTau, value); break; case TXPIDSETTINGS_PIDS_ACROPLUSFACTOR: - needsUpdateBank |= update(&bank.AcroInsanityFactor, value); + needsUpdateBank |= update(&bank.AcroInsanityFactor, value); + break; + case TXPIDSETTINGS_PIDS_ALTITUDEPOSKP: + needsUpdateAltitude |= update(&altitude.VerticalPosP, value); + break; + case TXPIDSETTINGS_PIDS_ALTITUDEVELOCITYKP: + needsUpdateAltitude |= update(&altitude.VerticalVelPID.Kp, value); + break; + case TXPIDSETTINGS_PIDS_ALTITUDEVELOCITYKI: + needsUpdateAltitude |= update(&altitude.VerticalVelPID.Ki, value); + break; + case TXPIDSETTINGS_PIDS_ALTITUDEVELOCITYKD: + needsUpdateAltitude |= update(&altitude.VerticalVelPID.Kd, value); + break; + case TXPIDSETTINGS_PIDS_ALTITUDEVELOCITYBETA: + needsUpdateAltitude |= update(&altitude.VerticalVelPID.Beta, value); break; default: PIOS_Assert(0); @@ -359,6 +380,9 @@ static void updatePIDs(UAVObjEvent *ev) if (needsUpdateStab) { StabilizationSettingsSet(&stab); } + if (needsUpdateAltitude) { + AltitudeHoldSettingsSet(&altitude); + } if (needsUpdateBank) { switch (inst.BankNumber) { case 0: diff --git a/shared/uavobjectdefinition/txpidsettings.xml b/shared/uavobjectdefinition/txpidsettings.xml index 28035452b..e63cf5c4c 100644 --- a/shared/uavobjectdefinition/txpidsettings.xml +++ b/shared/uavobjectdefinition/txpidsettings.xml @@ -20,7 +20,7 @@ Roll+Pitch Attitude.Kp, Roll+Pitch Attitude.Ki, Roll+Pitch Attitude.ILimit, Roll+Pitch Attitude.Resp, Yaw Attitude.Kp, Yaw Attitude.Ki, Yaw Attitude.ILimit, Yaw Attitude.Resp, Roll.Expo, Pitch.Expo, Roll+Pitch.Expo, Yaw.Expo, - GyroTau,AcroPlusFactor" + GyroTau,AcroPlusFactor, Altitude Pos.Kp, Altitude Velocity.Kp, Altitude Velocity.Ki, Altitude Velocity.Kd, Altitude Velocity.Beta" defaultvalue="Disabled"/> From 00aae3c5a31809ef1f64143a9ddb5d3f853de67a Mon Sep 17 00:00:00 2001 From: abeck70 Date: Mon, 4 May 2015 08:50:44 +1000 Subject: [PATCH 39/75] OP-1847 altvario update of tuning parameters for piddown control --- shared/uavobjectdefinition/altitudeholdsettings.xml | 2 +- shared/uavobjectdefinition/vtolpathfollowersettings.xml | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/shared/uavobjectdefinition/altitudeholdsettings.xml b/shared/uavobjectdefinition/altitudeholdsettings.xml index f0a171b4b..1763d5568 100644 --- a/shared/uavobjectdefinition/altitudeholdsettings.xml +++ b/shared/uavobjectdefinition/altitudeholdsettings.xml @@ -6,7 +6,7 @@ - + diff --git a/shared/uavobjectdefinition/vtolpathfollowersettings.xml b/shared/uavobjectdefinition/vtolpathfollowersettings.xml index c98ad4254..86eea36bc 100644 --- a/shared/uavobjectdefinition/vtolpathfollowersettings.xml +++ b/shared/uavobjectdefinition/vtolpathfollowersettings.xml @@ -23,8 +23,8 @@ - - + + From c3c80d4aa848ab7c4bef6a6f973576a1a87695bf Mon Sep 17 00:00:00 2001 From: abeck70 Date: Mon, 4 May 2015 08:58:07 +1000 Subject: [PATCH 40/75] OP-1848 altvario fix build issue for CC --- flight/modules/TxPID/txpid.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/flight/modules/TxPID/txpid.c b/flight/modules/TxPID/txpid.c index 8cd8c0d08..6bfa0410a 100644 --- a/flight/modules/TxPID/txpid.c +++ b/flight/modules/TxPID/txpid.c @@ -55,7 +55,9 @@ #include "accessorydesired.h" #include "manualcontrolcommand.h" #include "stabilizationsettings.h" +#ifdef REVOLUTION #include "altitudeholdsettings.h" +#endif #include "stabilizationbank.h" #include "stabilizationsettingsbank1.h" #include "stabilizationsettingsbank2.h" @@ -96,7 +98,9 @@ int32_t TxPIDInitialize(void) bool txPIDEnabled; HwSettingsOptionalModulesData optionalModules; +#ifdef REVOLUTION AltitudeHoldSettingsInitialize(); +#endif HwSettingsInitialize(); HwSettingsOptionalModulesGet(&optionalModules); @@ -191,13 +195,17 @@ static void updatePIDs(UAVObjEvent *ev) } StabilizationSettingsData stab; StabilizationSettingsGet(&stab); +#ifdef REVOLUTION AltitudeHoldSettingsData altitude; AltitudeHoldSettingsGet(&altitude); +#endif AccessoryDesiredData accessory; uint8_t needsUpdateBank = 0; uint8_t needsUpdateStab = 0; +#ifdef REVOLUTION uint8_t needsUpdateAltitude = 0; +#endif // Loop through every enabled instance for (uint8_t i = 0; i < TXPIDSETTINGS_PIDS_NUMELEM; i++) { @@ -357,6 +365,7 @@ static void updatePIDs(UAVObjEvent *ev) case TXPIDSETTINGS_PIDS_ACROPLUSFACTOR: needsUpdateBank |= update(&bank.AcroInsanityFactor, value); break; +#ifdef REVOLUTION case TXPIDSETTINGS_PIDS_ALTITUDEPOSKP: needsUpdateAltitude |= update(&altitude.VerticalPosP, value); break; @@ -372,6 +381,7 @@ static void updatePIDs(UAVObjEvent *ev) case TXPIDSETTINGS_PIDS_ALTITUDEVELOCITYBETA: needsUpdateAltitude |= update(&altitude.VerticalVelPID.Beta, value); break; +#endif default: PIOS_Assert(0); } @@ -380,9 +390,11 @@ static void updatePIDs(UAVObjEvent *ev) if (needsUpdateStab) { StabilizationSettingsSet(&stab); } +#ifdef REVOLUTION if (needsUpdateAltitude) { AltitudeHoldSettingsSet(&altitude); } +#endif if (needsUpdateBank) { switch (inst.BankNumber) { case 0: From 43d193cceb277c7db382f633bd044fa20b9c93a9 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 5 May 2015 21:48:04 +1000 Subject: [PATCH 41/75] OP-1848 altvario merge fixes with ratetrainer --- flight/modules/Stabilization/outerloop.c | 20 +---- flight/modules/TxPID/txpid.c | 104 +++++++++++------------ 2 files changed, 53 insertions(+), 71 deletions(-) diff --git a/flight/modules/Stabilization/outerloop.c b/flight/modules/Stabilization/outerloop.c index d82be201d..305812171 100644 --- a/flight/modules/Stabilization/outerloop.c +++ b/flight/modules/Stabilization/outerloop.c @@ -117,6 +117,7 @@ static void stabilizationOuterloopTask() break; #endif /* REVOLUTION */ case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: + case STABILIZATIONSTATUS_OUTERLOOP_DIRECTWITHLIMITS: default: rateDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = stabilizationDesiredAxis[STABILIZATIONSTATUS_OUTERLOOP_THRUST]; break; @@ -259,10 +260,6 @@ static void stabilizationOuterloopTask() rateDesiredAxis[t] = rate_input + weak_leveling; } break; - case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: - default: - rateDesiredAxis[t] = stabilizationDesiredAxis[t]; - break; case STABILIZATIONSTATUS_OUTERLOOP_DIRECTWITHLIMITS: rateDesiredAxis[t] = stabilizationDesiredAxis[t]; // default for all axes // now test limits for pitch and/or roll @@ -297,21 +294,6 @@ static void stabilizationOuterloopTask() } break; - case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: - default: - rateDesiredAxis[t] = stabilizationDesiredAxis[t]; - break; - } - } else { - switch (StabilizationStatusOuterLoopToArray(enabled)[t]) { -#ifdef REVOLUTION - case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE: - rateDesiredAxis[t] = stabilizationAltitudeHold(stabilizationDesiredAxis[t], ALTITUDEHOLD, reinit); - break; - case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDEVARIO: - rateDesiredAxis[t] = stabilizationAltitudeHold(stabilizationDesiredAxis[t], ALTITUDEVARIO, reinit); - break; -#endif /* REVOLUTION */ case STABILIZATIONSTATUS_OUTERLOOP_DIRECT: default: rateDesiredAxis[t] = stabilizationDesiredAxis[t]; diff --git a/flight/modules/TxPID/txpid.c b/flight/modules/TxPID/txpid.c index 6bfa0410a..7b6b7b2ee 100644 --- a/flight/modules/TxPID/txpid.c +++ b/flight/modules/TxPID/txpid.c @@ -230,140 +230,140 @@ static void updatePIDs(UAVObjEvent *ev) switch (TxPIDSettingsPIDsToArray(inst.PIDs)[i]) { case TXPIDSETTINGS_PIDS_ROLLRATEKP: - needsUpdateBank |= update(&bank.RollRatePID.Kp, value); + needsUpdateBank |= update(&bank.RollRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLRATEKI: - needsUpdateBank |= update(&bank.RollRatePID.Ki, value); + needsUpdateBank |= update(&bank.RollRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLRATEKD: - needsUpdateBank |= update(&bank.RollRatePID.Kd, value); + needsUpdateBank |= update(&bank.RollRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_ROLLRATEILIMIT: - needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); + needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Roll, value); + needsUpdateBank |= update(&bank.ManualRate.Roll, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDEKP: - needsUpdateBank |= update(&bank.RollPI.Kp, value); + needsUpdateBank |= update(&bank.RollPI.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDEKI: - needsUpdateBank |= update(&bank.RollPI.Ki, value); + needsUpdateBank |= update(&bank.RollPI.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDEILIMIT: - needsUpdateBank |= update(&bank.RollPI.ILimit, value); + needsUpdateBank |= update(&bank.RollPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.RollMax, value); + needsUpdateBank |= updateUint8(&bank.RollMax, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEKP: - needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEKI: - needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); + needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEKD: - needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_PITCHRATEILIMIT: - needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); + needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_PITCHRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Pitch, value); + needsUpdateBank |= update(&bank.ManualRate.Pitch, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDEKP: - needsUpdateBank |= update(&bank.PitchPI.Kp, value); + needsUpdateBank |= update(&bank.PitchPI.Kp, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDEKI: - needsUpdateBank |= update(&bank.PitchPI.Ki, value); + needsUpdateBank |= update(&bank.PitchPI.Ki, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDEILIMIT: - needsUpdateBank |= update(&bank.PitchPI.ILimit, value); + needsUpdateBank |= update(&bank.PitchPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_PITCHATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.PitchMax, value); + needsUpdateBank |= updateUint8(&bank.PitchMax, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKP: - needsUpdateBank |= update(&bank.RollRatePID.Kp, value); - needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); + needsUpdateBank |= update(&bank.RollRatePID.Kp, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKI: - needsUpdateBank |= update(&bank.RollRatePID.Ki, value); - needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); + needsUpdateBank |= update(&bank.RollRatePID.Ki, value); + needsUpdateBank |= update(&bank.PitchRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKD: - needsUpdateBank |= update(&bank.RollRatePID.Kd, value); - needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); + needsUpdateBank |= update(&bank.RollRatePID.Kd, value); + needsUpdateBank |= update(&bank.PitchRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATEILIMIT: - needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); - needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); + needsUpdateBank |= update(&bank.RollRatePID.ILimit, value); + needsUpdateBank |= update(&bank.PitchRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Roll, value); - needsUpdateBank |= update(&bank.ManualRate.Pitch, value); + needsUpdateBank |= update(&bank.ManualRate.Roll, value); + needsUpdateBank |= update(&bank.ManualRate.Pitch, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEKP: - needsUpdateBank |= update(&bank.RollPI.Kp, value); - needsUpdateBank |= update(&bank.PitchPI.Kp, value); + needsUpdateBank |= update(&bank.RollPI.Kp, value); + needsUpdateBank |= update(&bank.PitchPI.Kp, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEKI: - needsUpdateBank |= update(&bank.RollPI.Ki, value); - needsUpdateBank |= update(&bank.PitchPI.Ki, value); + needsUpdateBank |= update(&bank.RollPI.Ki, value); + needsUpdateBank |= update(&bank.PitchPI.Ki, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEILIMIT: - needsUpdateBank |= update(&bank.RollPI.ILimit, value); - needsUpdateBank |= update(&bank.PitchPI.ILimit, value); + needsUpdateBank |= update(&bank.RollPI.ILimit, value); + needsUpdateBank |= update(&bank.PitchPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.RollMax, value); - needsUpdateBank |= updateUint8(&bank.PitchMax, value); + needsUpdateBank |= updateUint8(&bank.RollMax, value); + needsUpdateBank |= updateUint8(&bank.PitchMax, value); break; case TXPIDSETTINGS_PIDS_YAWRATEKP: - needsUpdateBank |= update(&bank.YawRatePID.Kp, value); + needsUpdateBank |= update(&bank.YawRatePID.Kp, value); break; case TXPIDSETTINGS_PIDS_YAWRATEKI: - needsUpdateBank |= update(&bank.YawRatePID.Ki, value); + needsUpdateBank |= update(&bank.YawRatePID.Ki, value); break; case TXPIDSETTINGS_PIDS_YAWRATEKD: - needsUpdateBank |= update(&bank.YawRatePID.Kd, value); + needsUpdateBank |= update(&bank.YawRatePID.Kd, value); break; case TXPIDSETTINGS_PIDS_YAWRATEILIMIT: - needsUpdateBank |= update(&bank.YawRatePID.ILimit, value); + needsUpdateBank |= update(&bank.YawRatePID.ILimit, value); break; case TXPIDSETTINGS_PIDS_YAWRATERESP: - needsUpdateBank |= update(&bank.ManualRate.Yaw, value); + needsUpdateBank |= update(&bank.ManualRate.Yaw, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDEKP: - needsUpdateBank |= update(&bank.YawPI.Kp, value); + needsUpdateBank |= update(&bank.YawPI.Kp, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDEKI: - needsUpdateBank |= update(&bank.YawPI.Ki, value); + needsUpdateBank |= update(&bank.YawPI.Ki, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDEILIMIT: - needsUpdateBank |= update(&bank.YawPI.ILimit, value); + needsUpdateBank |= update(&bank.YawPI.ILimit, value); break; case TXPIDSETTINGS_PIDS_YAWATTITUDERESP: - needsUpdateBank |= updateUint8(&bank.YawMax, value); + needsUpdateBank |= updateUint8(&bank.YawMax, value); break; case TXPIDSETTINGS_PIDS_ROLLEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); break; case TXPIDSETTINGS_PIDS_PITCHEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); break; case TXPIDSETTINGS_PIDS_ROLLPITCHEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); - needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Roll, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Pitch, value); break; case TXPIDSETTINGS_PIDS_YAWEXPO: - needsUpdateBank |= updateInt8(&bank.StickExpo.Yaw, value); + needsUpdateBank |= updateInt8(&bank.StickExpo.Yaw, value); break; case TXPIDSETTINGS_PIDS_GYROTAU: - needsUpdateStab |= update(&stab.GyroTau, value); + needsUpdateStab |= update(&stab.GyroTau, value); break; case TXPIDSETTINGS_PIDS_ACROPLUSFACTOR: - needsUpdateBank |= update(&bank.AcroInsanityFactor, value); + needsUpdateBank |= update(&bank.AcroInsanityFactor, value); break; #ifdef REVOLUTION case TXPIDSETTINGS_PIDS_ALTITUDEPOSKP: From dd1c6c76001e85f5b7ed72ad199cc6432f48556e Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 5 May 2015 21:52:04 +1000 Subject: [PATCH 42/75] OP-1848 build fixes after merge with ratetrainer --- flight/modules/Stabilization/outerloop.c | 29 ++++++++++++------------ 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/flight/modules/Stabilization/outerloop.c b/flight/modules/Stabilization/outerloop.c index 305812171..923018004 100644 --- a/flight/modules/Stabilization/outerloop.c +++ b/flight/modules/Stabilization/outerloop.c @@ -300,26 +300,25 @@ static void stabilizationOuterloopTask() break; } } -} -RateDesiredSet(&rateDesired); -{ - FlightStatusArmedOptions armed; - FlightStatusArmedGet(&armed); - float throttleDesired; - ManualControlCommandThrottleGet(&throttleDesired); - if (armed != FLIGHTSTATUS_ARMED_ARMED || - ((stabSettings.settings.LowThrottleZeroIntegral == STABILIZATIONSETTINGS_LOWTHROTTLEZEROINTEGRAL_TRUE) && throttleDesired < 0)) { - // Force all axes to reinitialize when engaged - for (t = 0; t < AXES; t++) { - previous_mode[t] = 255; + RateDesiredSet(&rateDesired); + { + FlightStatusArmedOptions armed; + FlightStatusArmedGet(&armed); + float throttleDesired; + ManualControlCommandThrottleGet(&throttleDesired); + if (armed != FLIGHTSTATUS_ARMED_ARMED || + ((stabSettings.settings.LowThrottleZeroIntegral == STABILIZATIONSETTINGS_LOWTHROTTLEZEROINTEGRAL_TRUE) && throttleDesired < 0)) { + // Force all axes to reinitialize when engaged + for (t = 0; t < AXES; t++) { + previous_mode[t] = 255; + } } } -} // update cruisecontrol based on attitude -cruisecontrol_compute_factor(&attitudeState, rateDesired.Thrust); -stabSettings.monitor.rateupdates = 0; + cruisecontrol_compute_factor(&attitudeState, rateDesired.Thrust); + stabSettings.monitor.rateupdates = 0; } From 48f3922a8d58ff725624cfaa1956af623236a582 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 5 May 2015 22:14:18 +1000 Subject: [PATCH 43/75] OP-1848 altvario fix default stab page --- ground/openpilotgcs/src/plugins/config/stabilization.ui | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index f13ea2f4c..c4f1812fd 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -95,7 +95,7 @@ QTabWidget::Rounded - 3 + 0 false @@ -8244,7 +8244,7 @@ border-radius: 5; 0 0 - 950 + 884 736 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 950 - 671 + 839 + 670 From 0c77d8a21d580f01a68dc0522e8e4f4d2e79ab0b Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 5 May 2015 22:39:15 +1000 Subject: [PATCH 44/75] OP-1848 altvario Speed up velocity control loop to original speed --- flight/modules/Stabilization/altitudeloop.cpp | 23 ++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index d1b115454..7b1aa8bed 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -60,6 +60,7 @@ extern "C" { // Private types // Private variables +static DelayedCallbackInfo *altitudeHoldCBInfo; static PIDControlDown controlDown; static AltitudeHoldSettingsData altitudeHoldSettings; static ThrustModeType thrustMode; @@ -68,6 +69,8 @@ static float thrustDemand = 0.0f; // Private functions static void SettingsUpdatedCb(UAVObjEvent *ev); +static void altitudeHoldTask(void); +static void VelocityStateUpdatedCb(UAVObjEvent *ev); /** * Setup mode and setpoint @@ -113,7 +116,17 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit newaltitude = false; } + return thrustDemand; +} + + +/** + * Module thread, should not return. + */ +static void altitudeHoldTask(void) +{ AltitudeHoldStatusData altitudeHoldStatus; + AltitudeHoldStatusGet(&altitudeHoldStatus); float velocityStateDown; @@ -129,8 +142,6 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit controlDown.ControlPosition(); altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); thrustDemand = controlDown.GetDownCommand(); - - // if thrust demand is high and we are below altitude by 2m, back off pitch } break; @@ -145,8 +156,11 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit } AltitudeHoldStatusSet(&altitudeHoldStatus); +} - return thrustDemand; +static void VelocityStateUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) +{ + PIOS_CALLBACKSCHEDULER_Dispatch(altitudeHoldCBInfo); } /** @@ -163,6 +177,9 @@ void stabilizationAltitudeloopInit() AltitudeHoldSettingsConnectCallback(&SettingsUpdatedCb); VtolSelfTuningStatsConnectCallback(&SettingsUpdatedCb); SettingsUpdatedCb(NULL); + + altitudeHoldCBInfo = PIOS_CALLBACKSCHEDULER_Create(&altitudeHoldTask, CALLBACK_PRIORITY, CBTASK_PRIORITY, CALLBACKINFO_RUNNING_ALTITUDEHOLD, STACK_SIZE_BYTES); + VelocityStateConnectCallback(&VelocityStateUpdatedCb); } From 593cf18c5c0ec26f2e3659fa6e475405585d0573 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 5 May 2015 22:49:39 +1000 Subject: [PATCH 45/75] OP-1848 altvario Update dT to speed on sensor update rate --- flight/modules/Stabilization/altitudeloop.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index 7b1aa8bed..4c406f868 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -191,7 +191,7 @@ static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) altitudeHoldSettings.VerticalVelPID.Ki, altitudeHoldSettings.VerticalVelPID.Kd, altitudeHoldSettings.VerticalVelPID.Beta, - (float)(OUTERLOOP_SKIPCOUNT * UPDATE_EXPECTED), + (float)(UPDATE_EXPECTED), altitudeHoldSettings.ThrustRate); controlDown.UpdatePositionalParameters(altitudeHoldSettings.VerticalPosP); From 193911ba20725259d2410c2d5251ecfe4348d233 Mon Sep 17 00:00:00 2001 From: Cliff Geerdes Date: Tue, 5 May 2015 23:26:08 -0400 Subject: [PATCH 46/75] OP-1840 another merge conflict --- flight/modules/GPS/GPS.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/flight/modules/GPS/GPS.c b/flight/modules/GPS/GPS.c index e2e2ee8be..a0a12b4c3 100644 --- a/flight/modules/GPS/GPS.c +++ b/flight/modules/GPS/GPS.c @@ -157,10 +157,6 @@ int32_t GPSStart(void) int32_t GPSInitialize(void) { gpsPort = PIOS_COM_GPS; -<<<<<<< HEAD -======= - GPSSettingsDataProtocolOptions gpsProtocol; ->>>>>>> next HwSettingsInitialize(); #ifdef MODULE_GPS_BUILTIN From 8689b2d0caab34124617b8bf82596530be9b95ba Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 8 May 2015 07:38:12 +0100 Subject: [PATCH 47/75] OP-1803 Don't report error codes as % --- flight/modules/Receiver/receiver.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/flight/modules/Receiver/receiver.c b/flight/modules/Receiver/receiver.c index da26c23be..16f1c95d5 100644 --- a/flight/modules/Receiver/receiver.c +++ b/flight/modules/Receiver/receiver.c @@ -653,14 +653,19 @@ static bool updateRcvrStatus( { extern uint32_t pios_rcvr_group_map[]; bool activity_updated = false; - uint8_t quality; + int8_t quality; quality = PIOS_RCVR_GetQuality(pios_rcvr_group_map[group]); + /* If no driver is detected or any other error then return */ + if (quality < 0) { + return activity_updated; + } + /* Compare with previous sample */ if (quality != fsm->quality) { fsm->quality = quality; - ReceiverStatusQualitySet(&quality); + ReceiverStatusQualitySet(&fsm->quality); activity_updated = true; } From 023f157ba89748472b854f685336a1366ae2f1a9 Mon Sep 17 00:00:00 2001 From: Steve Evans Date: Fri, 8 May 2015 07:42:32 +0100 Subject: [PATCH 48/75] OP-1803 Disable untested DSM link quality code --- flight/pios/stm32f10x/pios_dsm.c | 2 +- flight/pios/stm32f4xx/pios_dsm.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/flight/pios/stm32f10x/pios_dsm.c b/flight/pios/stm32f10x/pios_dsm.c index a058ee9c2..44fa484be 100644 --- a/flight/pios/stm32f10x/pios_dsm.c +++ b/flight/pios/stm32f10x/pios_dsm.c @@ -35,7 +35,7 @@ #include "pios_dsm_priv.h" // *** UNTESTED CODE *** -#define DSM_LINK_QUALITY +#undef DSM_LINK_QUALITY /* Forward Declarations */ static int32_t PIOS_DSM_Get(uint32_t rcvr_id, uint8_t channel); diff --git a/flight/pios/stm32f4xx/pios_dsm.c b/flight/pios/stm32f4xx/pios_dsm.c index 764bc231b..bdd8244e1 100644 --- a/flight/pios/stm32f4xx/pios_dsm.c +++ b/flight/pios/stm32f4xx/pios_dsm.c @@ -35,7 +35,7 @@ #include "pios_dsm_priv.h" // *** UNTESTED CODE *** -#define DSM_LINK_QUALITY +#undef DSM_LINK_QUALITY #ifndef PIOS_INCLUDE_RTC #error PIOS_INCLUDE_RTC must be used to use DSM From 829a9c5663ff40b377ef114fc61aedfca7f8cad5 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Sat, 9 May 2015 14:42:26 +1000 Subject: [PATCH 49/75] OP-1848 altvario code review comment --- shared/uavobjectdefinition/txpidsettings.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shared/uavobjectdefinition/txpidsettings.xml b/shared/uavobjectdefinition/txpidsettings.xml index e63cf5c4c..6d59ae5a9 100644 --- a/shared/uavobjectdefinition/txpidsettings.xml +++ b/shared/uavobjectdefinition/txpidsettings.xml @@ -20,7 +20,7 @@ Roll+Pitch Attitude.Kp, Roll+Pitch Attitude.Ki, Roll+Pitch Attitude.ILimit, Roll+Pitch Attitude.Resp, Yaw Attitude.Kp, Yaw Attitude.Ki, Yaw Attitude.ILimit, Yaw Attitude.Resp, Roll.Expo, Pitch.Expo, Roll+Pitch.Expo, Yaw.Expo, - GyroTau,AcroPlusFactor, Altitude Pos.Kp, Altitude Velocity.Kp, Altitude Velocity.Ki, Altitude Velocity.Kd, Altitude Velocity.Beta" + GyroTau,AcroPlusFactor,Altitude Pos.Kp,Altitude Velocity.Kp,Altitude Velocity.Ki,Altitude Velocity.Kd,Altitude Velocity.Beta" defaultvalue="Disabled"/> From 2eef3e2dd2e34ba7229ead33216178d26d7adc6c Mon Sep 17 00:00:00 2001 From: abeck70 Date: Sat, 9 May 2015 14:54:40 +1000 Subject: [PATCH 50/75] OP-1848 altvario discovery4bare remove second instance of uavo --- flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc | 1 - 1 file changed, 1 deletion(-) diff --git a/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc b/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc index 85046fc2c..1d7f0e0c2 100644 --- a/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc +++ b/flight/targets/boards/discoveryf4bare/firmware/UAVObjects.inc @@ -20,7 +20,6 @@ # (all architectures) UAVOBJSRCFILENAMES = UAVOBJSRCFILENAMES += statusgrounddrive -UAVOBJSRCFILENAMES += statusvtolautotakeoff UAVOBJSRCFILENAMES += pidstatus UAVOBJSRCFILENAMES += statusvtolland UAVOBJSRCFILENAMES += statusvtolautotakeoff From 0ef677970179f48f0d8e0042893955560d9220c5 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Sat, 9 May 2015 23:03:53 +1000 Subject: [PATCH 51/75] OP-1848 altvario tidyup of NE controllers in pathfollower Change ILimit variable name to Beta in multiple PID loops that now use pid2 implementation. Change velocity controller yaw from axislock to rate. --- .../modules/PathFollower/vtolautotakeoffcontroller.cpp | 2 +- flight/modules/PathFollower/vtolbrakecontroller.cpp | 2 +- flight/modules/PathFollower/vtolflycontroller.cpp | 4 ++-- flight/modules/PathFollower/vtollandcontroller.cpp | 2 +- flight/modules/PathFollower/vtolvelocitycontroller.cpp | 4 ++-- .../uavobjectdefinition/vtolpathfollowersettings.xml | 10 +++++----- 6 files changed, 12 insertions(+), 12 deletions(-) diff --git a/flight/modules/PathFollower/vtolautotakeoffcontroller.cpp b/flight/modules/PathFollower/vtolautotakeoffcontroller.cpp index 729f65097..2c4bdc569 100644 --- a/flight/modules/PathFollower/vtolautotakeoffcontroller.cpp +++ b/flight/modules/PathFollower/vtolautotakeoffcontroller.cpp @@ -126,7 +126,7 @@ void VtolAutoTakeoffController::SettingsUpdated(void) controlNE.UpdateParameters(vtolPathFollowerSettings->HorizontalVelPID.Kp, vtolPathFollowerSettings->HorizontalVelPID.Ki, vtolPathFollowerSettings->HorizontalVelPID.Kd, - vtolPathFollowerSettings->HorizontalVelPID.ILimit, + vtolPathFollowerSettings->HorizontalVelPID.Beta, dT, vtolPathFollowerSettings->HorizontalVelMax); diff --git a/flight/modules/PathFollower/vtolbrakecontroller.cpp b/flight/modules/PathFollower/vtolbrakecontroller.cpp index 208e862f7..862011057 100644 --- a/flight/modules/PathFollower/vtolbrakecontroller.cpp +++ b/flight/modules/PathFollower/vtolbrakecontroller.cpp @@ -132,7 +132,7 @@ void VtolBrakeController::SettingsUpdated(void) controlNE.UpdateParameters(vtolPathFollowerSettings->BrakeHorizontalVelPID.Kp, vtolPathFollowerSettings->BrakeHorizontalVelPID.Ki, vtolPathFollowerSettings->BrakeHorizontalVelPID.Kd, - vtolPathFollowerSettings->BrakeHorizontalVelPID.ILimit, + vtolPathFollowerSettings->BrakeHorizontalVelPID.Beta, dT, 10.0f * vtolPathFollowerSettings->HorizontalVelMax); // avoid constraining initial fast entry into brake controlNE.UpdatePositionalParameters(vtolPathFollowerSettings->HorizontalPosP); diff --git a/flight/modules/PathFollower/vtolflycontroller.cpp b/flight/modules/PathFollower/vtolflycontroller.cpp index e76c09d54..0160d0e79 100644 --- a/flight/modules/PathFollower/vtolflycontroller.cpp +++ b/flight/modules/PathFollower/vtolflycontroller.cpp @@ -127,7 +127,7 @@ void VtolFlyController::SettingsUpdated(void) controlNE.UpdateParameters(vtolPathFollowerSettings->HorizontalVelPID.Kp, vtolPathFollowerSettings->HorizontalVelPID.Ki, vtolPathFollowerSettings->HorizontalVelPID.Kd, - vtolPathFollowerSettings->HorizontalVelPID.ILimit, + vtolPathFollowerSettings->HorizontalVelPID.Beta, dT, vtolPathFollowerSettings->HorizontalVelMax); controlNE.UpdatePositionalParameters(vtolPathFollowerSettings->HorizontalPosP); @@ -136,7 +136,7 @@ void VtolFlyController::SettingsUpdated(void) controlDown.UpdateParameters(vtolPathFollowerSettings->VerticalVelPID.Kp, vtolPathFollowerSettings->VerticalVelPID.Ki, vtolPathFollowerSettings->VerticalVelPID.Kd, - vtolPathFollowerSettings->VerticalVelPID.ILimit, // TODO Change to BETA + vtolPathFollowerSettings->VerticalVelPID.Beta, dT, vtolPathFollowerSettings->VerticalVelMax); controlDown.UpdatePositionalParameters(vtolPathFollowerSettings->VerticalPosP); diff --git a/flight/modules/PathFollower/vtollandcontroller.cpp b/flight/modules/PathFollower/vtollandcontroller.cpp index 96b4a40c7..97a7d466f 100644 --- a/flight/modules/PathFollower/vtollandcontroller.cpp +++ b/flight/modules/PathFollower/vtollandcontroller.cpp @@ -120,7 +120,7 @@ void VtolLandController::SettingsUpdated(void) controlNE.UpdateParameters(vtolPathFollowerSettings->HorizontalVelPID.Kp, vtolPathFollowerSettings->HorizontalVelPID.Ki, vtolPathFollowerSettings->HorizontalVelPID.Kd, - vtolPathFollowerSettings->HorizontalVelPID.ILimit, + vtolPathFollowerSettings->HorizontalVelPID.Beta, dT, vtolPathFollowerSettings->HorizontalVelMax); diff --git a/flight/modules/PathFollower/vtolvelocitycontroller.cpp b/flight/modules/PathFollower/vtolvelocitycontroller.cpp index 84ba99daa..68018c5ea 100644 --- a/flight/modules/PathFollower/vtolvelocitycontroller.cpp +++ b/flight/modules/PathFollower/vtolvelocitycontroller.cpp @@ -107,7 +107,7 @@ void VtolVelocityController::SettingsUpdated(void) controlNE.UpdateParameters(vtolPathFollowerSettings->HorizontalVelPID.Kp, vtolPathFollowerSettings->HorizontalVelPID.Ki, vtolPathFollowerSettings->HorizontalVelPID.Kd, - vtolPathFollowerSettings->HorizontalVelPID.ILimit, + vtolPathFollowerSettings->HorizontalVelPID.Beta, dT, vtolPathFollowerSettings->HorizontalVelMax); @@ -181,7 +181,7 @@ int8_t VtolVelocityController::UpdateStabilizationDesired(__attribute__((unused) ManualControlCommandData manualControl; ManualControlCommandGet(&manualControl); - stabDesired.StabilizationMode.Yaw = STABILIZATIONDESIRED_STABILIZATIONMODE_AXISLOCK; + stabDesired.StabilizationMode.Yaw = STABILIZATIONDESIRED_STABILIZATIONMODE_RATE; stabDesired.Yaw = stabSettings.MaximumRate.Yaw * manualControl.Yaw; // default thrust mode to altvario diff --git a/shared/uavobjectdefinition/vtolpathfollowersettings.xml b/shared/uavobjectdefinition/vtolpathfollowersettings.xml index 86eea36bc..4f6758035 100644 --- a/shared/uavobjectdefinition/vtolpathfollowersettings.xml +++ b/shared/uavobjectdefinition/vtolpathfollowersettings.xml @@ -7,8 +7,8 @@ - - + + @@ -21,10 +21,10 @@ - + - - + + From 76a6e59c8de0fc963dd9e1d3bd97f4583f32d333 Mon Sep 17 00:00:00 2001 From: David Ankers Date: Mon, 13 Apr 2015 19:57:57 +1000 Subject: [PATCH 52/75] Change uninstaller display name --- package/winx86/openpilotgcs.nsi | 8 ++++---- package/winx86/openpilotgcs.tpl | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/package/winx86/openpilotgcs.nsi b/package/winx86/openpilotgcs.nsi index ab8534742..6dc9151d2 100644 --- a/package/winx86/openpilotgcs.nsi +++ b/package/winx86/openpilotgcs.nsi @@ -1,7 +1,7 @@ # # Project: OpenPilot # NSIS configuration file for OpenPilot GCS -# The OpenPilot Team, http://www.openpilot.org, Copyright (C) 2010-2014. +# The OpenPilot Team, http://www.openpilot.org, Copyright (C) 2010-2015. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -71,7 +71,7 @@ VIAddVersionKey "Comments" "${INSTALLER_NAME}. ${BUILD_DESCRIPTION}" VIAddVersionKey "CompanyName" "The OpenPilot Team, http://www.openpilot.org" VIAddVersionKey "LegalTrademarks" "${PRODUCT_NAME} is a trademark of The OpenPilot Team" - VIAddVersionKey "LegalCopyright" "© 2010-2014 The OpenPilot Team" + VIAddVersionKey "LegalCopyright" "© 2010-2015 The OpenPilot Team" VIAddVersionKey "FileDescription" "${INSTALLER_NAME}" ;-------------------------------- @@ -92,7 +92,7 @@ ;-------------------------------- ; Branding - BrandingText "© 2010-2014 The OpenPilot Team, http://www.openpilot.org" + BrandingText "© 2010-2015 The OpenPilot Team, http://www.openpilot.org" !define MUI_ICON "${NSIS_DATA_TREE}\resources\openpilot.ico" !define MUI_HEADERIMAGE @@ -296,7 +296,7 @@ Section ; create uninstall info WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "UninstallString" '"$INSTDIR\Uninstall.exe"' WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "DisplayIcon" '"$INSTDIR\bin\openpilotgcs.exe"' WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "Publisher" "OpenPilot Team" - WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "DisplayVersion" "Mini Me" + WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "DisplayVersion" "Ragin’ Cajun" WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "URLInfoAbout" "http://www.openpilot.org" WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "HelpLink" "http://wiki.openpilot.org" WriteRegDWORD HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "EstimatedSize" 100600 diff --git a/package/winx86/openpilotgcs.tpl b/package/winx86/openpilotgcs.tpl index 65b38e11e..266aef976 100644 --- a/package/winx86/openpilotgcs.tpl +++ b/package/winx86/openpilotgcs.tpl @@ -2,7 +2,7 @@ # ***************************************************************************** # # @file ${OUTFILENAME} -# @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2011. +# @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2011-2015. # @brief Autogenerated NSIS header file, built using template # ${TEMPLATE} # From a294cc3cf102d58283bd73ca606a7f4066a236eb Mon Sep 17 00:00:00 2001 From: David Ankers Date: Mon, 13 Apr 2015 20:07:27 +1000 Subject: [PATCH 53/75] Upgrade HK CCs --- ...ultirotor-QuadrocopterX-3fe218baaba.optmpl | 2186 ----------------- ...ultirotor-QuadrocopterX-b91ae8ac277.optmpl | 2186 ----------------- 2 files changed, 4372 deletions(-) delete mode 100644 ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl delete mode 100644 ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl diff --git a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl deleted file mode 100644 index 7f9dd92d0..000000000 --- a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl +++ /dev/null @@ -1,2186 +0,0 @@ -{ - "battery": "3s 2200 ", - "comment": "Acro tune for Rate , Acro +, Attitude and rattitude\nBank 1 Attitude / Acro +\nBank 2 Rattitude ", - "controller": "CC3D", - "esc": "Argonaut 20a Blheli", - "motor": "DYS 1806-2203kv", - "name": "H-King 320mm Carbon ARF", - "nick": "Failsafe", - "objects": [ - { - "fields": [ - { - "name": "VbarSensitivity", - "type": "float32", - "unit": "frac", - "values": [ - { - "name": "Roll", - "value": 0.5 - }, - { - "name": "Pitch", - "value": 0.5 - }, - { - "name": "Yaw", - "value": 0.5 - } - ] - }, - { - "name": "VbarRollPI", - "type": "float32", - "unit": "1/(deg/s)", - "values": [ - { - "name": "Kp", - "value": 0.004999999888241291 - }, - { - "name": "Ki", - "value": 0.0020000000949949026 - } - ] - }, - { - "name": "VbarPitchPI", - "type": "float32", - "unit": "1/(deg/s)", - "values": [ - { - "name": "Kp", - "value": 0.004999999888241291 - }, - { - "name": "Ki", - "value": 0.0020000000949949026 - } - ] - }, - { - "name": "VbarYawPI", - "type": "float32", - "unit": "1/(deg/s)", - "values": [ - { - "name": "Kp", - "value": 0.004999999888241291 - }, - { - "name": "Ki", - "value": 0.0020000000949949026 - } - ] - }, - { - "name": "VbarTau", - "type": "float32", - "unit": "sec", - "values": [ - { - "name": "0", - "value": 0.5 - } - ] - }, - { - "name": "GyroTau", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 0.004999999888241291 - } - ] - }, - { - "name": "DerivativeGamma", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 1 - } - ] - }, - { - "name": "AxisLockKp", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 2.5 - } - ] - }, - { - "name": "WeakLevelingKp", - "type": "float32", - "unit": "(deg/s)/deg", - "values": [ - { - "name": "0", - "value": 0.10000000149011612 - } - ] - }, - { - "name": "CruiseControlMaxPowerFactor", - "type": "float32", - "unit": "x", - "values": [ - { - "name": "0", - "value": 3 - } - ] - }, - { - "name": "CruiseControlPowerTrim", - "type": "float32", - "unit": "%", - "values": [ - { - "name": "0", - "value": 100 - } - ] - }, - { - "name": "CruiseControlPowerDelayComp", - "type": "float32", - "unit": "sec", - "values": [ - { - "name": "0", - "value": 0.25 - } - ] - }, - { - "name": "ScaleToAirspeed", - "type": "float32", - "unit": "m/s", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "ScaleToAirspeedLimits", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Min", - "value": 0.05000000074505806 - }, - { - "name": "Max", - "value": 3 - } - ] - }, - { - "name": "FlightModeMap", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Bank1" - }, - { - "name": "1", - "value": "Bank1" - }, - { - "name": "2", - "value": "Bank1" - }, - { - "name": "3", - "value": "Bank1" - }, - { - "name": "4", - "value": "Bank1" - }, - { - "name": "5", - "value": "Bank1" - } - ] - }, - { - "name": "VbarGyroSuppress", - "type": "int8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 30 - } - ] - }, - { - "name": "VbarPiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "VbarMaxAngle", - "type": "uint8", - "unit": "deg", - "values": [ - { - "name": "0", - "value": 10 - } - ] - }, - { - "name": "DerivativeCutoff", - "type": "uint8", - "unit": "Hz", - "values": [ - { - "name": "0", - "value": 20 - } - ] - }, - { - "name": "MaxAxisLock", - "type": "uint8", - "unit": "deg", - "values": [ - { - "name": "0", - "value": 30 - } - ] - }, - { - "name": "MaxAxisLockRate", - "type": "uint8", - "unit": "deg/s", - "values": [ - { - "name": "0", - "value": 2 - } - ] - }, - { - "name": "MaxWeakLevelingRate", - "type": "uint8", - "unit": "deg/s", - "values": [ - { - "name": "0", - "value": 5 - } - ] - }, - { - "name": "RattitudeModeTransition", - "type": "uint8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 80 - } - ] - }, - { - "name": "CruiseControlMinThrust", - "type": "int8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 5 - } - ] - }, - { - "name": "CruiseControlMaxThrust", - "type": "uint8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 90 - } - ] - }, - { - "name": "CruiseControlMaxAngle", - "type": "uint8", - "unit": "deg", - "values": [ - { - "name": "0", - "value": 105 - } - ] - }, - { - "name": "CruiseControlFlightModeSwitchPosEnable", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - }, - { - "name": "1", - "value": "FALSE" - }, - { - "name": "2", - "value": "FALSE" - }, - { - "name": "3", - "value": "FALSE" - }, - { - "name": "4", - "value": "FALSE" - }, - { - "name": "5", - "value": "FALSE" - } - ] - }, - { - "name": "CruiseControlInvertedThrustReversing", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Unreversed" - } - ] - }, - { - "name": "CruiseControlInvertedPowerOutput", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Zero" - } - ] - }, - { - "name": "LowThrottleZeroIntegral", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "FlightModeAssistMap", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "None" - }, - { - "name": "1", - "value": "None" - }, - { - "name": "2", - "value": "None" - }, - { - "name": "3", - "value": "None" - }, - { - "name": "4", - "value": "None" - }, - { - "name": "5", - "value": "None" - } - ] - } - ], - "id": "73603180", - "instance": 0, - "name": "StabilizationSettings", - "setting": true - }, - { - "fields": [ - { - "name": "ManualRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 300 - }, - { - "name": "Pitch", - "value": 300 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "MaximumRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 400 - }, - { - "name": "Pitch", - "value": 400 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "RollRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0022499999031424522 - }, - { - "name": "Ki", - "value": 0.0051400000229477882 - }, - { - "name": "Kd", - "value": 2.5999999706982635e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "PitchRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0037299999967217445 - }, - { - "name": "Ki", - "value": 0.010089999996125698 - }, - { - "name": "Kd", - "value": 3.9999998989515007e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "YawRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.008139999583363533 - }, - { - "name": "Ki", - "value": 0.0086000002920627594 - }, - { - "name": "Kd", - "value": 3.9999998989515007e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "RollPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.2999999523162842 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "PitchPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.7999999523162842 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "YawPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "AcroInsanityFactor", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.40000000596046448 - } - ] - }, - { - "name": "ThrustPIDScaleCurve", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": -1.427447386959102e-05 - }, - { - "name": "25", - "value": -0.0085789738222956657 - }, - { - "name": "50", - "value": -0.038573265075683594 - }, - { - "name": "75", - "value": -0.15000000596046448 - }, - { - "name": "100", - "value": -0.30000001192092896 - } - ] - }, - { - "name": "RollMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "PitchMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "YawMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 35 - } - ] - }, - { - "name": "StickExpo", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "EnablePiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "EnableThrustPIDScaling", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "ThrustPIDScaleSource", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "ActuatorDesiredThrust" - } - ] - }, - { - "name": "ThrustPIDScaleTarget", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "PD" - } - ] - }, - { - "name": "ThrustPIDScaleAxes", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Roll Pitch" - } - ] - } - ], - "id": "E8EBBD48", - "instance": 0, - "name": "StabilizationSettingsBank1", - "setting": true - }, - { - "fields": [ - { - "name": "ManualRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 400 - }, - { - "name": "Pitch", - "value": 400 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "MaximumRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 400 - }, - { - "name": "Pitch", - "value": 400 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "RollRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0022499999031424522 - }, - { - "name": "Ki", - "value": 0.0051400000229477882 - }, - { - "name": "Kd", - "value": 2.5999999706982635e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "PitchRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0037299999967217445 - }, - { - "name": "Ki", - "value": 0.010089999996125698 - }, - { - "name": "Kd", - "value": 3.9999998989515007e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "YawRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.008139999583363533 - }, - { - "name": "Ki", - "value": 0.0086000002920627594 - }, - { - "name": "Kd", - "value": 3.9999998989515007e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "RollPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.2999999523162842 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "PitchPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.7999999523162842 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "YawPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "AcroInsanityFactor", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.40000000596046448 - } - ] - }, - { - "name": "ThrustPIDScaleCurve", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": -1.427447386959102e-05 - }, - { - "name": "25", - "value": -0.0085789738222956657 - }, - { - "name": "50", - "value": -0.038573265075683594 - }, - { - "name": "75", - "value": -0.15000000596046448 - }, - { - "name": "100", - "value": -0.30000001192092896 - } - ] - }, - { - "name": "RollMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "PitchMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "YawMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 35 - } - ] - }, - { - "name": "StickExpo", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "EnablePiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "EnableThrustPIDScaling", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "ThrustPIDScaleSource", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "ActuatorDesiredThrust" - } - ] - }, - { - "name": "ThrustPIDScaleTarget", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "PD" - } - ] - }, - { - "name": "ThrustPIDScaleAxes", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Roll Pitch" - } - ] - } - ], - "id": "70E9539A", - "instance": 0, - "name": "StabilizationSettingsBank2", - "setting": true - }, - { - "fields": [ - { - "name": "ManualRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 220 - }, - { - "name": "Pitch", - "value": 220 - }, - { - "name": "Yaw", - "value": 220 - } - ] - }, - { - "name": "MaximumRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 300 - }, - { - "name": "Pitch", - "value": 300 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "RollRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0030000000260770321 - }, - { - "name": "Ki", - "value": 0.0065000001341104507 - }, - { - "name": "Kd", - "value": 3.3000000257743523e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "PitchRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0030000000260770321 - }, - { - "name": "Ki", - "value": 0.0065000001341104507 - }, - { - "name": "Kd", - "value": 3.3000000257743523e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "YawRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0062000001780688763 - }, - { - "name": "Ki", - "value": 0.0099999997764825821 - }, - { - "name": "Kd", - "value": 4.9999998736893758e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "RollPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "PitchPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "YawPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "AcroInsanityFactor", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.40000000596046448 - } - ] - }, - { - "name": "ThrustPIDScaleCurve", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.30000001192092896 - }, - { - "name": "25", - "value": 0.15000000596046448 - }, - { - "name": "50", - "value": 0 - }, - { - "name": "75", - "value": -0.15000000596046448 - }, - { - "name": "100", - "value": -0.30000001192092896 - } - ] - }, - { - "name": "RollMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "PitchMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "YawMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 35 - } - ] - }, - { - "name": "StickExpo", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "EnablePiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "EnableThrustPIDScaling", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "ThrustPIDScaleSource", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "ActuatorDesiredThrust" - } - ] - }, - { - "name": "ThrustPIDScaleTarget", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "PID" - } - ] - }, - { - "name": "ThrustPIDScaleAxes", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Roll Pitch" - } - ] - } - ], - "id": "C02DAA6A", - "instance": 0, - "name": "StabilizationSettingsBank3", - "setting": true - }, - { - "fields": [ - { - "name": "MaxAccel", - "type": "float32", - "unit": "units/sec", - "values": [ - { - "name": "0", - "value": 1000 - } - ] - }, - { - "name": "FeedForward", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "AccelTime", - "type": "float32", - "unit": "ms", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "DecelTime", - "type": "float32", - "unit": "ms", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "ThrottleCurve1", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0 - }, - { - "name": "25", - "value": 0.22499999403953552 - }, - { - "name": "50", - "value": 0.44999998807907104 - }, - { - "name": "75", - "value": 0.67499995231628418 - }, - { - "name": "100", - "value": 0.89999997615814209 - } - ] - }, - { - "name": "ThrottleCurve2", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0 - }, - { - "name": "25", - "value": 0.22499999403953552 - }, - { - "name": "50", - "value": 0.44999998807907104 - }, - { - "name": "75", - "value": 0.67499995231628418 - }, - { - "name": "100", - "value": 0.89999997615814209 - } - ] - }, - { - "name": "MixerValueRoll", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 50 - } - ] - }, - { - "name": "MixerValuePitch", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 50 - } - ] - }, - { - "name": "MixerValueYaw", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 50 - } - ] - }, - { - "name": "Curve2Source", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Throttle" - } - ] - }, - { - "name": "Mixer1Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer1Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 64 - }, - { - "name": "Pitch", - "value": 64 - }, - { - "name": "Yaw", - "value": -64 - } - ] - }, - { - "name": "Mixer2Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer2Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": -64 - }, - { - "name": "Pitch", - "value": 64 - }, - { - "name": "Yaw", - "value": 64 - } - ] - }, - { - "name": "Mixer3Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer3Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": -64 - }, - { - "name": "Pitch", - "value": -64 - }, - { - "name": "Yaw", - "value": -64 - } - ] - }, - { - "name": "Mixer4Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer4Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 64 - }, - { - "name": "Pitch", - "value": -64 - }, - { - "name": "Yaw", - "value": 64 - } - ] - }, - { - "name": "Mixer5Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer5Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer6Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer6Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer7Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer7Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer8Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer8Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer9Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer9Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer10Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer10Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer11Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer11Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer12Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer12Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - } - ], - "id": "7BF2CFA8", - "instance": 0, - "name": "MixerSettings", - "setting": true - }, - { - "fields": [ - { - "name": "P", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "PositionNorth", - "value": 10 - }, - { - "name": "PositionEast", - "value": 10 - }, - { - "name": "PositionDown", - "value": 10 - }, - { - "name": "VelocityNorth", - "value": 1 - }, - { - "name": "VelocityEast", - "value": 1 - }, - { - "name": "VelocityDown", - "value": 1 - }, - { - "name": "AttitudeQ1", - "value": 0.0070000002160668373 - }, - { - "name": "AttitudeQ2", - "value": 0.0070000002160668373 - }, - { - "name": "AttitudeQ3", - "value": 0.0070000002160668373 - }, - { - "name": "AttitudeQ4", - "value": 0.0070000002160668373 - }, - { - "name": "GyroDriftX", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftY", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftZ", - "value": 9.9999999747524271e-07 - } - ] - }, - { - "name": "Q", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "GyroX", - "value": 0.0099999997764825821 - }, - { - "name": "GyroY", - "value": 0.0099999997764825821 - }, - { - "name": "GyroZ", - "value": 0.0099999997764825821 - }, - { - "name": "AccelX", - "value": 0.0099999997764825821 - }, - { - "name": "AccelY", - "value": 0.0099999997764825821 - }, - { - "name": "AccelZ", - "value": 0.0099999997764825821 - }, - { - "name": "GyroDriftX", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftY", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftZ", - "value": 9.9999999747524271e-07 - } - ] - }, - { - "name": "R", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "GPSPosNorth", - "value": 1 - }, - { - "name": "GPSPosEast", - "value": 1 - }, - { - "name": "GPSPosDown", - "value": 1000000 - }, - { - "name": "GPSVelNorth", - "value": 0.0010000000474974513 - }, - { - "name": "GPSVelEast", - "value": 0.0010000000474974513 - }, - { - "name": "GPSVelDown", - "value": 0.0010000000474974513 - }, - { - "name": "MagX", - "value": 10 - }, - { - "name": "MagY", - "value": 10 - }, - { - "name": "MagZ", - "value": 10 - }, - { - "name": "BaroZ", - "value": 0.0099999997764825821 - } - ] - }, - { - "name": "FakeR", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "FakeGPSPosIndoor", - "value": 10 - }, - { - "name": "FakeGPSVelIndoor", - "value": 1 - }, - { - "name": "FakeGPSVelAirspeed", - "value": 1000 - } - ] - } - ], - "id": "5E91213C", - "instance": 0, - "name": "EKFConfiguration", - "setting": true - } - ], - "owner": "Jim", - "photo": "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", - "propeller": "6 x 4.5", - "servo": "", - "size": "320", - "subtype": 2, - "type": 1, - "uuid": "{cf693467-fcb3-4eae-a0ab-43fe218baaba}", - "weight": "898" -} diff --git a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl deleted file mode 100644 index 700e289ad..000000000 --- a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl +++ /dev/null @@ -1,2186 +0,0 @@ -{ - "battery": "3s 1300 35c", - "comment": "Acro tune for Rate , Acro +, Attitude and rattitude\nBank 1 Attitude / Acro +\nBank 2 Rattitude ", - "controller": "CC3D", - "esc": "Argonaut 20a Blheli", - "motor": "DYS 1806-2300kv", - "name": "H-King Carbon 250 ARF", - "nick": "Failsafe", - "objects": [ - { - "fields": [ - { - "name": "VbarSensitivity", - "type": "float32", - "unit": "frac", - "values": [ - { - "name": "Roll", - "value": 0.5 - }, - { - "name": "Pitch", - "value": 0.5 - }, - { - "name": "Yaw", - "value": 0.5 - } - ] - }, - { - "name": "VbarRollPI", - "type": "float32", - "unit": "1/(deg/s)", - "values": [ - { - "name": "Kp", - "value": 0.004999999888241291 - }, - { - "name": "Ki", - "value": 0.0020000000949949026 - } - ] - }, - { - "name": "VbarPitchPI", - "type": "float32", - "unit": "1/(deg/s)", - "values": [ - { - "name": "Kp", - "value": 0.004999999888241291 - }, - { - "name": "Ki", - "value": 0.0020000000949949026 - } - ] - }, - { - "name": "VbarYawPI", - "type": "float32", - "unit": "1/(deg/s)", - "values": [ - { - "name": "Kp", - "value": 0.004999999888241291 - }, - { - "name": "Ki", - "value": 0.0020000000949949026 - } - ] - }, - { - "name": "VbarTau", - "type": "float32", - "unit": "sec", - "values": [ - { - "name": "0", - "value": 0.5 - } - ] - }, - { - "name": "GyroTau", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 0.004999999888241291 - } - ] - }, - { - "name": "DerivativeGamma", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 1 - } - ] - }, - { - "name": "AxisLockKp", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 2.5 - } - ] - }, - { - "name": "WeakLevelingKp", - "type": "float32", - "unit": "(deg/s)/deg", - "values": [ - { - "name": "0", - "value": 0.10000000149011612 - } - ] - }, - { - "name": "CruiseControlMaxPowerFactor", - "type": "float32", - "unit": "x", - "values": [ - { - "name": "0", - "value": 3 - } - ] - }, - { - "name": "CruiseControlPowerTrim", - "type": "float32", - "unit": "%", - "values": [ - { - "name": "0", - "value": 100 - } - ] - }, - { - "name": "CruiseControlPowerDelayComp", - "type": "float32", - "unit": "sec", - "values": [ - { - "name": "0", - "value": 0.25 - } - ] - }, - { - "name": "ScaleToAirspeed", - "type": "float32", - "unit": "m/s", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "ScaleToAirspeedLimits", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Min", - "value": 0.05000000074505806 - }, - { - "name": "Max", - "value": 3 - } - ] - }, - { - "name": "FlightModeMap", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Bank1" - }, - { - "name": "1", - "value": "Bank1" - }, - { - "name": "2", - "value": "Bank1" - }, - { - "name": "3", - "value": "Bank1" - }, - { - "name": "4", - "value": "Bank1" - }, - { - "name": "5", - "value": "Bank1" - } - ] - }, - { - "name": "VbarGyroSuppress", - "type": "int8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 30 - } - ] - }, - { - "name": "VbarPiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "VbarMaxAngle", - "type": "uint8", - "unit": "deg", - "values": [ - { - "name": "0", - "value": 10 - } - ] - }, - { - "name": "DerivativeCutoff", - "type": "uint8", - "unit": "Hz", - "values": [ - { - "name": "0", - "value": 20 - } - ] - }, - { - "name": "MaxAxisLock", - "type": "uint8", - "unit": "deg", - "values": [ - { - "name": "0", - "value": 30 - } - ] - }, - { - "name": "MaxAxisLockRate", - "type": "uint8", - "unit": "deg/s", - "values": [ - { - "name": "0", - "value": 2 - } - ] - }, - { - "name": "MaxWeakLevelingRate", - "type": "uint8", - "unit": "deg/s", - "values": [ - { - "name": "0", - "value": 5 - } - ] - }, - { - "name": "RattitudeModeTransition", - "type": "uint8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 80 - } - ] - }, - { - "name": "CruiseControlMinThrust", - "type": "int8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 5 - } - ] - }, - { - "name": "CruiseControlMaxThrust", - "type": "uint8", - "unit": "%", - "values": [ - { - "name": "0", - "value": 90 - } - ] - }, - { - "name": "CruiseControlMaxAngle", - "type": "uint8", - "unit": "deg", - "values": [ - { - "name": "0", - "value": 105 - } - ] - }, - { - "name": "CruiseControlFlightModeSwitchPosEnable", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - }, - { - "name": "1", - "value": "FALSE" - }, - { - "name": "2", - "value": "FALSE" - }, - { - "name": "3", - "value": "FALSE" - }, - { - "name": "4", - "value": "FALSE" - }, - { - "name": "5", - "value": "FALSE" - } - ] - }, - { - "name": "CruiseControlInvertedThrustReversing", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Unreversed" - } - ] - }, - { - "name": "CruiseControlInvertedPowerOutput", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Zero" - } - ] - }, - { - "name": "LowThrottleZeroIntegral", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "FlightModeAssistMap", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "None" - }, - { - "name": "1", - "value": "None" - }, - { - "name": "2", - "value": "None" - }, - { - "name": "3", - "value": "None" - }, - { - "name": "4", - "value": "None" - }, - { - "name": "5", - "value": "None" - } - ] - } - ], - "id": "73603180", - "instance": 0, - "name": "StabilizationSettings", - "setting": true - }, - { - "fields": [ - { - "name": "ManualRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 300 - }, - { - "name": "Pitch", - "value": 300 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "MaximumRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 300 - }, - { - "name": "Pitch", - "value": 300 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "RollRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0019499999471008778 - }, - { - "name": "Ki", - "value": 0.0048400000669062138 - }, - { - "name": "Kd", - "value": 2.4999999368446879e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "PitchRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.003229999914765358 - }, - { - "name": "Ki", - "value": 0.0091899996623396873 - }, - { - "name": "Kd", - "value": 3.5000000934815034e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "YawRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0069400002248585224 - }, - { - "name": "Ki", - "value": 0.0086000002920627594 - }, - { - "name": "Kd", - "value": 3.9999998989515007e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "RollPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.0999999046325684 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "PitchPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5999999046325684 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "YawPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "AcroInsanityFactor", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.40000000596046448 - } - ] - }, - { - "name": "ThrustPIDScaleCurve", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": -1.427447386959102e-05 - }, - { - "name": "25", - "value": -0.0085789738222956657 - }, - { - "name": "50", - "value": -0.038573265075683594 - }, - { - "name": "75", - "value": -0.15000000596046448 - }, - { - "name": "100", - "value": -0.30000001192092896 - } - ] - }, - { - "name": "RollMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "PitchMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "YawMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 35 - } - ] - }, - { - "name": "StickExpo", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "EnablePiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "EnableThrustPIDScaling", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "ThrustPIDScaleSource", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "ActuatorDesiredThrust" - } - ] - }, - { - "name": "ThrustPIDScaleTarget", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "PD" - } - ] - }, - { - "name": "ThrustPIDScaleAxes", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Roll Pitch" - } - ] - } - ], - "id": "E8EBBD48", - "instance": 0, - "name": "StabilizationSettingsBank1", - "setting": true - }, - { - "fields": [ - { - "name": "ManualRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 400 - }, - { - "name": "Pitch", - "value": 400 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "MaximumRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 400 - }, - { - "name": "Pitch", - "value": 400 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "RollRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0019499999471008778 - }, - { - "name": "Ki", - "value": 0.0048400000669062138 - }, - { - "name": "Kd", - "value": 2.4999999368446879e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "PitchRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.003229999914765358 - }, - { - "name": "Ki", - "value": 0.0091899996623396873 - }, - { - "name": "Kd", - "value": 3.5000000934815034e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "YawRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0069400002248585224 - }, - { - "name": "Ki", - "value": 0.0086000002920627594 - }, - { - "name": "Kd", - "value": 3.9999998989515007e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "RollPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.0999999046325684 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "PitchPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5999999046325684 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "YawPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "AcroInsanityFactor", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.40000000596046448 - } - ] - }, - { - "name": "ThrustPIDScaleCurve", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": -1.427447386959102e-05 - }, - { - "name": "25", - "value": -0.0085789738222956657 - }, - { - "name": "50", - "value": -0.038573265075683594 - }, - { - "name": "75", - "value": -0.15000000596046448 - }, - { - "name": "100", - "value": -0.30000001192092896 - } - ] - }, - { - "name": "RollMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "PitchMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "YawMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 35 - } - ] - }, - { - "name": "StickExpo", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "EnablePiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "EnableThrustPIDScaling", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "ThrustPIDScaleSource", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "ActuatorDesiredThrust" - } - ] - }, - { - "name": "ThrustPIDScaleTarget", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "PD" - } - ] - }, - { - "name": "ThrustPIDScaleAxes", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Roll Pitch" - } - ] - } - ], - "id": "70E9539A", - "instance": 0, - "name": "StabilizationSettingsBank2", - "setting": true - }, - { - "fields": [ - { - "name": "ManualRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 220 - }, - { - "name": "Pitch", - "value": 220 - }, - { - "name": "Yaw", - "value": 220 - } - ] - }, - { - "name": "MaximumRate", - "type": "float32", - "unit": "degrees/sec", - "values": [ - { - "name": "Roll", - "value": 300 - }, - { - "name": "Pitch", - "value": 300 - }, - { - "name": "Yaw", - "value": 300 - } - ] - }, - { - "name": "RollRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0030000000260770321 - }, - { - "name": "Ki", - "value": 0.0065000001341104507 - }, - { - "name": "Kd", - "value": 3.3000000257743523e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "PitchRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0030000000260770321 - }, - { - "name": "Ki", - "value": 0.0065000001341104507 - }, - { - "name": "Kd", - "value": 3.3000000257743523e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "YawRatePID", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 0.0062000001780688763 - }, - { - "name": "Ki", - "value": 0.0099999997764825821 - }, - { - "name": "Kd", - "value": 4.9999998736893758e-05 - }, - { - "name": "ILimit", - "value": 0.30000001192092896 - } - ] - }, - { - "name": "RollPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "PitchPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "YawPI", - "type": "float32", - "unit": "", - "values": [ - { - "name": "Kp", - "value": 2.5 - }, - { - "name": "Ki", - "value": 0 - }, - { - "name": "ILimit", - "value": 50 - } - ] - }, - { - "name": "AcroInsanityFactor", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.40000000596046448 - } - ] - }, - { - "name": "ThrustPIDScaleCurve", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0.30000001192092896 - }, - { - "name": "25", - "value": 0.15000000596046448 - }, - { - "name": "50", - "value": 0 - }, - { - "name": "75", - "value": -0.15000000596046448 - }, - { - "name": "100", - "value": -0.30000001192092896 - } - ] - }, - { - "name": "RollMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "PitchMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 55 - } - ] - }, - { - "name": "YawMax", - "type": "uint8", - "unit": "degrees", - "values": [ - { - "name": "0", - "value": 35 - } - ] - }, - { - "name": "StickExpo", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "EnablePiroComp", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "TRUE" - } - ] - }, - { - "name": "EnableThrustPIDScaling", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "FALSE" - } - ] - }, - { - "name": "ThrustPIDScaleSource", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "ActuatorDesiredThrust" - } - ] - }, - { - "name": "ThrustPIDScaleTarget", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "PID" - } - ] - }, - { - "name": "ThrustPIDScaleAxes", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Roll Pitch" - } - ] - } - ], - "id": "C02DAA6A", - "instance": 0, - "name": "StabilizationSettingsBank3", - "setting": true - }, - { - "fields": [ - { - "name": "MaxAccel", - "type": "float32", - "unit": "units/sec", - "values": [ - { - "name": "0", - "value": 1000 - } - ] - }, - { - "name": "FeedForward", - "type": "float32", - "unit": "", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "AccelTime", - "type": "float32", - "unit": "ms", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "DecelTime", - "type": "float32", - "unit": "ms", - "values": [ - { - "name": "0", - "value": 0 - } - ] - }, - { - "name": "ThrottleCurve1", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0 - }, - { - "name": "25", - "value": 0.22499999403953552 - }, - { - "name": "50", - "value": 0.44999998807907104 - }, - { - "name": "75", - "value": 0.67499995231628418 - }, - { - "name": "100", - "value": 0.89999997615814209 - } - ] - }, - { - "name": "ThrottleCurve2", - "type": "float32", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 0 - }, - { - "name": "25", - "value": 0.22499999403953552 - }, - { - "name": "50", - "value": 0.44999998807907104 - }, - { - "name": "75", - "value": 0.67499995231628418 - }, - { - "name": "100", - "value": 0.89999997615814209 - } - ] - }, - { - "name": "MixerValueRoll", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 50 - } - ] - }, - { - "name": "MixerValuePitch", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 50 - } - ] - }, - { - "name": "MixerValueYaw", - "type": "int8", - "unit": "percent", - "values": [ - { - "name": "0", - "value": 50 - } - ] - }, - { - "name": "Curve2Source", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Throttle" - } - ] - }, - { - "name": "Mixer1Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer1Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 64 - }, - { - "name": "Pitch", - "value": 64 - }, - { - "name": "Yaw", - "value": -64 - } - ] - }, - { - "name": "Mixer2Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer2Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": -64 - }, - { - "name": "Pitch", - "value": 64 - }, - { - "name": "Yaw", - "value": 64 - } - ] - }, - { - "name": "Mixer3Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer3Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": -64 - }, - { - "name": "Pitch", - "value": -64 - }, - { - "name": "Yaw", - "value": -64 - } - ] - }, - { - "name": "Mixer4Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Motor" - } - ] - }, - { - "name": "Mixer4Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 127 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 64 - }, - { - "name": "Pitch", - "value": -64 - }, - { - "name": "Yaw", - "value": 64 - } - ] - }, - { - "name": "Mixer5Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer5Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer6Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer6Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer7Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer7Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer8Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer8Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer9Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer9Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer10Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer10Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer11Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer11Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - }, - { - "name": "Mixer12Type", - "type": "enum", - "unit": "", - "values": [ - { - "name": "0", - "value": "Disabled" - } - ] - }, - { - "name": "Mixer12Vector", - "type": "int8", - "unit": "", - "values": [ - { - "name": "ThrottleCurve1", - "value": 0 - }, - { - "name": "ThrottleCurve2", - "value": 0 - }, - { - "name": "Roll", - "value": 0 - }, - { - "name": "Pitch", - "value": 0 - }, - { - "name": "Yaw", - "value": 0 - } - ] - } - ], - "id": "7BF2CFA8", - "instance": 0, - "name": "MixerSettings", - "setting": true - }, - { - "fields": [ - { - "name": "P", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "PositionNorth", - "value": 10 - }, - { - "name": "PositionEast", - "value": 10 - }, - { - "name": "PositionDown", - "value": 10 - }, - { - "name": "VelocityNorth", - "value": 1 - }, - { - "name": "VelocityEast", - "value": 1 - }, - { - "name": "VelocityDown", - "value": 1 - }, - { - "name": "AttitudeQ1", - "value": 0.0070000002160668373 - }, - { - "name": "AttitudeQ2", - "value": 0.0070000002160668373 - }, - { - "name": "AttitudeQ3", - "value": 0.0070000002160668373 - }, - { - "name": "AttitudeQ4", - "value": 0.0070000002160668373 - }, - { - "name": "GyroDriftX", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftY", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftZ", - "value": 9.9999999747524271e-07 - } - ] - }, - { - "name": "Q", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "GyroX", - "value": 0.0099999997764825821 - }, - { - "name": "GyroY", - "value": 0.0099999997764825821 - }, - { - "name": "GyroZ", - "value": 0.0099999997764825821 - }, - { - "name": "AccelX", - "value": 0.0099999997764825821 - }, - { - "name": "AccelY", - "value": 0.0099999997764825821 - }, - { - "name": "AccelZ", - "value": 0.0099999997764825821 - }, - { - "name": "GyroDriftX", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftY", - "value": 9.9999999747524271e-07 - }, - { - "name": "GyroDriftZ", - "value": 9.9999999747524271e-07 - } - ] - }, - { - "name": "R", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "GPSPosNorth", - "value": 1 - }, - { - "name": "GPSPosEast", - "value": 1 - }, - { - "name": "GPSPosDown", - "value": 1000000 - }, - { - "name": "GPSVelNorth", - "value": 0.0010000000474974513 - }, - { - "name": "GPSVelEast", - "value": 0.0010000000474974513 - }, - { - "name": "GPSVelDown", - "value": 0.0010000000474974513 - }, - { - "name": "MagX", - "value": 10 - }, - { - "name": "MagY", - "value": 10 - }, - { - "name": "MagZ", - "value": 10 - }, - { - "name": "BaroZ", - "value": 0.0099999997764825821 - } - ] - }, - { - "name": "FakeR", - "type": "float32", - "unit": "1^2", - "values": [ - { - "name": "FakeGPSPosIndoor", - "value": 10 - }, - { - "name": "FakeGPSVelIndoor", - "value": 1 - }, - { - "name": "FakeGPSVelAirspeed", - "value": 1000 - } - ] - } - ], - "id": "5E91213C", - "instance": 0, - "name": "EKFConfiguration", - "setting": true - } - ], - "owner": "Jim", - "photo": "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", - "propeller": "5x3 Carbon", - "servo": "", - "size": "250", - "subtype": 2, - "type": 1, - "uuid": "{2177947e-c1b1-4724-9b76-db91ae8ac277}", - "weight": "410" -} From dda67398cbb6bd83e39df710d5b50da72a24de61 Mon Sep 17 00:00:00 2001 From: David Ankers Date: Mon, 13 Apr 2015 20:08:23 +1000 Subject: [PATCH 54/75] New versions of HK RTF models for cloudconfig --- ...ultirotor-QuadrocopterX-969354c51c1.optmpl | 2186 +++++++++++++++++ ...ultirotor-QuadrocopterX-0b41edda68f.optmpl | 2186 +++++++++++++++++ 2 files changed, 4372 insertions(+) create mode 100644 ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS250CarbonFib-Multirotor-QuadrocopterX-969354c51c1.optmpl create mode 100644 ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS320CarbonFib-Multirotor-QuadrocopterX-0b41edda68f.optmpl diff --git a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS250CarbonFib-Multirotor-QuadrocopterX-969354c51c1.optmpl b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS250CarbonFib-Multirotor-QuadrocopterX-969354c51c1.optmpl new file mode 100644 index 000000000..8f4467ab0 --- /dev/null +++ b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS250CarbonFib-Multirotor-QuadrocopterX-969354c51c1.optmpl @@ -0,0 +1,2186 @@ +{ + "battery": "3s 1300 35c", + "comment": "Bank 1 attitude and rate /acro +\nBank 2 rattitude mode ", + "controller": "CC3D", + "esc": "20a OPTO Blheli", + "motor": "DYS 1806 2300kv", + "name": "H King DYS 250 Carbon Fiber", + "nick": "Failsafe", + "objects": [ + { + "fields": [ + { + "name": "VbarSensitivity", + "type": "float32", + "unit": "frac", + "values": [ + { + "name": "Roll", + "value": 0.5 + }, + { + "name": "Pitch", + "value": 0.5 + }, + { + "name": "Yaw", + "value": 0.5 + } + ] + }, + { + "name": "VbarRollPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarPitchPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarYawPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarTau", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.5 + } + ] + }, + { + "name": "GyroTau", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0.004999999888241291 + } + ] + }, + { + "name": "DerivativeGamma", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 1 + } + ] + }, + { + "name": "AxisLockKp", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 2.5 + } + ] + }, + { + "name": "WeakLevelingKp", + "type": "float32", + "unit": "(deg/s)/deg", + "values": [ + { + "name": "0", + "value": 0.10000000149011612 + } + ] + }, + { + "name": "CruiseControlMaxPowerFactor", + "type": "float32", + "unit": "x", + "values": [ + { + "name": "0", + "value": 3 + } + ] + }, + { + "name": "CruiseControlPowerTrim", + "type": "float32", + "unit": "%", + "values": [ + { + "name": "0", + "value": 100 + } + ] + }, + { + "name": "CruiseControlPowerDelayComp", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.25 + } + ] + }, + { + "name": "ScaleToAirspeed", + "type": "float32", + "unit": "m/s", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ScaleToAirspeedLimits", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Min", + "value": 0.05000000074505806 + }, + { + "name": "Max", + "value": 3 + } + ] + }, + { + "name": "FlightModeMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Bank1" + }, + { + "name": "1", + "value": "Bank1" + }, + { + "name": "2", + "value": "Bank1" + }, + { + "name": "3", + "value": "Bank1" + }, + { + "name": "4", + "value": "Bank1" + }, + { + "name": "5", + "value": "Bank1" + } + ] + }, + { + "name": "VbarGyroSuppress", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "VbarPiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "VbarMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 10 + } + ] + }, + { + "name": "DerivativeCutoff", + "type": "uint8", + "unit": "Hz", + "values": [ + { + "name": "0", + "value": 20 + } + ] + }, + { + "name": "MaxAxisLock", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "MaxAxisLockRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 2 + } + ] + }, + { + "name": "MaxWeakLevelingRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "RattitudeModeTransition", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 80 + } + ] + }, + { + "name": "CruiseControlMinThrust", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "CruiseControlMaxThrust", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 90 + } + ] + }, + { + "name": "CruiseControlMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 105 + } + ] + }, + { + "name": "CruiseControlFlightModeSwitchPosEnable", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + }, + { + "name": "1", + "value": "FALSE" + }, + { + "name": "2", + "value": "FALSE" + }, + { + "name": "3", + "value": "FALSE" + }, + { + "name": "4", + "value": "FALSE" + }, + { + "name": "5", + "value": "FALSE" + } + ] + }, + { + "name": "CruiseControlInvertedThrustReversing", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Unreversed" + } + ] + }, + { + "name": "CruiseControlInvertedPowerOutput", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Zero" + } + ] + }, + { + "name": "LowThrottleZeroIntegral", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "FlightModeAssistMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "None" + }, + { + "name": "1", + "value": "None" + }, + { + "name": "2", + "value": "None" + }, + { + "name": "3", + "value": "None" + }, + { + "name": "4", + "value": "None" + }, + { + "name": "5", + "value": "None" + } + ] + } + ], + "id": "73603180", + "instance": 0, + "name": "StabilizationSettings", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0017500000540167093 + }, + { + "name": "Ki", + "value": 0.0026400000788271427 + }, + { + "name": "Kd", + "value": 1.8999999156221747e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.002199999988079071 + }, + { + "name": "Ki", + "value": 0.006289999932050705 + }, + { + "name": "Kd", + "value": 2.3000000510364771e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0063399998471140862 + }, + { + "name": "Ki", + "value": 0.0098999999463558197 + }, + { + "name": "Kd", + "value": 4.1999999666586518e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 1.7999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.0999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "E8EBBD48", + "instance": 0, + "name": "StabilizationSettingsBank1", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 460 + }, + { + "name": "Pitch", + "value": 460 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 460 + }, + { + "name": "Pitch", + "value": 460 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0017500000540167093 + }, + { + "name": "Ki", + "value": 0.0026400000788271427 + }, + { + "name": "Kd", + "value": 1.8999999156221747e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.002199999988079071 + }, + { + "name": "Ki", + "value": 0.006289999932050705 + }, + { + "name": "Kd", + "value": 2.3000000510364771e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0063399998471140862 + }, + { + "name": "Ki", + "value": 0.0098999999463558197 + }, + { + "name": "Kd", + "value": 4.1999999666586518e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 1.7999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.0999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "70E9539A", + "instance": 0, + "name": "StabilizationSettingsBank2", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 220 + }, + { + "name": "Pitch", + "value": 220 + }, + { + "name": "Yaw", + "value": 220 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0062000001780688763 + }, + { + "name": "Ki", + "value": 0.0099999997764825821 + }, + { + "name": "Kd", + "value": 4.9999998736893758e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "C02DAA6A", + "instance": 0, + "name": "StabilizationSettingsBank3", + "setting": true + }, + { + "fields": [ + { + "name": "MaxAccel", + "type": "float32", + "unit": "units/sec", + "values": [ + { + "name": "0", + "value": 1000 + } + ] + }, + { + "name": "FeedForward", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "AccelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "DecelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ThrottleCurve1", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "ThrottleCurve2", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "MixerValueRoll", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValuePitch", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValueYaw", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "Curve2Source", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Throttle" + } + ] + }, + { + "name": "Mixer1Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer1Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer2Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer2Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer3Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer3Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer4Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer4Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer5Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer5Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer6Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer6Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer7Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer7Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer8Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer8Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer9Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer9Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer10Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer10Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer11Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer11Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer12Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer12Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + } + ], + "id": "7BF2CFA8", + "instance": 0, + "name": "MixerSettings", + "setting": true + }, + { + "fields": [ + { + "name": "P", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "PositionNorth", + "value": 10 + }, + { + "name": "PositionEast", + "value": 10 + }, + { + "name": "PositionDown", + "value": 10 + }, + { + "name": "VelocityNorth", + "value": 1 + }, + { + "name": "VelocityEast", + "value": 1 + }, + { + "name": "VelocityDown", + "value": 1 + }, + { + "name": "AttitudeQ1", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ2", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ3", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ4", + "value": 0.0070000002160668373 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "Q", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GyroX", + "value": 0.0099999997764825821 + }, + { + "name": "GyroY", + "value": 0.0099999997764825821 + }, + { + "name": "GyroZ", + "value": 0.0099999997764825821 + }, + { + "name": "AccelX", + "value": 0.0099999997764825821 + }, + { + "name": "AccelY", + "value": 0.0099999997764825821 + }, + { + "name": "AccelZ", + "value": 0.0099999997764825821 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "R", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GPSPosNorth", + "value": 1 + }, + { + "name": "GPSPosEast", + "value": 1 + }, + { + "name": "GPSPosDown", + "value": 1000000 + }, + { + "name": "GPSVelNorth", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelEast", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelDown", + "value": 0.0010000000474974513 + }, + { + "name": "MagX", + "value": 10 + }, + { + "name": "MagY", + "value": 10 + }, + { + "name": "MagZ", + "value": 10 + }, + { + "name": "BaroZ", + "value": 0.0099999997764825821 + } + ] + }, + { + "name": "FakeR", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "FakeGPSPosIndoor", + "value": 10 + }, + { + "name": "FakeGPSVelIndoor", + "value": 1 + }, + { + "name": "FakeGPSVelAirspeed", + "value": 1000 + } + ] + } + ], + "id": "5E91213C", + "instance": 0, + "name": "EKFConfiguration", + "setting": true + } + ], + "owner": "Jim Allen", + "photo": "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", + "propeller": "5x4 HQ", + "servo": "", + "size": "250mm", + "subtype": 2, + "type": 1, + "uuid": "{57f8cb14-95bc-4ae0-9773-8969354c51c1}", + "weight": "410" +} diff --git a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS320CarbonFib-Multirotor-QuadrocopterX-0b41edda68f.optmpl b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS320CarbonFib-Multirotor-QuadrocopterX-0b41edda68f.optmpl new file mode 100644 index 000000000..afb531957 --- /dev/null +++ b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/HKingDYS320CarbonFib-Multirotor-QuadrocopterX-0b41edda68f.optmpl @@ -0,0 +1,2186 @@ +{ + "battery": "3s 1300 35c", + "comment": "Bank 1 attitude and rate /acro +\nBank 2 rattitude mode", + "controller": "CC3D", + "esc": "20a OPTO Blheli", + "motor": "DYS 1806 2300kv", + "name": "H King DYS 320 Carbon Fiber", + "nick": "Failsafe", + "objects": [ + { + "fields": [ + { + "name": "VbarSensitivity", + "type": "float32", + "unit": "frac", + "values": [ + { + "name": "Roll", + "value": 0.5 + }, + { + "name": "Pitch", + "value": 0.5 + }, + { + "name": "Yaw", + "value": 0.5 + } + ] + }, + { + "name": "VbarRollPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarPitchPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarYawPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarTau", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.5 + } + ] + }, + { + "name": "GyroTau", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0.004999999888241291 + } + ] + }, + { + "name": "DerivativeGamma", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 1 + } + ] + }, + { + "name": "AxisLockKp", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 2.5 + } + ] + }, + { + "name": "WeakLevelingKp", + "type": "float32", + "unit": "(deg/s)/deg", + "values": [ + { + "name": "0", + "value": 0.10000000149011612 + } + ] + }, + { + "name": "CruiseControlMaxPowerFactor", + "type": "float32", + "unit": "x", + "values": [ + { + "name": "0", + "value": 3 + } + ] + }, + { + "name": "CruiseControlPowerTrim", + "type": "float32", + "unit": "%", + "values": [ + { + "name": "0", + "value": 100 + } + ] + }, + { + "name": "CruiseControlPowerDelayComp", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.25 + } + ] + }, + { + "name": "ScaleToAirspeed", + "type": "float32", + "unit": "m/s", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ScaleToAirspeedLimits", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Min", + "value": 0.05000000074505806 + }, + { + "name": "Max", + "value": 3 + } + ] + }, + { + "name": "FlightModeMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Bank1" + }, + { + "name": "1", + "value": "Bank1" + }, + { + "name": "2", + "value": "Bank1" + }, + { + "name": "3", + "value": "Bank1" + }, + { + "name": "4", + "value": "Bank1" + }, + { + "name": "5", + "value": "Bank1" + } + ] + }, + { + "name": "VbarGyroSuppress", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "VbarPiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "VbarMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 10 + } + ] + }, + { + "name": "DerivativeCutoff", + "type": "uint8", + "unit": "Hz", + "values": [ + { + "name": "0", + "value": 20 + } + ] + }, + { + "name": "MaxAxisLock", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "MaxAxisLockRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 2 + } + ] + }, + { + "name": "MaxWeakLevelingRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "RattitudeModeTransition", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 80 + } + ] + }, + { + "name": "CruiseControlMinThrust", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "CruiseControlMaxThrust", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 90 + } + ] + }, + { + "name": "CruiseControlMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 105 + } + ] + }, + { + "name": "CruiseControlFlightModeSwitchPosEnable", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + }, + { + "name": "1", + "value": "FALSE" + }, + { + "name": "2", + "value": "FALSE" + }, + { + "name": "3", + "value": "FALSE" + }, + { + "name": "4", + "value": "FALSE" + }, + { + "name": "5", + "value": "FALSE" + } + ] + }, + { + "name": "CruiseControlInvertedThrustReversing", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Unreversed" + } + ] + }, + { + "name": "CruiseControlInvertedPowerOutput", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Zero" + } + ] + }, + { + "name": "LowThrottleZeroIntegral", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "FlightModeAssistMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "None" + }, + { + "name": "1", + "value": "None" + }, + { + "name": "2", + "value": "None" + }, + { + "name": "3", + "value": "None" + }, + { + "name": "4", + "value": "None" + }, + { + "name": "5", + "value": "None" + } + ] + } + ], + "id": "73603180", + "instance": 0, + "name": "StabilizationSettings", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0017500000540167093 + }, + { + "name": "Ki", + "value": 0.0026400000788271427 + }, + { + "name": "Kd", + "value": 1.8999999156221747e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.002199999988079071 + }, + { + "name": "Ki", + "value": 0.006289999932050705 + }, + { + "name": "Kd", + "value": 2.3000000510364771e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0063399998471140862 + }, + { + "name": "Ki", + "value": 0.0098999999463558197 + }, + { + "name": "Kd", + "value": 4.1999999666586518e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 1.7999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.0999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "E8EBBD48", + "instance": 0, + "name": "StabilizationSettingsBank1", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 460 + }, + { + "name": "Pitch", + "value": 460 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 460 + }, + { + "name": "Pitch", + "value": 460 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0017500000540167093 + }, + { + "name": "Ki", + "value": 0.0026400000788271427 + }, + { + "name": "Kd", + "value": 1.8999999156221747e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.002199999988079071 + }, + { + "name": "Ki", + "value": 0.006289999932050705 + }, + { + "name": "Kd", + "value": 2.3000000510364771e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0063399998471140862 + }, + { + "name": "Ki", + "value": 0.0098999999463558197 + }, + { + "name": "Kd", + "value": 4.1999999666586518e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 1.7999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.0999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "70E9539A", + "instance": 0, + "name": "StabilizationSettingsBank2", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 220 + }, + { + "name": "Pitch", + "value": 220 + }, + { + "name": "Yaw", + "value": 220 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0062000001780688763 + }, + { + "name": "Ki", + "value": 0.0099999997764825821 + }, + { + "name": "Kd", + "value": 4.9999998736893758e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "C02DAA6A", + "instance": 0, + "name": "StabilizationSettingsBank3", + "setting": true + }, + { + "fields": [ + { + "name": "MaxAccel", + "type": "float32", + "unit": "units/sec", + "values": [ + { + "name": "0", + "value": 1000 + } + ] + }, + { + "name": "FeedForward", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "AccelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "DecelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ThrottleCurve1", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "ThrottleCurve2", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "MixerValueRoll", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValuePitch", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValueYaw", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "Curve2Source", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Throttle" + } + ] + }, + { + "name": "Mixer1Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer1Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer2Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer2Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer3Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer3Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer4Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer4Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer5Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer5Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer6Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer6Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer7Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer7Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer8Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer8Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer9Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer9Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer10Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer10Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer11Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer11Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer12Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer12Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + } + ], + "id": "7BF2CFA8", + "instance": 0, + "name": "MixerSettings", + "setting": true + }, + { + "fields": [ + { + "name": "P", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "PositionNorth", + "value": 10 + }, + { + "name": "PositionEast", + "value": 10 + }, + { + "name": "PositionDown", + "value": 10 + }, + { + "name": "VelocityNorth", + "value": 1 + }, + { + "name": "VelocityEast", + "value": 1 + }, + { + "name": "VelocityDown", + "value": 1 + }, + { + "name": "AttitudeQ1", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ2", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ3", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ4", + "value": 0.0070000002160668373 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "Q", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GyroX", + "value": 0.0099999997764825821 + }, + { + "name": "GyroY", + "value": 0.0099999997764825821 + }, + { + "name": "GyroZ", + "value": 0.0099999997764825821 + }, + { + "name": "AccelX", + "value": 0.0099999997764825821 + }, + { + "name": "AccelY", + "value": 0.0099999997764825821 + }, + { + "name": "AccelZ", + "value": 0.0099999997764825821 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "R", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GPSPosNorth", + "value": 1 + }, + { + "name": "GPSPosEast", + "value": 1 + }, + { + "name": "GPSPosDown", + "value": 1000000 + }, + { + "name": "GPSVelNorth", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelEast", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelDown", + "value": 0.0010000000474974513 + }, + { + "name": "MagX", + "value": 10 + }, + { + "name": "MagY", + "value": 10 + }, + { + "name": "MagZ", + "value": 10 + }, + { + "name": "BaroZ", + "value": 0.0099999997764825821 + } + ] + }, + { + "name": "FakeR", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "FakeGPSPosIndoor", + "value": 10 + }, + { + "name": "FakeGPSVelIndoor", + "value": 1 + }, + { + "name": "FakeGPSVelAirspeed", + "value": 1000 + } + ] + } + ], + "id": "5E91213C", + "instance": 0, + "name": "EKFConfiguration", + "setting": true + } + ], + "owner": "Jim Allen", + "photo": "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", + "propeller": "6x3 HQ", + "servo": "", + "size": "320mm", + "subtype": 2, + "type": 1, + "uuid": "{90300d44-3050-4539-847e-a0b41edda68f}", + "weight": "530" +} From ad205b599892dfcf8043b04e1b39f6d3da464303 Mon Sep 17 00:00:00 2001 From: David Ankers Date: Tue, 14 Apr 2015 08:48:24 +1000 Subject: [PATCH 55/75] OP-1831 - Update Ki Limits --- shared/uavobjectdefinition/stabilizationbank.xml | 6 +++--- shared/uavobjectdefinition/stabilizationsettingsbank1.xml | 6 +++--- shared/uavobjectdefinition/stabilizationsettingsbank2.xml | 6 +++--- shared/uavobjectdefinition/stabilizationsettingsbank3.xml | 6 +++--- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/shared/uavobjectdefinition/stabilizationbank.xml b/shared/uavobjectdefinition/stabilizationbank.xml index c40b907a9..c740521a5 100644 --- a/shared/uavobjectdefinition/stabilizationbank.xml +++ b/shared/uavobjectdefinition/stabilizationbank.xml @@ -9,9 +9,9 @@ - - - + + + diff --git a/shared/uavobjectdefinition/stabilizationsettingsbank1.xml b/shared/uavobjectdefinition/stabilizationsettingsbank1.xml index 4e17a7b54..0d9f4bd7e 100644 --- a/shared/uavobjectdefinition/stabilizationsettingsbank1.xml +++ b/shared/uavobjectdefinition/stabilizationsettingsbank1.xml @@ -9,9 +9,9 @@ - - - + + + diff --git a/shared/uavobjectdefinition/stabilizationsettingsbank2.xml b/shared/uavobjectdefinition/stabilizationsettingsbank2.xml index 22ba9cb29..d57e46c0c 100644 --- a/shared/uavobjectdefinition/stabilizationsettingsbank2.xml +++ b/shared/uavobjectdefinition/stabilizationsettingsbank2.xml @@ -9,9 +9,9 @@ - - - + + + diff --git a/shared/uavobjectdefinition/stabilizationsettingsbank3.xml b/shared/uavobjectdefinition/stabilizationsettingsbank3.xml index 31d7df0e8..bb2cf5fa0 100644 --- a/shared/uavobjectdefinition/stabilizationsettingsbank3.xml +++ b/shared/uavobjectdefinition/stabilizationsettingsbank3.xml @@ -9,9 +9,9 @@ - - - + + + From 9ddb3097d6a22939870449bc103d8d2d093015d5 Mon Sep 17 00:00:00 2001 From: Alessio Morale Date: Tue, 28 Apr 2015 23:56:56 +0200 Subject: [PATCH 56/75] Fix WhatsNew for release --- WHATSNEW.txt | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/WHATSNEW.txt b/WHATSNEW.txt index 50222ec90..d18dcabbc 100644 --- a/WHATSNEW.txt +++ b/WHATSNEW.txt @@ -1,3 +1,21 @@ +--- RELEASE-15.02.02-RC1 --- +This release fixes a bug that prevents revo onboard mag to work correctly. + +Release Notes - OpenPilot - Version RELEASE-15.02.02 + +The full list of bugfixes in this release is accessible here: +https://progress.openpilot.org/issues/?filter=12262 + +** Bug + * [OP-1820] - fix onboard mag orientation + * [OP-1821] - Tricopter tail servo wrong speed on wizard + * [OP-1827] - Version ID wrong in Windows uninstaller + +** Task + * [OP-1831] - due to oneshot higher pid values ki now shows "red" warning in stabilization page + + + --- RELEASE-15.02.01 --- This release fixes an in important bug that may prevent failsafe to work correctly using CC3D/CC with a PWM receiver. From 8b3e42f980587a0bf392c96511a561cd54f97fc5 Mon Sep 17 00:00:00 2001 From: Laurent Lalanne Date: Sat, 2 May 2015 16:11:13 +0200 Subject: [PATCH 57/75] OP-1827 File encoding, "Ragin' Cajun" --- package/winx86/openpilotgcs.nsi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package/winx86/openpilotgcs.nsi b/package/winx86/openpilotgcs.nsi index 6dc9151d2..f33d0150c 100644 --- a/package/winx86/openpilotgcs.nsi +++ b/package/winx86/openpilotgcs.nsi @@ -296,7 +296,7 @@ Section ; create uninstall info WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "UninstallString" '"$INSTDIR\Uninstall.exe"' WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "DisplayIcon" '"$INSTDIR\bin\openpilotgcs.exe"' WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "Publisher" "OpenPilot Team" - WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "DisplayVersion" "Ragin’ Cajun" + WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "DisplayVersion" "Ragin' Cajun" WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "URLInfoAbout" "http://www.openpilot.org" WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "HelpLink" "http://wiki.openpilot.org" WriteRegDWORD HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\OpenPilot" "EstimatedSize" 100600 From aad33bc2f0d85a1ca2224ee1503c1c249679013b Mon Sep 17 00:00:00 2001 From: Alessio Morale Date: Sat, 9 May 2015 17:40:25 +0200 Subject: [PATCH 58/75] Update WHATSNEW.txt - rel-15.02.02-RC2 --- WHATSNEW.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/WHATSNEW.txt b/WHATSNEW.txt index d18dcabbc..f91e24178 100644 --- a/WHATSNEW.txt +++ b/WHATSNEW.txt @@ -1,4 +1,4 @@ ---- RELEASE-15.02.02-RC1 --- +--- RELEASE-15.02.02-RC2 --- This release fixes a bug that prevents revo onboard mag to work correctly. Release Notes - OpenPilot - Version RELEASE-15.02.02 @@ -10,6 +10,7 @@ https://progress.openpilot.org/issues/?filter=12262 * [OP-1820] - fix onboard mag orientation * [OP-1821] - Tricopter tail servo wrong speed on wizard * [OP-1827] - Version ID wrong in Windows uninstaller + * [OP-1872] - Vehicle Wiz Tricopter tail servo settings don't save ** Task * [OP-1831] - due to oneshot higher pid values ki now shows "red" warning in stabilization page From 463a0a999603f4a150f98ed65c640cdde886e4d6 Mon Sep 17 00:00:00 2001 From: Laurent Lalanne Date: Sun, 3 May 2015 13:27:39 +0200 Subject: [PATCH 59/75] Update WHATSNEW.txt - rel-15.02.02-RC3 --- WHATSNEW.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/WHATSNEW.txt b/WHATSNEW.txt index f91e24178..59f26f2d8 100644 --- a/WHATSNEW.txt +++ b/WHATSNEW.txt @@ -1,4 +1,4 @@ ---- RELEASE-15.02.02-RC2 --- +--- RELEASE-15.02.02-RC3 --- This release fixes a bug that prevents revo onboard mag to work correctly. Release Notes - OpenPilot - Version RELEASE-15.02.02 @@ -10,6 +10,7 @@ https://progress.openpilot.org/issues/?filter=12262 * [OP-1820] - fix onboard mag orientation * [OP-1821] - Tricopter tail servo wrong speed on wizard * [OP-1827] - Version ID wrong in Windows uninstaller + * [OP-1857] - PPM on Flexi does not work on CC/CC3D * [OP-1872] - Vehicle Wiz Tricopter tail servo settings don't save ** Task From 43ec4647370673f91a16603830f36af6deaba507 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Sun, 10 May 2015 19:05:36 +1000 Subject: [PATCH 60/75] OP-1848 altvario improvements 1. Avoid neutral thrust calcs in altvario typically used in forward flight 2. Capture stick state for debugging into altitudeholdstatus --- flight/libraries/pid/pidcontroldown.cpp | 2 +- flight/libraries/pid/pidcontroldown.h | 11 ++++++++++- flight/modules/PathFollower/vtolflycontroller.cpp | 3 +++ flight/modules/Stabilization/altitudeloop.cpp | 6 ++++++ shared/uavobjectdefinition/altitudeholdstatus.xml | 1 + 5 files changed, 21 insertions(+), 2 deletions(-) diff --git a/flight/libraries/pid/pidcontroldown.cpp b/flight/libraries/pid/pidcontroldown.cpp index 04ae1cddf..7f06eac93 100644 --- a/flight/libraries/pid/pidcontroldown.cpp +++ b/flight/libraries/pid/pidcontroldown.cpp @@ -59,7 +59,7 @@ extern "C" { PIDControlDown::PIDControlDown() : deltaTime(0.0f), mVelocitySetpointTarget(0.0f), mVelocitySetpointCurrent(0.0f), mVelocityState(0.0f), mDownCommand(0.0f), mCallback(NULL), mNeutral(0.5f), mVelocityMax(1.0f), mPositionSetpointTarget(0.0f), mPositionState(0.0f), - mMinThrust(0.1f), mMaxThrust(0.6f), mActive(false) + mMinThrust(0.1f), mMaxThrust(0.6f), mActive(false), mAllowNeutralThrustCalc(true) { Deactivate(); } diff --git a/flight/libraries/pid/pidcontroldown.h b/flight/libraries/pid/pidcontroldown.h index b7c215430..854daa955 100644 --- a/flight/libraries/pid/pidcontroldown.h +++ b/flight/libraries/pid/pidcontroldown.h @@ -58,6 +58,14 @@ public: void ControlPositionWithPath(struct path_status *progress); void UpdateBrakeVelocity(float startingVelocity, float dT, float brakeRate, float currentVelocity, float *updatedVelocity); void UpdateVelocityStateWithBrake(float pvDown, float path_time, float brakeRate); + void DisableNeutralThrustCalc() + { + mAllowNeutralThrustCalc = false; + } + void EnableNeutralThrustCalc() + { + mAllowNeutralThrustCalc = true; + } private: void setup_neutralThrustCalc(); @@ -77,7 +85,6 @@ private: float mPositionState; float mMinThrust; float mMaxThrust; - uint8_t mActive; struct NeutralThrustEstimation { uint32_t count; @@ -90,6 +97,8 @@ private: bool have_correction; }; struct NeutralThrustEstimation neutralThrustEst; + bool mActive; + bool mAllowNeutralThrustCalc; }; #endif // PIDCONTROLDOWN_H diff --git a/flight/modules/PathFollower/vtolflycontroller.cpp b/flight/modules/PathFollower/vtolflycontroller.cpp index 0160d0e79..20a387277 100644 --- a/flight/modules/PathFollower/vtolflycontroller.cpp +++ b/flight/modules/PathFollower/vtolflycontroller.cpp @@ -145,6 +145,9 @@ void VtolFlyController::SettingsUpdated(void) VtolSelfTuningStatsGet(&vtolSelfTuningStats); controlDown.UpdateNeutralThrust(vtolSelfTuningStats.NeutralThrustOffset + vtolPathFollowerSettings->ThrustLimits.Neutral); controlDown.SetThrustLimits(vtolPathFollowerSettings->ThrustLimits.Min, vtolPathFollowerSettings->ThrustLimits.Max); + + // disable neutral thrust calcs which should only be done in a hold mode. + controlDown.DisableNeutralThrustCalc(); } /** diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index 4c406f868..2cf141c82 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -141,17 +141,20 @@ static void altitudeHoldTask(void) controlDown.UpdatePositionState(positionStateDown); controlDown.ControlPosition(); altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); + altitudeHoldStatus.State = ALTITUDEHOLDSTATUS_STATE_ALTITUDEHOLD; thrustDemand = controlDown.GetDownCommand(); } break; case ALTITUDEVARIO: altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); + altitudeHoldStatus.State = ALTITUDEHOLDSTATUS_STATE_ALTITUDEVARIO; thrustDemand = controlDown.GetDownCommand(); break; case DIRECT: altitudeHoldStatus.VelocityDesired = 0.0f; + altitudeHoldStatus.State = ALTITUDEHOLDSTATUS_STATE_DIRECT; break; } @@ -202,6 +205,9 @@ static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) // initialise limits on thrust but note the FSM can override. controlDown.SetThrustLimits(altitudeHoldSettings.ThrustLimits.Min, altitudeHoldSettings.ThrustLimits.Max); + + // disable neutral thrust calcs which should only be done in a hold mode. + controlDown.DisableNeutralThrustCalc(); } diff --git a/shared/uavobjectdefinition/altitudeholdstatus.xml b/shared/uavobjectdefinition/altitudeholdstatus.xml index f298a45ab..293c5df34 100644 --- a/shared/uavobjectdefinition/altitudeholdstatus.xml +++ b/shared/uavobjectdefinition/altitudeholdstatus.xml @@ -2,6 +2,7 @@ Status Data from Altitude Hold Control Loops + From 38f0a609daf221d87cdb03a587a3dc5412a534db Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Sun, 10 May 2015 15:59:08 -0400 Subject: [PATCH 61/75] Fix Google Map tiles, https://maps.google.com/maps?output=classic is now depreciated. Legacy view temporarily available via https://www.google.com/lochp Need to update to Google Maps v3 soon. New URL will be https://www.google.com/maps/@0,-0,7z?dg=dbrw&newdg=1 (tile retrieval is completely different) Fix location search. Updated to v3 Google GeoCoder. CSV is no longer an option for output. Updated to XML parsed output. (needs a more robust parser!) New Geocode search urls are as follows: https://maps.googleapis.com/maps/api/geocode/xml?sensor=false&address=california https://maps.googleapis.com/maps/api/geocode/xml?latlng=0.000000,-0.000000 Need to fix response after SetCurrentPositionByKeywords() all responses shade the box Green currently. --- .../src/libs/opmapcontrol/opmapcontrol.pro | 2 + .../src/libs/opmapcontrol/src/core/core.pro | 2 + .../libs/opmapcontrol/src/core/urlfactory.cpp | 152 +++++++++++++++--- .../libs/opmapcontrol/src/core/urlfactory.h | 4 +- .../libs/opmapcontrol/src/internals/core.cpp | 12 +- 5 files changed, 148 insertions(+), 24 deletions(-) diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/opmapcontrol.pro b/ground/openpilotgcs/src/libs/opmapcontrol/opmapcontrol.pro index dee478c28..1f27742bd 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/opmapcontrol.pro +++ b/ground/openpilotgcs/src/libs/opmapcontrol/opmapcontrol.pro @@ -2,3 +2,5 @@ TEMPLATE = subdirs SUBDIRS = src \ + +QT += xml diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/core.pro b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/core.pro index d606082a1..912d292fe 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/core.pro +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/core.pro @@ -38,3 +38,5 @@ HEADERS += opmaps.h \ kibertilecache.h \ debugheader.h \ diagnostics.h + +QT += xml diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp index e033d58dc..4df06c916 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp @@ -26,7 +26,8 @@ */ #include "urlfactory.h" #include - +#include +#include namespace core { const double UrlFactory::EarthRadiusKm = 6378.137; // WGS-84 @@ -97,6 +98,12 @@ void UrlFactory::TryCorrectGoogleVersions() if (CorrectGoogleVersions && !IsCorrectGoogleVersions()) { QNetworkReply *reply; QNetworkRequest qheader; + // This SSL Hack is half assed... technically bad *security* joojoo. + // Required due to a QT5 bug on linux and Mac + // + QSslConfiguration conf = qheader.sslConfiguration(); + conf.setPeerVerifyMode(QSslSocket::VerifyNone); + qheader.setSslConfiguration(conf); QNetworkAccessManager network; QEventLoop q; QTimer tT; @@ -109,7 +116,10 @@ void UrlFactory::TryCorrectGoogleVersions() qDebug() << "Correct GoogleVersion"; #endif // DEBUG_URLFACTORY // setIsCorrectGoogleVersions(true); - QString url = "https://maps.google.com/maps?output=classic"; + // QString url = "https://www.google.com/maps/@0,-0,7z?dg=dbrw&newdg=1"; + // We need to switch to the Above url... the /lochp method will be depreciated soon + // https://productforums.google.com/forum/#!category-topic/maps/navigation/k6EFrp7J7Jk + QString url = "https://www.google.com/lochp"; qheader.setUrl(QUrl(url)); qheader.setRawHeader("User-Agent", UserAgent); @@ -126,7 +136,12 @@ void UrlFactory::TryCorrectGoogleVersions() #endif // DEBUG_URLFACTORY return; } + QString html = QString(reply->readAll()); +#ifdef DEBUG_URLFACTORY + qDebug() << html; +#endif // DEBUG_URLFACTORY + QRegExp reg("\"*https://mts0.google.com/vt/lyrs=m@(\\d*)", Qt::CaseInsensitive); if (reg.indexIn(html) != -1) { QStringList gc = reg.capturedTexts(); @@ -148,6 +163,7 @@ void UrlFactory::TryCorrectGoogleVersions() qDebug() << "TryCorrectGoogleVersions, VersionGoogleLabels: " << VersionGoogleLabels; #endif // DEBUG_URLFACTORY } + reg = QRegExp("\"*https://khms0.google.com/kh/v=(\\d*)", Qt::CaseInsensitive); if (reg.indexIn(html) != -1) { QStringList gc = reg.capturedTexts(); @@ -157,6 +173,7 @@ void UrlFactory::TryCorrectGoogleVersions() qDebug() << "TryCorrectGoogleVersions, VersionGoogleSatellite: " << VersionGoogleSatellite; } + reg = QRegExp("\"*https://mts0.google.com/vt/lyrs=t@(\\d*),r@(\\d*)", Qt::CaseInsensitive); if (reg.indexIn(html) != -1) { QStringList gc = reg.capturedTexts(); @@ -492,23 +509,29 @@ void UrlFactory::GetSecGoogleWords(const Point &pos, QString &sec1, QString &sec QString UrlFactory::MakeGeocoderUrl(QString keywords) { QString key = keywords.replace(' ', '+'); - - return QString("http://maps.google.com/maps/geo?q=%1&output=csv&key=%2").arg(key).arg(GoogleMapsAPIKey); + // CSV output has been depreciated. API key is no longer needed. + return QString("https://maps.googleapis.com/maps/api/geocode/xml?sensor=false&address=%1").arg(key); } QString UrlFactory::MakeReverseGeocoderUrl(internals::PointLatLng &pt, const QString &language) { - return QString("http://maps.google.com/maps/geo?hl=%1&ll=%2,%3&output=csv&key=%4").arg(language).arg(QString::number(pt.Lat())).arg(QString::number(pt.Lng())).arg(GoogleMapsAPIKey); + // CSV output has been depreciated. API key is no longer needed. + return QString("https://maps.googleapis.com/maps/api/geocode/xml?latlng=%1,%2").arg(QString::number(pt.Lat())).arg(QString::number(pt.Lng())); } -internals::PointLatLng UrlFactory::GetLatLngFromGeodecoder(const QString &keywords, GeoCoderStatusCode::Types &status) +internals::PointLatLng UrlFactory::GetLatLngFromGeodecoder(const QString &keywords, QString &status) { return GetLatLngFromGeocoderUrl(MakeGeocoderUrl(keywords), UseGeocoderCache, status); } -internals::PointLatLng UrlFactory::GetLatLngFromGeocoderUrl(const QString &url, const bool &useCache, GeoCoderStatusCode::Types &status) + +QString latxml; +QString lonxml; +//QString status; + +internals::PointLatLng UrlFactory::GetLatLngFromGeocoderUrl(const QString &url, const bool &useCache, QString &status) { #ifdef DEBUG_URLFACTORY qDebug() << "Entered GetLatLngFromGeocoderUrl:"; #endif // DEBUG_URLFACTORY - status = GeoCoderStatusCode::Unknow; + status = "ZERO_RESULTS"; internals::PointLatLng ret(0, 0); QString urlEnd = url.mid(url.indexOf("geo?q=") + 6); urlEnd.replace(QRegExp( @@ -529,6 +552,10 @@ internals::PointLatLng UrlFactory::GetLatLngFromGeocoderUrl(const QString &url, #endif // DEBUG_URLFACTORY QNetworkReply *reply; QNetworkRequest qheader; + // Lame hack *SSL security == none, bypass QT bug + QSslConfiguration conf = qheader.sslConfiguration(); + conf.setPeerVerifyMode(QSslSocket::VerifyNone); + qheader.setSslConfiguration(conf); QNetworkAccessManager network; network.setProxy(Proxy); qheader.setUrl(QUrl(url)); @@ -557,6 +584,82 @@ internals::PointLatLng UrlFactory::GetLatLngFromGeocoderUrl(const QString &url, #endif // DEBUG_URLFACTORY geo = reply->readAll(); + qDebug() << geo; // This is the response from the geocode request (no longer in CSV) + + // This is SOOOO horribly hackish, code duplication needs to go. Needed a quick fix. + QXmlStreamReader reader(geo); + while(!reader.atEnd()) + { + reader.readNext(); + + if(reader.isStartElement()) + { + if(reader.name() == "lat") + { + reader.readNext(); + if(reader.atEnd()) + break; + + if(reader.isCharacters()) + { + QString text = reader.text().toString(); + qDebug() << text; + latxml = text; + break; + } + } + } + + } + + while(!reader.atEnd()) + { + reader.readNext(); + + if(reader.isStartElement()) + { + if(reader.name() == "lng") + { + reader.readNext(); + if(reader.atEnd()) + break; + + if(reader.isCharacters()) + { + QString text = reader.text().toString(); + qDebug() << text; + lonxml = text; + break; + } + } + } + + } + + QXmlStreamReader reader2(geo); + while(!reader2.atEnd()) + { + reader2.readNext(); + + if(reader2.isStartElement()) + { + if(reader2.name() == "status") + { + reader2.readNext(); + if(reader2.atEnd()) + break; + + if(reader2.isCharacters()) + { + QString text = reader2.text().toString(); + qDebug() << text; + status = text; + break; + } + } + } + + } // cache geocoding if (useCache && geo.startsWith("200")) { @@ -567,23 +670,36 @@ internals::PointLatLng UrlFactory::GetLatLngFromGeocoderUrl(const QString &url, } - // parse values - // true : 200,4,56.1451640,22.0681787 - // false: 602,0,0,0 { - QStringList values = geo.split(','); - if (values.count() == 4) { - status = (GeoCoderStatusCode::Types)QString(values[0]).toInt(); - if (status == GeoCoderStatusCode::G_GEO_SUCCESS) { - double lat = QString(values[2]).toDouble(); - double lng = QString(values[3]).toDouble(); + if (status == "OK") { + double lat = QString(latxml).toDouble(); + double lng = QString(lonxml).toDouble(); ret = internals::PointLatLng(lat, lng); #ifdef DEBUG_URLFACTORY + qDebug() << "Status is: " << status; qDebug() << "Lat=" << lat << " Lng=" << lng; #endif // DEBUG_URLFACTORY } - } + else if (status == "ZERO_RESULTS") { + qDebug() << "No results"; + } + else if (status == "OVER_QUERY_LIMIT") { + qDebug() << "You are over quota on queries"; + } + else if (status == "REQUEST_DENIED") { + qDebug() << "Request was denied"; + } + else if (status == "INVALID_REQUEST") { + qDebug() << "Invalid request, missing address, lat long or location"; + } + else if (status == "UNKNOWN_ERROR") { + qDebug() << "Some sort of server error."; + } + else + { + qDebug() << "UrlFactory loop error"; + } } return ret; } diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.h b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.h index ace8b52d3..76de69f0b 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.h +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.h @@ -56,7 +56,7 @@ public: UrlFactory(); ~UrlFactory(); QString MakeImageUrl(const MapType::Types &type, const core::Point &pos, const int &zoom, const QString &language); - internals::PointLatLng GetLatLngFromGeodecoder(const QString &keywords, GeoCoderStatusCode::Types &status); + internals::PointLatLng GetLatLngFromGeodecoder(const QString &keywords, QString &status); Placemark GetPlacemarkFromGeocoder(internals::PointLatLng location); int Timeout; private: @@ -79,7 +79,7 @@ protected: void setIsCorrectGoogleVersions(bool value); QString MakeGeocoderUrl(QString keywords); QString MakeReverseGeocoderUrl(internals::PointLatLng &pt, const QString &language); - internals::PointLatLng GetLatLngFromGeocoderUrl(const QString &url, const bool &useCache, GeoCoderStatusCode::Types &status); + internals::PointLatLng GetLatLngFromGeocoderUrl(const QString &url, const bool &useCache, QString &status); Placemark GetPlacemarkFromReverseGeocoderUrl(const QString &url, const bool &useCache); }; } diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp index b56d84e75..bdeb54ed1 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp @@ -379,14 +379,18 @@ void Core::OnMapClose() } GeoCoderStatusCode::Types Core::SetCurrentPositionByKeywords(QString const & keys) { - GeoCoderStatusCode::Types status = GeoCoderStatusCode::Unknow; + QString status = "ZERO_RESULTS"; PointLatLng pos = OPMaps::Instance()->GetLatLngFromGeodecoder(keys, status); - if (!pos.IsEmpty() && (status == GeoCoderStatusCode::G_GEO_SUCCESS)) { + if (!pos.IsEmpty() && (status == "OK")) { SetCurrentPosition(pos); } - - return status; + else + { + qDebug() << "Status is not OK: " << status; + } + //return status; + return GeoCoderStatusCode::G_GEO_SUCCESS; } RectLatLng Core::CurrentViewArea() { From 390a8cccb51a4d9ad4399ad77114ff9a6632b51c Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Sun, 10 May 2015 16:36:01 -0400 Subject: [PATCH 62/75] Add search coloring back to the location search. Google Maps should be functional again. Some locations on the extents of map do not render 'North Pole, South Pole, Antarctica, etc.' currently a *non issue* --- .../libs/opmapcontrol/src/core/urlfactory.cpp | 5 ++-- .../libs/opmapcontrol/src/internals/core.cpp | 5 ++-- .../libs/opmapcontrol/src/internals/core.h | 2 +- .../src/mapwidget/mapgraphicitem.h | 2 +- .../opmapcontrol/src/mapwidget/opmapwidget.h | 2 +- .../src/plugins/opmap/opmapgadgetwidget.cpp | 28 +++++++++++++++++-- 6 files changed, 32 insertions(+), 12 deletions(-) diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp index 4df06c916..d802acb99 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp @@ -579,12 +579,11 @@ internals::PointLatLng UrlFactory::GetLatLngFromGeocoderUrl(const QString &url, return internals::PointLatLng(0, 0); } { + geo = reply->readAll(); #ifdef DEBUG_URLFACTORY qDebug() << "GetLatLngFromGeocoderUrl:Reply ok"; -#endif // DEBUG_URLFACTORY - geo = reply->readAll(); - qDebug() << geo; // This is the response from the geocode request (no longer in CSV) +#endif // DEBUG_URLFACTORY // This is SOOOO horribly hackish, code duplication needs to go. Needed a quick fix. QXmlStreamReader reader(geo); diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp index bdeb54ed1..f85b17958 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.cpp @@ -377,7 +377,7 @@ void Core::OnMapClose() CancelAsyncTasks(); } -GeoCoderStatusCode::Types Core::SetCurrentPositionByKeywords(QString const & keys) +QString Core::SetCurrentPositionByKeywords(QString const & keys) { QString status = "ZERO_RESULTS"; PointLatLng pos = OPMaps::Instance()->GetLatLngFromGeodecoder(keys, status); @@ -389,8 +389,7 @@ GeoCoderStatusCode::Types Core::SetCurrentPositionByKeywords(QString const & key { qDebug() << "Status is not OK: " << status; } - //return status; - return GeoCoderStatusCode::G_GEO_SUCCESS; + return status; } RectLatLng Core::CurrentViewArea() { diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.h b/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.h index 9998f0408..7bcae973b 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.h +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/internals/core.h @@ -266,7 +266,7 @@ public: void OnMapClose(); // TODO had as slot - GeoCoderStatusCode::Types SetCurrentPositionByKeywords(QString const & keys); + QString SetCurrentPositionByKeywords(QString const & keys); RectLatLng CurrentViewArea(); diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/mapgraphicitem.h b/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/mapgraphicitem.h index e1b2c5d88..463800fb1 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/mapgraphicitem.h +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/mapgraphicitem.h @@ -229,7 +229,7 @@ private: { core->ReloadMap(); } - GeoCoderStatusCode::Types SetCurrentPositionByKeywords(QString const & keys) + QString SetCurrentPositionByKeywords(QString const & keys) { return core->SetCurrentPositionByKeywords(keys); } diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/opmapwidget.h b/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/opmapwidget.h index 005509908..895baf452 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/opmapwidget.h +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/mapwidget/opmapwidget.h @@ -350,7 +350,7 @@ public: map->ReloadMap(); map->resize(); } - GeoCoderStatusCode::Types SetCurrentPositionByKeywords(QString const & keys) + QString SetCurrentPositionByKeywords(QString const & keys) { return map->SetCurrentPositionByKeywords(keys); } diff --git a/ground/openpilotgcs/src/plugins/opmap/opmapgadgetwidget.cpp b/ground/openpilotgcs/src/plugins/opmap/opmapgadgetwidget.cpp index 3a122afb9..98d0a267a 100644 --- a/ground/openpilotgcs/src/plugins/opmap/opmapgadgetwidget.cpp +++ b/ground/openpilotgcs/src/plugins/opmap/opmapgadgetwidget.cpp @@ -2320,16 +2320,38 @@ void OPMapGadgetWidget::on_tbFind_clicked() { QPalette pal = m_widget->leFind->palette(); - int result = m_map->SetCurrentPositionByKeywords(m_widget->leFind->text()); + QString status = m_map->SetCurrentPositionByKeywords(m_widget->leFind->text()); - if (result == core::GeoCoderStatusCode::G_GEO_SUCCESS) { + if (status == "OK") { pal.setColor(m_widget->leFind->backgroundRole(), Qt::green); m_widget->leFind->setPalette(pal); m_map->SetZoom(12); - } else { + } else if (status == "ZERO_RESULTS") { pal.setColor(m_widget->leFind->backgroundRole(), Qt::red); m_widget->leFind->setPalette(pal); + qDebug() << "No results"; + } else if (status == "OVER_QUERY_LIMIT") { + pal.setColor(m_widget->leFind->backgroundRole(), Qt::yellow); + m_widget->leFind->setPalette(pal); + qDebug() << "You are over quota on queries"; + } else if (status == "REQUEST_DENIED") { + pal.setColor(m_widget->leFind->backgroundRole(), Qt::darkRed); + m_widget->leFind->setPalette(pal); + qDebug() << "Request was denied"; + } else if (status == "INVALID_REQUEST") { + pal.setColor(m_widget->leFind->backgroundRole(), Qt::darkYellow); + m_widget->leFind->setPalette(pal); + qDebug() << "Invalid request, missing address, lat long or location"; + } else if (status == "UNKNOWN_ERROR") { + pal.setColor(m_widget->leFind->backgroundRole(), Qt::darkYellow); + m_widget->leFind->setPalette(pal); + qDebug() << "Some sort of server error."; + } else { + pal.setColor(m_widget->leFind->backgroundRole(), Qt::gray); + m_widget->leFind->setPalette(pal); + qDebug() << "Some sort of code error!"; } + } void OPMapGadgetWidget::onHomeDoubleClick(HomeItem *) From 06d0df69b60229043616055ed0b99c76e6e717e0 Mon Sep 17 00:00:00 2001 From: Alessio Morale Date: Sun, 10 May 2015 23:19:52 +0200 Subject: [PATCH 63/75] Update WHATSNEW.txt - rel-15.02.02-RC4 --- WHATSNEW.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/WHATSNEW.txt b/WHATSNEW.txt index 59f26f2d8..0eca1973e 100644 --- a/WHATSNEW.txt +++ b/WHATSNEW.txt @@ -1,4 +1,4 @@ ---- RELEASE-15.02.02-RC3 --- +--- RELEASE-15.02.02-RC4 --- This release fixes a bug that prevents revo onboard mag to work correctly. Release Notes - OpenPilot - Version RELEASE-15.02.02 @@ -11,7 +11,6 @@ https://progress.openpilot.org/issues/?filter=12262 * [OP-1821] - Tricopter tail servo wrong speed on wizard * [OP-1827] - Version ID wrong in Windows uninstaller * [OP-1857] - PPM on Flexi does not work on CC/CC3D - * [OP-1872] - Vehicle Wiz Tricopter tail servo settings don't save ** Task * [OP-1831] - due to oneshot higher pid values ki now shows "red" warning in stabilization page From 9fe4fb7216d7f1d095d0a55532549f1a89cf67d9 Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Sun, 10 May 2015 22:31:48 -0400 Subject: [PATCH 64/75] Remove depreciated Yahoo maps (now uses "Here" - https://developer.here.com/rest-apis which requires an API key we don't have) No desire to implement new Here interface. Fix Yandex.ru interface to reference Yandex.net --- .../opmapcontrol/src/core/alllayersoftype.cpp | 7 ----- .../src/libs/opmapcontrol/src/core/maptype.h | 5 ---- .../src/libs/opmapcontrol/src/core/opmaps.cpp | 9 ------ .../opmapcontrol/src/core/providerstrings.cpp | 5 ---- .../opmapcontrol/src/core/providerstrings.h | 5 ---- .../libs/opmapcontrol/src/core/urlfactory.cpp | 30 ++++++++----------- 6 files changed, 12 insertions(+), 49 deletions(-) diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/alllayersoftype.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/alllayersoftype.cpp index ca615f94b..ad3033bd0 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/alllayersoftype.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/alllayersoftype.cpp @@ -55,13 +55,6 @@ QVector AllLayersOfType::GetAllLayersOfType(const MapType::Types } break; - case MapType::YahooHybrid: - { - types.append(MapType::YahooSatellite); - types.append(MapType::YahooLabels); - } - break; - case MapType::ArcGIS_MapsLT_Map_Hybrid: { types.append(MapType::ArcGIS_MapsLT_OrtoFoto); diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/maptype.h b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/maptype.h index d31844f6b..8e5569764 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/maptype.h +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/maptype.h @@ -52,11 +52,6 @@ public: OpenStreetMapSurfer = 34, OpenStreetMapSurferTerrain = 35, - YahooMap = 64, - YahooSatellite = 128, - YahooLabels = 256, - YahooHybrid = 333, - BingMap = 444, BingSatellite = 555, BingHybrid = 666, diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/opmaps.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/opmaps.cpp index fd249f66d..a39cf8b01 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/opmaps.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/opmaps.cpp @@ -153,15 +153,6 @@ QByteArray OPMaps::GetImageFrom(const MapType::Types &type, const Point &pos, co } break; - case MapType::YahooHybrid: - case MapType::YahooLabels: - case MapType::YahooMap: - case MapType::YahooSatellite: - { - qheader.setRawHeader("Referrer", "http://maps.yahoo.com/"); - } - break; - case MapType::ArcGIS_MapsLT_Map_Labels: case MapType::ArcGIS_MapsLT_Map: case MapType::ArcGIS_MapsLT_OrtoFoto: diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.cpp index 50d16bbc9..5e1f1f0c8 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.cpp @@ -61,11 +61,6 @@ ProviderStrings::ProviderStrings() /// GoogleMapsAPIKey = "ABQIAAAAWaQgWiEBF3lW97ifKnAczhRAzBk5Igf8Z5n2W3hNnMT0j2TikxTLtVIGU7hCLLHMAuAMt-BO5UrEWA"; - // Yahoo version strings - VersionYahooMap = "4.3"; - VersionYahooSatellite = "1.9"; - VersionYahooLabels = "4.3"; - // BingMaps VersionBingMaps = "563"; diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.h b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.h index 1d349e7c2..b0d2389d9 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.h +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/providerstrings.h @@ -60,11 +60,6 @@ public: /// - // Yahoo version strings - QString VersionYahooMap; - QString VersionYahooSatellite; - QString VersionYahooLabels; - // BingMaps QString VersionBingMaps; diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp index d802acb99..da92f3d6f 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp @@ -335,21 +335,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c return QString("https://%1%2.gmaptiles.co.kr/%3/v=%4&hl=%5&x=%6%7&y=%8&z=%9&s=%10").arg(server).arg(GetServerNum(pos, 4)).arg(request).arg(VersionGoogleLabelsKorea).arg(language).arg(pos.X()).arg(sec1).arg(pos.Y()).arg(zoom).arg(sec2); } break; - case MapType::YahooMap: - { - return QString("http://maps%1.yimg.com/hx/tl?v=%2&.intl=%3&x=%4&y=%5&z=%6&r=1").arg(((GetServerNum(pos, 2)) + 1)).arg(VersionYahooMap).arg(language).arg(pos.X()).arg((((1 << zoom) >> 1) - 1 - pos.Y())).arg((zoom + 1)); - } - - case MapType::YahooSatellite: - { - return QString("http://maps%1.yimg.com/ae/ximg?v=%2&t=a&s=256&.intl=%3&x=%4&y=%5&z=%6&r=1").arg("3").arg(VersionYahooSatellite).arg(language).arg(pos.X()).arg(((1 << zoom) >> 1) - 1 - pos.Y()).arg(zoom + 1); - } - break; - case MapType::YahooLabels: - { - return QString("http://maps%1.yimg.com/hx/tl?v=%2&t=h&.intl=%3&x=%4&y=%5&z=%6&r=1").arg("1").arg(VersionYahooLabels).arg(language).arg(pos.X()).arg(((1 << zoom) >> 1) - 1 - pos.Y()).arg(zoom + 1); - } - break; + // *.yimg.com has been depreciated. "Here" is what Yahoo uses now. https://developer.here.com/rest-apis/documentation/enterprise-map-tile/topics/request-constructing.html case MapType::OpenStreetMap: { char letter = "abc"[GetServerNum(pos, 3)]; @@ -483,11 +469,19 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c case MapType::YandexMapRu: { + /* + Used "oldmaps" to determine map types - https://old.maps.yandex.ru/?ll=-83.110960%2C40.091250&spn=7.745361%2C6.015476&z=7&l=map + map: 'https:\/\/vec0%d.maps.yandex.net\/tiles?l=map&%c&%l', + sat: 'https:\/\/sat0%d.maps.yandex.net\/tiles?l=sat&%c&%l', + skl: 'https:\/\/vec0%d.maps.yandex.net\/tiles?l=skl&%c&%l', + */ + QString server = "vec"; + return QString("http://%1").arg(server) + QString("0%2.maps.yandex.net/tiles?l=map&v=%3&x=%4&y=%5&z=%6").arg(GetServerNum(pos, 4) + 1).arg(VersionYandexMap).arg(pos.X()).arg(pos.Y()).arg(zoom); - // http://vec01.maps.yandex.ru/tiles?l=map&v=2.10.2&x=1494&y=650&z=11 - - return QString("http://%1").arg(server) + QString("0%2.maps.yandex.ru/tiles?l=map&v=%3&x=%4&y=%5&z=%6").arg(GetServerNum(pos, 4) + 1).arg(VersionYandexMap).arg(pos.X()).arg(pos.Y()).arg(zoom); +// Satllite maps are poor quality, but available. +// QString server = "sat"; +// return QString("http://%1").arg(server) + QString("0%2.maps.yandex.net/tiles?l=sat&v=%3&x=%4&y=%5&z=%6").arg(GetServerNum(pos, 4) + 1).arg(VersionYandexMap).arg(pos.X()).arg(pos.Y()).arg(zoom); } break; default: From 8d2f4722d74c29f7e792a72e33ad7f7fbea00570 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 12 May 2015 17:40:28 +1000 Subject: [PATCH 65/75] OP-1848 altvario improvements 1. Disable velocity pid loop when altvario is not active 2. Add sanity boundf to ensure max min are inforced. --- flight/libraries/pid/pidcontroldown.h | 4 +++ flight/modules/Stabilization/altitudeloop.cpp | 25 ++++++++++++++++--- .../modules/Stabilization/inc/altitudeloop.h | 1 + flight/modules/Stabilization/outerloop.c | 5 ++++ .../altitudeholdstatus.xml | 1 + 5 files changed, 32 insertions(+), 4 deletions(-) diff --git a/flight/libraries/pid/pidcontroldown.h b/flight/libraries/pid/pidcontroldown.h index 854daa955..8ea185610 100644 --- a/flight/libraries/pid/pidcontroldown.h +++ b/flight/libraries/pid/pidcontroldown.h @@ -44,6 +44,10 @@ public: void SetThrustLimits(float min_thrust, float max_thrust); void Deactivate(); void Activate(); + bool IsActive() + { + return mActive; + } void UpdateParameters(float kp, float ki, float kd, float beta, float dT, float velocityMax); void UpdateNeutralThrust(float neutral); void UpdateVelocitySetpoint(float setpoint); diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index 2cf141c82..a9dd5848c 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -81,7 +81,7 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit { static bool newaltitude = true; - if (reinit) { + if (reinit || !controlDown.IsActive()) { controlDown.Activate(); newaltitude = true; } @@ -97,6 +97,7 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit thrustDemand = 0.0f; thrustMode = DIRECT; newaltitude = true; + return thrustDemand; } else if (mode == ALTITUDEVARIO && setpoint > DEADBAND_HIGH) { // being the two band symmetrical I can divide by DEADBAND_LOW to scale it to a value betweeon 0 and 1 // then apply an "exp" f(x,k) = (k*x*x*x + (255-k)*x) / 255 @@ -116,23 +117,38 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit newaltitude = false; } + thrustDemand = boundf(thrustDemand, altitudeHoldSettings.ThrustLimits.Min, altitudeHoldSettings.ThrustLimits.Max); + return thrustDemand; } +/** + * Disable the alt hold task loop velocity controller to save cpu cycles + */ +void stabilizationDisableAltitudeHold(void) +{ + controlDown.Deactivate(); +} + /** * Module thread, should not return. */ static void altitudeHoldTask(void) { - AltitudeHoldStatusData altitudeHoldStatus; + if (!controlDown.IsActive()) { + return; + } + AltitudeHoldStatusData altitudeHoldStatus; AltitudeHoldStatusGet(&altitudeHoldStatus); float velocityStateDown; VelocityStateDownGet(&velocityStateDown); controlDown.UpdateVelocityState(velocityStateDown); + float local_thrustDemand = 0.0f; + switch (thrustMode) { case ALTITUDEHOLD: { @@ -142,14 +158,14 @@ static void altitudeHoldTask(void) controlDown.ControlPosition(); altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); altitudeHoldStatus.State = ALTITUDEHOLDSTATUS_STATE_ALTITUDEHOLD; - thrustDemand = controlDown.GetDownCommand(); + local_thrustDemand = controlDown.GetDownCommand(); } break; case ALTITUDEVARIO: altitudeHoldStatus.VelocityDesired = controlDown.GetVelocityDesired(); altitudeHoldStatus.State = ALTITUDEHOLDSTATUS_STATE_ALTITUDEVARIO; - thrustDemand = controlDown.GetDownCommand(); + local_thrustDemand = controlDown.GetDownCommand(); break; case DIRECT: @@ -159,6 +175,7 @@ static void altitudeHoldTask(void) } AltitudeHoldStatusSet(&altitudeHoldStatus); + thrustDemand = local_thrustDemand; } static void VelocityStateUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) diff --git a/flight/modules/Stabilization/inc/altitudeloop.h b/flight/modules/Stabilization/inc/altitudeloop.h index d4789c6eb..f29709149 100644 --- a/flight/modules/Stabilization/inc/altitudeloop.h +++ b/flight/modules/Stabilization/inc/altitudeloop.h @@ -37,5 +37,6 @@ typedef enum { ALTITUDEHOLD = 0, ALTITUDEVARIO = 1, DIRECT = 2 } ThrustModeType; void stabilizationAltitudeloopInit(); float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit); +void stabilizationDisableAltitudeHold(void); #endif /* ALTITUDELOOP_H */ diff --git a/flight/modules/Stabilization/outerloop.c b/flight/modules/Stabilization/outerloop.c index 923018004..791f595cb 100644 --- a/flight/modules/Stabilization/outerloop.c +++ b/flight/modules/Stabilization/outerloop.c @@ -107,6 +107,11 @@ static void stabilizationOuterloopTask() bool reinit = (StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST] != previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST]); previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST]; + if (reinit && (previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] == STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE || + previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] == STABILIZATIONSTATUS_OUTERLOOP_ALTITUDEVARIO)) { + // disable the altvario velocity control loop + stabilizationDisableAltitudeHold(); + } switch (StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST]) { #ifdef REVOLUTION case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE: diff --git a/shared/uavobjectdefinition/altitudeholdstatus.xml b/shared/uavobjectdefinition/altitudeholdstatus.xml index 293c5df34..0918785c5 100644 --- a/shared/uavobjectdefinition/altitudeholdstatus.xml +++ b/shared/uavobjectdefinition/altitudeholdstatus.xml @@ -3,6 +3,7 @@ Status Data from Altitude Hold Control Loops + From e0919542e7d449aec9dd5d7098ebb0a6a792ffd2 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 12 May 2015 17:45:07 +1000 Subject: [PATCH 66/75] OP-1848r-altvario updated Kp, Ki, Kd --- shared/uavobjectdefinition/altitudeholdsettings.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shared/uavobjectdefinition/altitudeholdsettings.xml b/shared/uavobjectdefinition/altitudeholdsettings.xml index 1763d5568..e85ff09e6 100644 --- a/shared/uavobjectdefinition/altitudeholdsettings.xml +++ b/shared/uavobjectdefinition/altitudeholdsettings.xml @@ -6,7 +6,7 @@ - + From 794605b3d9d84b470eb6a0b9635a4e51a24e4eb3 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 12 May 2015 22:02:03 +1000 Subject: [PATCH 67/75] OP-1848 altvario fixes 1. CC compile fix 2. on reinit calculate a new thrustdemand after which gyro updates will retrigger subsequent calcs --- flight/modules/Stabilization/altitudeloop.cpp | 2 ++ flight/modules/Stabilization/outerloop.c | 2 ++ 2 files changed, 4 insertions(+) diff --git a/flight/modules/Stabilization/altitudeloop.cpp b/flight/modules/Stabilization/altitudeloop.cpp index a9dd5848c..dab918ae4 100644 --- a/flight/modules/Stabilization/altitudeloop.cpp +++ b/flight/modules/Stabilization/altitudeloop.cpp @@ -84,6 +84,8 @@ float stabilizationAltitudeHold(float setpoint, ThrustModeType mode, bool reinit if (reinit || !controlDown.IsActive()) { controlDown.Activate(); newaltitude = true; + // calculate a thrustDemand on reinit only + altitudeHoldTask(); } const float DEADBAND = 0.20f; diff --git a/flight/modules/Stabilization/outerloop.c b/flight/modules/Stabilization/outerloop.c index 791f595cb..1fb2a4061 100644 --- a/flight/modules/Stabilization/outerloop.c +++ b/flight/modules/Stabilization/outerloop.c @@ -107,11 +107,13 @@ static void stabilizationOuterloopTask() bool reinit = (StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST] != previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST]); previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] = StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST]; +#ifdef REVOLUTION if (reinit && (previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] == STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE || previous_mode[STABILIZATIONSTATUS_OUTERLOOP_THRUST] == STABILIZATIONSTATUS_OUTERLOOP_ALTITUDEVARIO)) { // disable the altvario velocity control loop stabilizationDisableAltitudeHold(); } +#endif /* REVOLUTION */ switch (StabilizationStatusOuterLoopToArray(enabled)[STABILIZATIONSTATUS_OUTERLOOP_THRUST]) { #ifdef REVOLUTION case STABILIZATIONSTATUS_OUTERLOOP_ALTITUDE: From 65ecec8af8f275830302c11561454d4ba6edb51e Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 12 May 2015 22:34:18 +1000 Subject: [PATCH 68/75] OP-1848 altvario ui fix for Ki on altvario --- ground/openpilotgcs/src/plugins/config/stabilization.ui | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index c4f1812fd..ab60e57f1 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -25317,7 +25317,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Ki - scale:0.1 + scale:0.01 haslimits:yes buttongroup:98 @@ -25364,7 +25364,7 @@ border-radius: 5; objname:AltitudeHoldSettings fieldname:VerticalVelPID element:Ki - scale:0.1 + scale:0.01 haslimits:yes buttongroup:98,10 From 33673134320bc748376220471f46a0601b5b1923 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Tue, 12 May 2015 22:48:49 +1000 Subject: [PATCH 69/75] OP-1848 altvario gcs fix ranges --- .../src/plugins/config/stabilization.ui | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index ab60e57f1..aa5b3b553 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -8244,7 +8244,7 @@ border-radius: 5; 0 0 - 884 + 950 736 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 839 - 670 + 950 + 671 @@ -25298,7 +25298,7 @@ border-radius: 5; <html><head/><body><p>How fast the vehicle should attain its target velocity. For neutral throttle estimation, the altitude module assumes that when engaged the throttle thrust limit neutral setting is in the range required to hover. If the throttle required is a lot higher or lower, it needs to adjust this &quot;throttle trim&quot;. Higher values make it do this adjustment faster, but this could lead to ugly oscillations. Leave at default unless you know what you are doing.</p></body></html> - 50 + 100 1 @@ -25354,7 +25354,7 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 50 + 100 25 @@ -25408,7 +25408,7 @@ border-radius: 5; <html><head/><body><p>Small abouts of Kd can reduce oscillations in the velocity controller.</p></body></html> - 700 + 300 50 @@ -25461,7 +25461,7 @@ border-radius: 5; Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - 700 + 300 51 @@ -25627,7 +25627,7 @@ border-radius: 5; 100 - 51 + 50 From 0377c3f333b956b21337f5ffd61c3157a104b356 Mon Sep 17 00:00:00 2001 From: Kevin Finisterre Date: Tue, 12 May 2015 17:35:16 -0400 Subject: [PATCH 70/75] Work through debugging faulty map rendering. Fix OpenStreetOSM option. --- .../libs/opmapcontrol/src/core/urlfactory.cpp | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp index da92f3d6f..a0ebd84d6 100644 --- a/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp +++ b/ground/openpilotgcs/src/libs/opmapcontrol/src/core/urlfactory.cpp @@ -225,7 +225,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c QString sec2 = ""; // after &zoom=... GetSecGoogleWords(pos, sec1, sec2); TryCorrectGoogleVersions(); - + qDebug() << QString("http://%1%2.google.com/%3/lyrs=%4&hl=%5&x=%6%7&y=%8&z=%9&s=%10").arg(server).arg(GetServerNum(pos, 4)).arg(request).arg(VersionGoogleLabels).arg(language).arg(pos.X()).arg(sec1).arg(pos.Y()).arg(zoom).arg(sec2); return QString("http://%1%2.google.com/%3/lyrs=%4&hl=%5&x=%6%7&y=%8&z=%9&s=%10").arg(server).arg(GetServerNum(pos, 4)).arg(request).arg(VersionGoogleLabels).arg(language).arg(pos.X()).arg(sec1).arg(pos.Y()).arg(zoom).arg(sec2); } break; @@ -276,6 +276,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c TryCorrectGoogleVersions(); // http://mt0.google.cn/vt/v=w2t.110&hl=zh-CN&gl=cn&x=12&y=6&z=4&s=Ga + qDebug() << QString("http://%1%2.google.cn/%3/imgtp=png32&lyrs=%4&hl=%5&gl=cn&x=%6%7&y=%8&z=%9&s=%10").arg(server).arg(GetServerNum(pos, 4)).arg(request).arg(VersionGoogleLabelsChina).arg("zh-CN").arg(pos.X()).arg(sec1).arg(pos.Y()).arg(zoom).arg(sec2); return QString("http://%1%2.google.cn/%3/imgtp=png32&lyrs=%4&hl=%5&gl=cn&x=%6%7&y=%8&z=%9&s=%10").arg(server).arg(GetServerNum(pos, 4)).arg(request).arg(VersionGoogleLabelsChina).arg("zh-CN").arg(pos.X()).arg(sec1).arg(pos.Y()).arg(zoom).arg(sec2); } break; @@ -342,16 +343,19 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c return QString("http://%1.tile.openstreetmap.org/%2/%3/%4.png").arg(letter).arg(zoom).arg(pos.X()).arg(pos.Y()); } break; + // Need to update tile format to fit http://wiki.openstreetmap.org/wiki/Tile_servers case MapType::OpenStreetOsm: { char letter = "abc"[GetServerNum(pos, 3)]; - return QString("http://%1.tah.openstreetmap.org/Tiles/tile/%2/%3/%4.png").arg(letter).arg(zoom).arg(pos.X()).arg(pos.Y()); + qDebug() << QString("http://%1.tile.openstreetmap.org/%2/%3/%4.png").arg(letter).arg(zoom).arg(pos.X()).arg(pos.Y()); + return QString("http://%1.tile.openstreetmap.org/%2/%3/%4.png").arg(letter).arg(zoom).arg(pos.X()).arg(pos.Y()); } break; case MapType::OpenStreetMapSurfer: { // http://tiles1.mapsurfer.net/tms_r.ashx?x=37378&y=20826&z=16 + qDebug() << QString("http://tiles1.mapsurfer.net/tms_r.ashx?x=%1&y=%2&z=%3").arg(pos.X()).arg(pos.Y()).arg(zoom); return QString("http://tiles1.mapsurfer.net/tms_r.ashx?x=%1&y=%2&z=%3").arg(pos.X()).arg(pos.Y()).arg(zoom); } break; @@ -359,6 +363,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c { // http://tiles2.mapsurfer.net/tms_t.ashx?x=9346&y=5209&z=14 + qDebug() << QString("http://tiles2.mapsurfer.net/tms_t.ashx?x=%1&y=%2&z=%3").arg(pos.X()).arg(pos.Y()).arg(zoom); return QString("http://tiles2.mapsurfer.net/tms_t.ashx?x=%1&y=%2&z=%3").arg(pos.X()).arg(pos.Y()).arg(zoom); } break; @@ -398,7 +403,8 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c { // http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_ShadedRelief_World_2D/MapServer/tile/1/0/1.jpg - return QString("http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_ShadedRelief_World_2D/MapServer/tile/%1/%2/%3").arg(zoom).arg(pos.Y()).arg(pos.X()); + qDebug() << QString("http://server.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/%1/%2/%3").arg(zoom).arg(pos.Y()).arg(pos.X()); + return QString("http://server.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/%1/%2/%3").arg(zoom).arg(pos.Y()).arg(pos.X()); } break; case MapType::ArcGIS_Terrain: @@ -417,6 +423,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c // return string.Format("http://arcgis.maps.lt/ArcGIS/rest/services/mapslt_ortofoto/MapServer/tile/{0}/{1}/{2}", zoom, pos.Y(), pos.X()); // http://dc1.maps.lt/cache/mapslt_ortofoto_512/map/_alllayers/L03/R0000001d/C0000002a.jpg // TODO verificar + qDebug() << QString("http://dc1.maps.lt/cache/mapslt_ortofoto/map/_alllayers/L%1/R%2/C%3.jpg").arg(zoom, 2, 10, (QChar)'0').arg(pos.Y(), 8, 16, (QChar)'0').arg(pos.X(), 8, 16, (QChar)'0'); return QString("http://dc1.maps.lt/cache/mapslt_ortofoto/map/_alllayers/L%1/R%2/C%3.jpg").arg(zoom, 2, 10, (QChar)'0').arg(pos.Y(), 8, 16, (QChar)'0').arg(pos.X(), 8, 16, (QChar)'0'); } break; @@ -429,6 +436,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c // http://dc1.maps.lt/cache/mapslt_512/map/_alllayers/L03/R0000001b/C00000029.png // TODO verificar // http://dc1.maps.lt/cache/mapslt/map/_alllayers/L02/R0000001c/C00000029.png + qDebug() << QString("http://dc1.maps.lt/cache/mapslt/map/_alllayers/L%1/R%2/C%3.png").arg(zoom, 2, 10, (QChar)'0').arg(pos.Y(), 8, 16, (QChar)'0').arg(pos.X(), 8, 16, (QChar)'0'); return QString("http://dc1.maps.lt/cache/mapslt/map/_alllayers/L%1/R%2/C%3.png").arg(zoom, 2, 10, (QChar)'0').arg(pos.Y(), 8, 16, (QChar)'0').arg(pos.X(), 8, 16, (QChar)'0'); } break; @@ -438,6 +446,7 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c // return string.Format("http://arcgis.maps.lt/ArcGIS/rest/services/mapslt_ortofoto_overlay/MapServer/tile/{0}/{1}/{2}", zoom, pos.Y(), pos.X()); // http://dc1.maps.lt/cache/mapslt_ortofoto_overlay_512/map/_alllayers/L03/R0000001d/C00000029.png // TODO verificar + qDebug() << QString("http://dc1.maps.lt/cache/mapslt_ortofoto_overlay/map/_alllayers/L%1/R%2/C%3.png").arg(zoom, 2, 10, (QChar)'0').arg(pos.Y(), 8, 16, (QChar)'0').arg(pos.X(), 8, 16, (QChar)'0'); return QString("http://dc1.maps.lt/cache/mapslt_ortofoto_overlay/map/_alllayers/L%1/R%2/C%3.png").arg(zoom, 2, 10, (QChar)'0').arg(pos.Y(), 8, 16, (QChar)'0').arg(pos.X(), 8, 16, (QChar)'0'); } break; @@ -458,12 +467,15 @@ QString UrlFactory::MakeImageUrl(const MapType::Types &type, const Point &pos, c QString y = QString("%1").arg(QString::number(pos.Y()), 9, (QChar)'0'); y.insert(3, "/").insert(7, "/"); // "http://map03.pergo.com.tr/tile/2/000/000/003/000/000/002.png" + // This has changed map03 does not exist. (neither does map3) Servers have changed to map1 and map2? return QString("http://map%1.pergo.com.tr/tile/%2/%3/%4.png").arg(GetServerNum(pos, 4)).arg(zoom, 2, 10, (QChar)'0').arg(x).arg(y); } break; case MapType::SigPacSpainMap: { - return QString("http://sigpac.mapa.es/kmlserver/raster/%1@3785/%2.%3.%4.img").arg(levelsForSigPacSpainMap[zoom]).arg(zoom).arg(pos.X()).arg((2 << (zoom - 1)) - pos.Y() - 1); + // http://sigpac.magrama.es/fega/h5visor/ is new server location + qDebug() << QString("http://sigpac.mapa.es/kmlserver/raster/%1@3785/%2.%3.%4.img").arg(levelsForSigPacSpainMap[zoom]).arg(zoom).arg(pos.X()).arg((2 << (zoom - 1)) - pos.Y() - 1); + return QString("http://sigpac.magrama.es/SDG/%1@3785/%2.%3.%4.img").arg(levelsForSigPacSpainMap[zoom]).arg(zoom).arg(pos.X()).arg((2 << (zoom - 1)) - pos.Y() - 1); } break; From 92e50c2eada1125c0acd24fe1bf786ed07969ccc Mon Sep 17 00:00:00 2001 From: abeck70 Date: Wed, 13 May 2015 17:19:51 +1000 Subject: [PATCH 71/75] OP-1810 FOC Squashed commit for clean commit as discussed in code review Uncrustify --- Makefile | 3 +- flight/pios/inc/pios_usb_defs.h | 7 +- .../boards/coptercontrol/board-info.mk | 23 - .../boards/coptercontrol/board_hw_defs.c | 1525 ------- .../boards/coptercontrol/bootloader/Makefile | 32 - .../coptercontrol/bootloader/inc/common.h | 115 - .../bootloader/inc/pios_config.h | 53 - .../bootloader/inc/pios_usb_board_data.h | 53 - .../boards/coptercontrol/bootloader/main.c | 223 - .../coptercontrol/bootloader/pios_board.c | 106 - .../boards/coptercontrol/firmware/Makefile | 148 - .../coptercontrol/firmware/coptercontrol.c | 117 - .../firmware/inc/FreeRTOSConfig.h | 99 - .../coptercontrol/firmware/inc/openpilot.h | 52 - .../firmware/inc/pios_board_posix.h | 81 - .../coptercontrol/firmware/inc/pios_config.h | 188 - .../firmware/inc/pios_config_posix.h | 48 - .../firmware/inc/pios_usb_board_data.h | 47 - .../coptercontrol/firmware/pios_board.c | 920 ---- .../coptercontrol/firmware/pios_board_posix.c | 145 - .../targets/boards/coptercontrol/pios_board.h | 279 -- .../coptercontrol/pios_usb_board_data.c | 102 - .../src/plugins/config/cc_hw_settings.ui | 658 --- .../src/plugins/config/ccattitude.ui | 597 --- .../src/plugins/config/config.pro | 8 +- .../plugins/config/config_cc_hw_widget.cpp | 156 - .../src/plugins/config/config_cc_hw_widget.h | 56 - .../plugins/config/configccattitudewidget.cpp | 239 - .../plugins/config/configccattitudewidget.h | 74 - .../src/plugins/config/configgadget.qrc | 2 - .../src/plugins/config/configgadgetwidget.cpp | 16 +- .../src/plugins/config/configoutputwidget.cpp | 6 +- .../src/plugins/config/images/PipXtreme.png | Bin 78915 -> 0 bytes .../plugins/config/images/coptercontrol.svg | 2647 ----------- .../plugins/coreplugin/connectionmanager.cpp | 35 +- .../plugins/coreplugin/connectionmanager.h | 3 + .../src/plugins/coreplugin/mainwindow.cpp | 2 +- .../src/plugins/ophid/inc/ophid_usbmon.h | 7 +- .../plugins/setupwizard/connectiondiagram.cpp | 12 - .../setupwizard/pages/controllerpage.cpp | 11 - .../src/plugins/setupwizard/pages/escpage.cpp | 26 +- .../plugins/setupwizard/pages/inputpage.cpp | 21 - .../resources/connection-diagrams.svg | 4045 ++--------------- .../src/plugins/setupwizard/setupwizard.cpp | 10 - .../vehicleconfigurationhelper.cpp | 62 +- .../setupwizard/vehicleconfigurationsource.h | 2 +- .../uavobjectutil/devicedescriptorstruct.h | 28 - .../src/plugins/uploader/devicewidget.cpp | 20 +- .../plugins/uploader/images/deviceID-0101.svg | 2466 ---------- .../plugins/uploader/images/deviceID-0201.svg | 2948 ------------ .../plugins/uploader/images/deviceID-0301.svg | 61 - .../plugins/uploader/images/deviceID-0401.svg | 2646 ----------- .../plugins/uploader/images/deviceID-0402.svg | 2389 ---------- .../plugins/uploader/images/gcs-board-cc.png | Bin 242648 -> 0 bytes .../uploader/images/gcs-board-cc3d.png | Bin 247305 -> 0 bytes .../src/plugins/uploader/images/pipx.png | Bin 184786 -> 0 bytes .../src/plugins/uploader/op_dfu.cpp | 4 - .../src/plugins/uploader/op_dfu.h | 1 - .../plugins/uploader/runningdevicewidget.cpp | 10 - .../src/plugins/uploader/uploader.qrc | 8 - .../plugins/uploader/uploadergadgetwidget.cpp | 5 - .../usagetracker/usagetrackerplugin.cpp | 17 +- 62 files changed, 425 insertions(+), 23239 deletions(-) delete mode 100644 flight/targets/boards/coptercontrol/board-info.mk delete mode 100644 flight/targets/boards/coptercontrol/board_hw_defs.c delete mode 100644 flight/targets/boards/coptercontrol/bootloader/Makefile delete mode 100644 flight/targets/boards/coptercontrol/bootloader/inc/common.h delete mode 100644 flight/targets/boards/coptercontrol/bootloader/inc/pios_config.h delete mode 100644 flight/targets/boards/coptercontrol/bootloader/inc/pios_usb_board_data.h delete mode 100644 flight/targets/boards/coptercontrol/bootloader/main.c delete mode 100644 flight/targets/boards/coptercontrol/bootloader/pios_board.c delete mode 100644 flight/targets/boards/coptercontrol/firmware/Makefile delete mode 100644 flight/targets/boards/coptercontrol/firmware/coptercontrol.c delete mode 100644 flight/targets/boards/coptercontrol/firmware/inc/FreeRTOSConfig.h delete mode 100644 flight/targets/boards/coptercontrol/firmware/inc/openpilot.h delete mode 100644 flight/targets/boards/coptercontrol/firmware/inc/pios_board_posix.h delete mode 100644 flight/targets/boards/coptercontrol/firmware/inc/pios_config.h delete mode 100644 flight/targets/boards/coptercontrol/firmware/inc/pios_config_posix.h delete mode 100644 flight/targets/boards/coptercontrol/firmware/inc/pios_usb_board_data.h delete mode 100644 flight/targets/boards/coptercontrol/firmware/pios_board.c delete mode 100644 flight/targets/boards/coptercontrol/firmware/pios_board_posix.c delete mode 100644 flight/targets/boards/coptercontrol/pios_board.h delete mode 100644 flight/targets/boards/coptercontrol/pios_usb_board_data.c delete mode 100644 ground/openpilotgcs/src/plugins/config/cc_hw_settings.ui delete mode 100644 ground/openpilotgcs/src/plugins/config/ccattitude.ui delete mode 100644 ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.cpp delete mode 100644 ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.h delete mode 100644 ground/openpilotgcs/src/plugins/config/configccattitudewidget.cpp delete mode 100644 ground/openpilotgcs/src/plugins/config/configccattitudewidget.h delete mode 100644 ground/openpilotgcs/src/plugins/config/images/PipXtreme.png delete mode 100644 ground/openpilotgcs/src/plugins/config/images/coptercontrol.svg delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/deviceID-0101.svg delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/deviceID-0201.svg delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/deviceID-0301.svg delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/deviceID-0401.svg delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/deviceID-0402.svg delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/gcs-board-cc.png delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/gcs-board-cc3d.png delete mode 100644 ground/openpilotgcs/src/plugins/uploader/images/pipx.png diff --git a/Makefile b/Makefile index d9711b0a1..54bbea0b8 100644 --- a/Makefile +++ b/Makefile @@ -209,10 +209,9 @@ export OPGCSSYNTHDIR := $(BUILD_DIR)/openpilotgcs-synthetics DIRS += $(OPGCSSYNTHDIR) # Define supported board lists -ALL_BOARDS := coptercontrol oplinkmini revolution osd revoproto simposix discoveryf4bare gpsplatinum +ALL_BOARDS := oplinkmini revolution osd revoproto simposix discoveryf4bare gpsplatinum # Short names of each board (used to display board name in parallel builds) -coptercontrol_short := 'cc ' oplinkmini_short := 'oplm' revolution_short := 'revo' osd_short := 'osd ' diff --git a/flight/pios/inc/pios_usb_defs.h b/flight/pios/inc/pios_usb_defs.h index 164d31fb3..9078e1abb 100644 --- a/flight/pios/inc/pios_usb_defs.h +++ b/flight/pios/inc/pios_usb_defs.h @@ -353,7 +353,6 @@ enum usb_cdc_notification { enum usb_product_ids { USB_PRODUCT_ID_OPENPILOT_MAIN = 0x415A, - USB_PRODUCT_ID_COPTERCONTROL = 0x415B, USB_PRODUCT_ID_OPLINK = 0x415C, USB_PRODUCT_ID_CC3D = 0x415D, USB_PRODUCT_ID_REVOLUTION = 0x415E, @@ -364,9 +363,9 @@ enum usb_product_ids { enum usb_op_board_ids { USB_OP_BOARD_ID_OPENPILOT_MAIN = 1, /* Board ID 2 may be unused or AHRS */ - USB_OP_BOARD_ID_OPLINK = 3, - USB_OP_BOARD_ID_COPTERCONTROL = 4, - USB_OP_BOARD_ID_REVOLUTION = 5, + USB_OP_BOARD_ID_OPLINK = 3, + /* USB_OP_BOARD_ID_COPTERCONTROL = 4, */ + USB_OP_BOARD_ID_REVOLUTION = 5, USB_OP_BOARD_ID_OSD = 6, } __attribute__((packed)); diff --git a/flight/targets/boards/coptercontrol/board-info.mk b/flight/targets/boards/coptercontrol/board-info.mk deleted file mode 100644 index d58f3d71d..000000000 --- a/flight/targets/boards/coptercontrol/board-info.mk +++ /dev/null @@ -1,23 +0,0 @@ -BOARD_TYPE := 0x04 -BOARD_REVISION := 0x02 -BOOTLOADER_VERSION := 0x04 -HW_TYPE := 0x01 - -MCU := cortex-m3 -CHIP := STM32F103CBT -BOARD := STM32103CB_CC_Rev1 -MODEL := MD -MODEL_SUFFIX := _CC - -OPENOCD_JTAG_CONFIG := foss-jtag.revb.cfg -OPENOCD_CONFIG := stm32f1x.cfg - -# Note: These must match the values in link_$(BOARD)_memory.ld -BL_BANK_BASE := 0x08000000 # Start of bootloader flash -BL_BANK_SIZE := 0x00003000 # Should include BD_INFO region -FW_BANK_BASE := 0x08003000 # Start of firmware flash -FW_BANK_SIZE := 0x0001D000 # Should include FW_DESC_SIZE - -FW_DESC_SIZE := 0x00000064 - -OSCILLATOR_FREQ := 8000000 diff --git a/flight/targets/boards/coptercontrol/board_hw_defs.c b/flight/targets/boards/coptercontrol/board_hw_defs.c deleted file mode 100644 index 17981095f..000000000 --- a/flight/targets/boards/coptercontrol/board_hw_defs.c +++ /dev/null @@ -1,1525 +0,0 @@ -/** - ****************************************************************************** - * @file board_hw_defs.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012. - * @author PhoenixPilot, http://github.com/PhoenixPilot, Copyright (C) 2012 - * @addtogroup OpenPilotSystem OpenPilot System - * @{ - * @addtogroup OpenPilotCore OpenPilot Core - * @{ - * @brief Defines board specific static initializers for hardware for the CopterControl board. - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#define BOARD_REVISION_CC 1 -#define BOARD_REVISION_CC3D 2 - -#if defined(PIOS_INCLUDE_LED) - -#include -static const struct pios_gpio pios_leds_cc[] = { - [PIOS_LED_HEARTBEAT] = { - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_6, - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_50MHz, - }, - }, - .active_low = true - }, -}; - -static const struct pios_gpio_cfg pios_led_cfg_cc = { - .gpios = pios_leds_cc, - .num_gpios = NELEMENTS(pios_leds_cc), -}; - -static const struct pios_gpio pios_leds_cc3d[] = { - [PIOS_LED_HEARTBEAT] = { - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_3, - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_50MHz, - }, - }, - .remap = GPIO_Remap_SWJ_JTAGDisable, - .active_low = true - }, -}; - -static const struct pios_gpio_cfg pios_led_cfg_cc3d = { - .gpios = pios_leds_cc3d, - .num_gpios = NELEMENTS(pios_leds_cc3d), -}; - -const struct pios_gpio_cfg *PIOS_BOARD_HW_DEFS_GetLedCfg(uint32_t board_revision) -{ - switch (board_revision) { - case BOARD_REVISION_CC: return &pios_led_cfg_cc; - - case BOARD_REVISION_CC3D: return &pios_led_cfg_cc3d; - - default: return NULL; - } -} - -#endif /* PIOS_INCLUDE_LED */ - -#if defined(PIOS_INCLUDE_SPI) - -#include - -/* Gyro interface */ -void PIOS_SPI_gyro_irq_handler(void); -void DMA1_Channel2_IRQHandler() __attribute__((alias("PIOS_SPI_gyro_irq_handler"))); -void DMA1_Channel3_IRQHandler() __attribute__((alias("PIOS_SPI_gyro_irq_handler"))); -static const struct pios_spi_cfg pios_spi_gyro_cfg = { - .regs = SPI1, - .init = { - .SPI_Mode = SPI_Mode_Master, - .SPI_Direction = SPI_Direction_2Lines_FullDuplex, - .SPI_DataSize = SPI_DataSize_8b, - .SPI_NSS = SPI_NSS_Soft, - .SPI_FirstBit = SPI_FirstBit_MSB, - .SPI_CRCPolynomial = 7, - .SPI_CPOL = SPI_CPOL_High, - .SPI_CPHA = SPI_CPHA_2Edge, - .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16, /* 10 Mhz */ - }, - .use_crc = false, - .dma = { - .ahb_clk = RCC_AHBPeriph_DMA1, - - .irq = { - .flags = (DMA1_FLAG_TC2 | DMA1_FLAG_TE2 | DMA1_FLAG_HT2 | DMA1_FLAG_GL2), - .init = { - .NVIC_IRQChannel = DMA1_Channel2_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - - .rx = { - .channel = DMA1_Channel2, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&(SPI1->DR), - .DMA_DIR = DMA_DIR_PeripheralSRC, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte, - .DMA_Mode = DMA_Mode_Normal, - .DMA_Priority = DMA_Priority_Medium, - .DMA_M2M = DMA_M2M_Disable, - }, - }, - .tx = { - .channel = DMA1_Channel3, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&(SPI1->DR), - .DMA_DIR = DMA_DIR_PeripheralDST, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte, - .DMA_Mode = DMA_Mode_Normal, - .DMA_Priority = DMA_Priority_Medium, - .DMA_M2M = DMA_M2M_Disable, - }, - }, - }, - .sclk = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_5, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, - .miso = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_6, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .mosi = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_7, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, - .slave_count = 1, - .ssel = { - { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_4, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - }, - } - }, -}; - -static uint32_t pios_spi_gyro_id; -void PIOS_SPI_gyro_irq_handler(void) -{ - /* Call into the generic code to handle the IRQ for this specific device */ - PIOS_SPI_IRQ_Handler(pios_spi_gyro_id); -} - - -/* Flash/Accel Interface - * - * NOTE: Leave this declared as const data so that it ends up in the - * .rodata section (ie. Flash) rather than in the .bss section (RAM). - */ -void PIOS_SPI_flash_accel_irq_handler(void); -void DMA1_Channel4_IRQHandler() __attribute__((alias("PIOS_SPI_flash_accel_irq_handler"))); -void DMA1_Channel5_IRQHandler() __attribute__((alias("PIOS_SPI_flash_accel_irq_handler"))); -static const struct pios_spi_cfg pios_spi_flash_accel_cfg_cc3d = { - .regs = SPI2, - .init = { - .SPI_Mode = SPI_Mode_Master, - .SPI_Direction = SPI_Direction_2Lines_FullDuplex, - .SPI_DataSize = SPI_DataSize_8b, - .SPI_NSS = SPI_NSS_Soft, - .SPI_FirstBit = SPI_FirstBit_MSB, - .SPI_CRCPolynomial = 7, - .SPI_CPOL = SPI_CPOL_High, - .SPI_CPHA = SPI_CPHA_2Edge, - .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8, - }, - .use_crc = false, - .dma = { - .ahb_clk = RCC_AHBPeriph_DMA1, - - .irq = { - .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), - .init = { - .NVIC_IRQChannel = DMA1_Channel4_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - - .rx = { - .channel = DMA1_Channel4, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR), - .DMA_DIR = DMA_DIR_PeripheralSRC, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte, - .DMA_Mode = DMA_Mode_Normal, - .DMA_Priority = DMA_Priority_High, - .DMA_M2M = DMA_M2M_Disable, - }, - }, - .tx = { - .channel = DMA1_Channel5, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR), - .DMA_DIR = DMA_DIR_PeripheralDST, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte, - .DMA_Mode = DMA_Mode_Normal, - .DMA_Priority = DMA_Priority_High, - .DMA_M2M = DMA_M2M_Disable, - }, - }, - }, - .sclk = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_13, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, - .miso = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_14, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, - .mosi = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_15, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, - .slave_count = 2, - .ssel = { - { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_12, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - } - },{ - .gpio = GPIOC, - .init = { - .GPIO_Pin = GPIO_Pin_15, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - }, - } - }, -}; - -static const struct pios_spi_cfg pios_spi_flash_accel_cfg_cc = { - .regs = SPI2, - .init = { - .SPI_Mode = SPI_Mode_Master, - .SPI_Direction = SPI_Direction_2Lines_FullDuplex, - .SPI_DataSize = SPI_DataSize_8b, - .SPI_NSS = SPI_NSS_Soft, - .SPI_FirstBit = SPI_FirstBit_MSB, - .SPI_CRCPolynomial = 7, - .SPI_CPOL = SPI_CPOL_High, - .SPI_CPHA = SPI_CPHA_2Edge, - .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8, - }, - .use_crc = false, - .dma = { - .ahb_clk = RCC_AHBPeriph_DMA1, - - .irq = { - .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), - .init = { - .NVIC_IRQChannel = DMA1_Channel4_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - - .rx = { - .channel = DMA1_Channel4, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR), - .DMA_DIR = DMA_DIR_PeripheralSRC, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte, - .DMA_Mode = DMA_Mode_Normal, - .DMA_Priority = DMA_Priority_High, - .DMA_M2M = DMA_M2M_Disable, - }, - }, - .tx = { - .channel = DMA1_Channel5, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR), - .DMA_DIR = DMA_DIR_PeripheralDST, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte, - .DMA_Mode = DMA_Mode_Normal, - .DMA_Priority = DMA_Priority_High, - .DMA_M2M = DMA_M2M_Disable, - }, - }, - }, - .sclk = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_13, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, - .miso = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_14, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, - .mosi = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_15, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, - .slave_count = 2, - .ssel = { - { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_12, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - } - },{ - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_7, - .GPIO_Speed = GPIO_Speed_50MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - }, - } - }, -}; - -static uint32_t pios_spi_flash_accel_id; -void PIOS_SPI_flash_accel_irq_handler(void) -{ - /* Call into the generic code to handle the IRQ for this specific device */ - PIOS_SPI_IRQ_Handler(pios_spi_flash_accel_id); -} - -#endif /* PIOS_INCLUDE_SPI */ - -#if defined(PIOS_INCLUDE_FLASH) -#include "pios_flashfs_logfs_priv.h" -#include "pios_flash_jedec_priv.h" - -static const struct flashfs_logfs_cfg flashfs_w25x_cfg = { - .fs_magic = 0x99abcdef, - .total_fs_size = 0x00080000, /* 512K bytes (128 sectors = entire chip) */ - .arena_size = 0x00010000, /* 256 * slot size */ - .slot_size = 0x00000100, /* 256 bytes */ - - .start_offset = 0, /* start at the beginning of the chip */ - .sector_size = 0x00001000, /* 4K bytes */ - .page_size = 0x00000100, /* 256 bytes */ -}; - - -static const struct flashfs_logfs_cfg flashfs_m25p_cfg = { - .fs_magic = 0x99abceef, - .total_fs_size = 0x00200000, /* 2M bytes (32 sectors = entire chip) */ - .arena_size = 0x00010000, /* 256 * slot size */ - .slot_size = 0x00000100, /* 256 bytes */ - - .start_offset = 0, /* start at the beginning of the chip */ - .sector_size = 0x00010000, /* 64K bytes */ - .page_size = 0x00000100, /* 256 bytes */ -}; - -#include "pios_flash.h" - -#endif /* PIOS_INCLUDE_FLASH */ - -/* - * ADC system - */ -#if defined(PIOS_INCLUDE_ADC) -#include "pios_adc_priv.h" -extern void PIOS_ADC_handler(void); -void DMA1_Channel1_IRQHandler() __attribute__((alias("PIOS_ADC_handler"))); -// Remap the ADC DMA handler to this one -static const struct pios_adc_cfg pios_adc_cfg = { - .dma = { - .ahb_clk = RCC_AHBPeriph_DMA1, - .irq = { - .flags = (DMA1_FLAG_TC1 | DMA1_FLAG_TE1 | DMA1_FLAG_HT1 | DMA1_FLAG_GL1), - .init = { - .NVIC_IRQChannel = DMA1_Channel1_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .channel = DMA1_Channel1, - .init = { - .DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR, - .DMA_DIR = DMA_DIR_PeripheralSRC, - .DMA_PeripheralInc = DMA_PeripheralInc_Disable, - .DMA_MemoryInc = DMA_MemoryInc_Enable, - .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word, - .DMA_MemoryDataSize = DMA_MemoryDataSize_Word, - .DMA_Mode = DMA_Mode_Circular, - .DMA_Priority = DMA_Priority_High, - .DMA_M2M = DMA_M2M_Disable, - }, - } - }, - .half_flag = DMA1_IT_HT1, - .full_flag = DMA1_IT_TC1, -}; - -void PIOS_ADC_handler() -{ - PIOS_ADC_DMA_Handler(); -} -#endif /* if defined(PIOS_INCLUDE_ADC) */ - -#include "pios_tim_priv.h" - -static const TIM_TimeBaseInitTypeDef tim_1_2_3_4_time_base = { - .TIM_Prescaler = (PIOS_MASTER_CLOCK / 1000000) - 1, - .TIM_ClockDivision = TIM_CKD_DIV1, - .TIM_CounterMode = TIM_CounterMode_Up, - .TIM_Period = ((1000000 / PIOS_SERVO_UPDATE_HZ) - 1), - .TIM_RepetitionCounter = 0x0000, -}; - -static const struct pios_tim_clock_cfg tim_1_cfg = { - .timer = TIM1, - .time_base_init = &tim_1_2_3_4_time_base, - .irq = { - .init = { - .NVIC_IRQChannel = TIM1_CC_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, -}; - -static const struct pios_tim_clock_cfg tim_2_cfg = { - .timer = TIM2, - .time_base_init = &tim_1_2_3_4_time_base, - .irq = { - .init = { - .NVIC_IRQChannel = TIM2_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, -}; - -static const struct pios_tim_clock_cfg tim_3_cfg = { - .timer = TIM3, - .time_base_init = &tim_1_2_3_4_time_base, - .irq = { - .init = { - .NVIC_IRQChannel = TIM3_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, -}; - -static const struct pios_tim_clock_cfg tim_4_cfg = { - .timer = TIM4, - .time_base_init = &tim_1_2_3_4_time_base, - .irq = { - .init = { - .NVIC_IRQChannel = TIM4_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, -}; - -static const struct pios_tim_channel pios_tim_rcvrport_all_channels[] = { - { - .timer = TIM4, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_6, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM3, - .timer_chan = TIM_Channel_2, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_5, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - .remap = GPIO_PartialRemap_TIM3, - }, - { - .timer = TIM3, - .timer_chan = TIM_Channel_3, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_0, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM3, - .timer_chan = TIM_Channel_4, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_1, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM2, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_0, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM2, - .timer_chan = TIM_Channel_2, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_1, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, -}; - -static const struct pios_tim_channel pios_tim_servoport_all_pins[] = { - { - .timer = TIM4, - .timer_chan = TIM_Channel_4, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_9, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM4, - .timer_chan = TIM_Channel_3, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_8, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM4, - .timer_chan = TIM_Channel_2, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_7, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM1, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_8, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM3, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_4, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - .remap = GPIO_PartialRemap_TIM3, - }, - { - .timer = TIM2, - .timer_chan = TIM_Channel_3, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_2, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, -}; - - -static const struct pios_tim_channel pios_tim_servoport_rcvrport_pins[] = { - { - .timer = TIM4, - .timer_chan = TIM_Channel_4, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_9, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM4, - .timer_chan = TIM_Channel_3, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_8, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM4, - .timer_chan = TIM_Channel_2, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_7, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM1, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_8, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM3, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_4, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - .remap = GPIO_PartialRemap_TIM3, - }, - { - .timer = TIM2, - .timer_chan = TIM_Channel_3, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_2, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - - // Receiver port pins - // S3-S6 inputs are used as outputs in this case - { - .timer = TIM3, - .timer_chan = TIM_Channel_3, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_0, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM3, - .timer_chan = TIM_Channel_4, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_1, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM2, - .timer_chan = TIM_Channel_1, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_0, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, - { - .timer = TIM2, - .timer_chan = TIM_Channel_2, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_1, - .GPIO_Mode = GPIO_Mode_AF_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - }, -}; - -static const struct pios_tim_channel pios_tim_ppm_flexi_port = { - .timer = TIM2, - .timer_chan = TIM_Channel_4, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_11, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - .remap = GPIO_PartialRemap2_TIM2, -}; - -#if defined(PIOS_INCLUDE_USART) - -#include "pios_usart_priv.h" - -static const struct pios_usart_cfg pios_usart_generic_main_cfg = { - .regs = USART1, - .init = { - .USART_BaudRate = 57600, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART1_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_9, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, -}; - -static const struct pios_usart_cfg pios_usart_generic_flexi_cfg = { - .regs = USART3, - .init = { - .USART_BaudRate = 57600, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART3_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_11, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, -}; - -#if defined(PIOS_INCLUDE_DSM) -/* - * Spektrum/JR DSM USART - */ -#include - -static const struct pios_usart_cfg pios_usart_dsm_main_cfg = { - .regs = USART1, - .init = { - .USART_BaudRate = 115200, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART1_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_9, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, -}; - -static const struct pios_dsm_cfg pios_dsm_main_cfg = { - .bind = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - }, - }, -}; - -static const struct pios_usart_cfg pios_usart_dsm_flexi_cfg = { - .regs = USART3, - .init = { - .USART_BaudRate = 115200, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART3_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_11, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, -}; - -static const struct pios_dsm_cfg pios_dsm_flexi_cfg = { - .bind = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_11, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_Out_PP, - }, - }, -}; - -#endif /* PIOS_INCLUDE_DSM */ - - -#if defined(PIOS_INCLUDE_SBUS) -/* - * S.Bus USART - */ -#include - -static const struct pios_usart_cfg pios_usart_sbus_main_cfg = { - .regs = USART1, - .init = { - .USART_BaudRate = 100000, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_Even, - .USART_StopBits = USART_StopBits_2, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART1_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_9, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, -}; - -static const struct pios_sbus_cfg pios_sbus_cfg = { - /* Inverter configuration */ - .inv = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_2, - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - .gpio_clk_func = RCC_APB2PeriphClockCmd, - .gpio_clk_periph = RCC_APB2Periph_GPIOB, - .gpio_inv_enable = Bit_SET, -}; - -#endif /* PIOS_INCLUDE_SBUS */ - -/* - * HK OSD - */ -static const struct pios_usart_cfg pios_usart_hkosd_main_cfg = { - .regs = USART1, - .init = { - .USART_BaudRate = 57600, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART1_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_9, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, -}; - -static const struct pios_usart_cfg pios_usart_hkosd_flexi_cfg = { - .regs = USART3, - .init = { - .USART_BaudRate = 57600, - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, - }, - .irq = { - .init = { - .NVIC_IRQChannel = USART3_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_11, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_AF_PP, - }, - }, -}; - - -#endif /* PIOS_INCLUDE_USART */ - -#if defined(PIOS_INCLUDE_COM) - -#include "pios_com_priv.h" - -#endif /* PIOS_INCLUDE_COM */ - -#if defined(PIOS_INCLUDE_RTC) -/* - * Realtime Clock (RTC) - */ -#include - -void PIOS_RTC_IRQ_Handler(void); -void RTC_IRQHandler() __attribute__((alias("PIOS_RTC_IRQ_Handler"))); -static const struct pios_rtc_cfg pios_rtc_main_cfg = { - .clksrc = RCC_RTCCLKSource_HSE_Div128, - .prescaler = 100, - .irq = { - .init = { - .NVIC_IRQChannel = RTC_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, -}; - -void PIOS_RTC_IRQ_Handler(void) -{ - PIOS_RTC_irq_handler(); -} - -#endif /* if defined(PIOS_INCLUDE_RTC) */ - -#if defined(PIOS_INCLUDE_SERVO) && defined(PIOS_INCLUDE_TIM) -/* - * Servo outputs - */ -#include - -const struct pios_servo_cfg pios_servo_cfg = { - .tim_oc_init = { - .TIM_OCMode = TIM_OCMode_PWM1, - .TIM_OutputState = TIM_OutputState_Enable, - .TIM_OutputNState = TIM_OutputNState_Disable, - .TIM_Pulse = PIOS_SERVOS_INITIAL_POSITION, - .TIM_OCPolarity = TIM_OCPolarity_High, - .TIM_OCNPolarity = TIM_OCPolarity_High, - .TIM_OCIdleState = TIM_OCIdleState_Reset, - .TIM_OCNIdleState = TIM_OCNIdleState_Reset, - }, - .channels = pios_tim_servoport_all_pins, - .num_channels = NELEMENTS(pios_tim_servoport_all_pins), -}; - -const struct pios_servo_cfg pios_servo_rcvr_cfg = { - .tim_oc_init = { - .TIM_OCMode = TIM_OCMode_PWM1, - .TIM_OutputState = TIM_OutputState_Enable, - .TIM_OutputNState = TIM_OutputNState_Disable, - .TIM_Pulse = PIOS_SERVOS_INITIAL_POSITION, - .TIM_OCPolarity = TIM_OCPolarity_High, - .TIM_OCNPolarity = TIM_OCPolarity_High, - .TIM_OCIdleState = TIM_OCIdleState_Reset, - .TIM_OCNIdleState = TIM_OCNIdleState_Reset, - }, - .channels = pios_tim_servoport_rcvrport_pins, - .num_channels = NELEMENTS(pios_tim_servoport_rcvrport_pins), -}; - -#endif /* PIOS_INCLUDE_SERVO && PIOS_INCLUDE_TIM */ - -/* - * PPM Inputs - */ -#if defined(PIOS_INCLUDE_PPM) -#include - -const struct pios_ppm_cfg pios_ppm_cfg = { - .tim_ic_init = { - .TIM_ICPolarity = TIM_ICPolarity_Rising, - .TIM_ICSelection = TIM_ICSelection_DirectTI, - .TIM_ICPrescaler = TIM_ICPSC_DIV1, - .TIM_ICFilter = 0x0, - }, - /* Use only the first channel for ppm */ - .channels = &pios_tim_rcvrport_all_channels[0], - .num_channels = 1, -}; - -const struct pios_ppm_cfg pios_ppm_pin8_cfg = { - .tim_ic_init = { - .TIM_ICPolarity = TIM_ICPolarity_Rising, - .TIM_ICSelection = TIM_ICSelection_DirectTI, - .TIM_ICPrescaler = TIM_ICPSC_DIV1, - .TIM_ICFilter = 0x0, - }, - /* Use only the first channel for ppm */ - .channels = &pios_tim_rcvrport_all_channels[5], - .num_channels = 1, -}; - -#endif /* PIOS_INCLUDE_PPM */ - -#if defined(PIOS_INCLUDE_PPM_FLEXI) -#include - -const struct pios_ppm_cfg pios_ppm_flexi_cfg = { - .tim_ic_init = { - .TIM_ICPolarity = TIM_ICPolarity_Rising, - .TIM_ICSelection = TIM_ICSelection_DirectTI, - .TIM_ICPrescaler = TIM_ICPSC_DIV1, - .TIM_ICFilter = 0x0, - }, - .channels = &pios_tim_ppm_flexi_port, - .num_channels = 1, -}; - -#endif /* PIOS_INCLUDE_PPM_FLEXI */ - -/* - * PWM Inputs - */ -#if defined(PIOS_INCLUDE_PWM) -#include - -const struct pios_pwm_cfg pios_pwm_cfg = { - .tim_ic_init = { - .TIM_ICPolarity = TIM_ICPolarity_Rising, - .TIM_ICSelection = TIM_ICSelection_DirectTI, - .TIM_ICPrescaler = TIM_ICPSC_DIV1, - .TIM_ICFilter = 0x0, - }, - .channels = pios_tim_rcvrport_all_channels, - .num_channels = NELEMENTS(pios_tim_rcvrport_all_channels), -}; - -const struct pios_pwm_cfg pios_pwm_with_ppm_cfg = { - .tim_ic_init = { - .TIM_ICPolarity = TIM_ICPolarity_Rising, - .TIM_ICSelection = TIM_ICSelection_DirectTI, - .TIM_ICPrescaler = TIM_ICPSC_DIV1, - .TIM_ICFilter = 0x0, - }, - /* Leave the first channel for PPM use and use the rest for PWM */ - .channels = &pios_tim_rcvrport_all_channels[1], - .num_channels = NELEMENTS(pios_tim_rcvrport_all_channels) - 1, -}; - -#endif /* if defined(PIOS_INCLUDE_PWM) */ - - -/* - * SONAR Inputs - */ -#if defined(PIOS_INCLUDE_HCSR04) -#include - -static const struct pios_tim_channel pios_tim_hcsr04_port_all_channels[] = { - { - .timer = TIM3, - .timer_chan = TIM_Channel_2, - .pin = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_5, - .GPIO_Mode = GPIO_Mode_IPD, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, - .remap = GPIO_PartialRemap_TIM3, - }, -}; - -const struct pios_hcsr04_cfg pios_hcsr04_cfg = { - .tim_ic_init = { - .TIM_ICPolarity = TIM_ICPolarity_Rising, - .TIM_ICSelection = TIM_ICSelection_DirectTI, - .TIM_ICPrescaler = TIM_ICPSC_DIV1, - .TIM_ICFilter = 0x0, - }, - .channels = pios_tim_hcsr04_port_all_channels, - .num_channels = NELEMENTS(pios_tim_hcsr04_port_all_channels), - .trigger = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_6, - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - }, -}; -#endif /* if defined(PIOS_INCLUDE_HCSR04) */ - -#if defined(PIOS_INCLUDE_I2C) - -#include - -/* - * I2C Adapters - */ - -void PIOS_I2C_flexi_adapter_ev_irq_handler(void); -void PIOS_I2C_flexi_adapter_er_irq_handler(void); -void I2C2_EV_IRQHandler() __attribute__((alias("PIOS_I2C_flexi_adapter_ev_irq_handler"))); -void I2C2_ER_IRQHandler() __attribute__((alias("PIOS_I2C_flexi_adapter_er_irq_handler"))); - -static const struct pios_i2c_adapter_cfg pios_i2c_flexi_adapter_cfg = { - .regs = I2C2, - .init = { - .I2C_Mode = I2C_Mode_I2C, - .I2C_OwnAddress1 = 0, - .I2C_Ack = I2C_Ack_Enable, - .I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit, - .I2C_DutyCycle = I2C_DutyCycle_2, - .I2C_ClockSpeed = 400000, /* bits/s */ - }, - .transfer_timeout_ms = 50, - .scl = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_10, - .GPIO_Speed = GPIO_Speed_10MHz, - .GPIO_Mode = GPIO_Mode_AF_OD, - }, - }, - .sda = { - .gpio = GPIOB, - .init = { - .GPIO_Pin = GPIO_Pin_11, - .GPIO_Speed = GPIO_Speed_10MHz, - .GPIO_Mode = GPIO_Mode_AF_OD, - }, - }, - .event = { - .flags = 0, /* FIXME: check this */ - .init = { - .NVIC_IRQChannel = I2C2_EV_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .error = { - .flags = 0, /* FIXME: check this */ - .init = { - .NVIC_IRQChannel = I2C2_ER_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, -}; - -uint32_t pios_i2c_flexi_adapter_id; -void PIOS_I2C_flexi_adapter_ev_irq_handler(void) -{ - /* Call into the generic code to handle the IRQ for this specific device */ - PIOS_I2C_EV_IRQ_Handler(pios_i2c_flexi_adapter_id); -} - -void PIOS_I2C_flexi_adapter_er_irq_handler(void) -{ - /* Call into the generic code to handle the IRQ for this specific device */ - PIOS_I2C_ER_IRQ_Handler(pios_i2c_flexi_adapter_id); -} - -#endif /* PIOS_INCLUDE_I2C */ - -#if defined(PIOS_INCLUDE_GCSRCVR) -#include "pios_gcsrcvr_priv.h" -#endif /* PIOS_INCLUDE_GCSRCVR */ - -#if defined(PIOS_INCLUDE_RCVR) -#include "pios_rcvr_priv.h" - -#endif /* PIOS_INCLUDE_RCVR */ - -#if defined(PIOS_INCLUDE_USB) -#include "pios_usb_priv.h" - -static const struct pios_usb_cfg pios_usb_main_cfg_cc = { - .irq = { - .init = { - .NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_LOW, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .vsense = { - .gpio = GPIOC, - .init = { - .GPIO_Pin = GPIO_Pin_15, - .GPIO_Speed = GPIO_Speed_10MHz, - .GPIO_Mode = GPIO_Mode_AF_OD, - }, - }, - .vsense_active_low = false -}; - -static const struct pios_usb_cfg pios_usb_main_cfg_cc3d = { - .irq = { - .init = { - .NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_LOW, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .vsense = { - .gpio = GPIOC, - .init = { - .GPIO_Pin = GPIO_Pin_14, - .GPIO_Speed = GPIO_Speed_10MHz, - .GPIO_Mode = GPIO_Mode_AF_OD, - }, - }, - .vsense_active_low = false -}; - -#include "pios_usb_board_data_priv.h" -#include "pios_usb_desc_hid_cdc_priv.h" -#include "pios_usb_desc_hid_only_priv.h" - -#endif /* PIOS_INCLUDE_USB */ - -#if defined(PIOS_INCLUDE_COM_MSG) - -#include - -#endif /* PIOS_INCLUDE_COM_MSG */ - -#if defined(PIOS_INCLUDE_USB_HID) -#include - -const struct pios_usb_hid_cfg pios_usb_hid_cfg = { - .data_if = 2, - .data_rx_ep = 1, - .data_tx_ep = 1, -}; - -#endif /* PIOS_INCLUDE_USB_HID */ - -#if defined(PIOS_INCLUDE_USB_RCTX) -#include - -const struct pios_usb_rctx_cfg pios_usb_rctx_cfg = { - .data_if = 2, - .data_tx_ep = 1, -}; - -#endif /* PIOS_INCLUDE_USB_RCTX */ - -#if defined(PIOS_INCLUDE_USB_CDC) -#include - -const struct pios_usb_cdc_cfg pios_usb_cdc_cfg = { - .ctrl_if = 0, - .ctrl_tx_ep = 2, - - .data_if = 1, - .data_rx_ep = 3, - .data_tx_ep = 3, -}; -#endif /* PIOS_INCLUDE_USB_CDC */ diff --git a/flight/targets/boards/coptercontrol/bootloader/Makefile b/flight/targets/boards/coptercontrol/bootloader/Makefile deleted file mode 100644 index 7c575411b..000000000 --- a/flight/targets/boards/coptercontrol/bootloader/Makefile +++ /dev/null @@ -1,32 +0,0 @@ -# -# Copyright (c) 2009-2013, The OpenPilot Team, http://www.openpilot.org -# -# This program 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 3 of the License, or -# (at your option) any later version. -# -# This program 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 this program; if not, write to the Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -ifndef OPENPILOT_IS_COOL - $(error Top level Makefile must be used to build this target) -endif - -## The standard CMSIS startup -SRC += $(CMSIS_DEVICEDIR)/system_stm32f10x.c - -include ../board-info.mk -include $(ROOT_DIR)/make/firmware-defs.mk -include $(ROOT_DIR)/make/boot-defs.mk -include $(ROOT_DIR)/make/common-defs.mk - -$(info Making bootloader for CopterControl, board revision $(BOARD_REVISION)) -$(info Use BOARD_REVISION=1 for CC, BOARD_REVISION=2 for CC3D (default)) diff --git a/flight/targets/boards/coptercontrol/bootloader/inc/common.h b/flight/targets/boards/coptercontrol/bootloader/inc/common.h deleted file mode 100644 index e64b89014..000000000 --- a/flight/targets/boards/coptercontrol/bootloader/inc/common.h +++ /dev/null @@ -1,115 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup CopterControlBL CopterControl BootLoader - * @brief These files contain the code to the CopterControl Bootloader. - * - * @{ - * @file common.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief This file contains various common defines for the BootLoader - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -#ifndef COMMON_H_ -#define COMMON_H_ - -// #include "board.h" - -typedef enum { - start, keepgoing, -} DownloadAction; - -/**************************************************/ -/* OP_DFU states */ -/**************************************************/ - -typedef enum { - DFUidle, // 0 - uploading, // 1 - wrong_packet_received, // 2 - too_many_packets, // 3 - too_few_packets, // 4 - Last_operation_Success, // 5 - downloading, // 6 - BLidle, // 7 - Last_operation_failed, // 8 - uploadingStarting, // 9 - outsideDevCapabilities, // 10 - CRC_Fail, // 11 - failed_jump, -// 12 -} DFUStates; -/**************************************************/ -/* OP_DFU commands */ -/**************************************************/ -typedef enum { - Reserved, // 0 - Req_Capabilities, // 1 - Rep_Capabilities, // 2 - EnterDFU, // 3 - JumpFW, // 4 - Reset, // 5 - Abort_Operation, // 6 - Upload, // 7 - Op_END, // 8 - Download_Req, // 9 - Download, // 10 - Status_Request, // 11 - Status_Rep -// 12 -} DFUCommands; - -typedef enum { - High_Density, Medium_Density -} DeviceType; -/**************************************************/ -/* OP_DFU transfer types */ -/**************************************************/ -typedef enum { - FW, // 0 - Descript -// 2 -} DFUTransfer; -/**************************************************/ -/* OP_DFU transfer port */ -/**************************************************/ -typedef enum { - Usb, // 0 - Serial -// 2 -} DFUPort; -/**************************************************/ -/* OP_DFU programable programable HW types */ -/**************************************************/ -typedef enum { - Self_flash, // 0 - Remote_flash_via_spi -// 1 -} DFUProgType; -/**************************************************/ -/* OP_DFU programable sources */ -/**************************************************/ -#define USB 0 -#define SPI 1 - -#define DownloadDelay 100000 - -#define MAX_DEL_RETRYS 3 -#define MAX_WRI_RETRYS 3 - -#endif /* COMMON_H_ */ diff --git a/flight/targets/boards/coptercontrol/bootloader/inc/pios_config.h b/flight/targets/boards/coptercontrol/bootloader/inc/pios_config.h deleted file mode 100644 index 43182e435..000000000 --- a/flight/targets/boards/coptercontrol/bootloader/inc/pios_config.h +++ /dev/null @@ -1,53 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup CopterControlBL CopterControl BootLoader - * @brief These files contain the code to the CopterControl Bootloader. - * @{ - * @file pios_config.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief PiOS configuration header. - * Central compile time config for the project. - * In particular, pios_config.h is where you define which PiOS libraries - * and features are included in the firmware. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef PIOS_CONFIG_H -#define PIOS_CONFIG_H - -/* Enable/Disable PiOS modules */ -#define PIOS_INCLUDE_DELAY -#define PIOS_INCLUDE_SYS -#define PIOS_INCLUDE_IRQ -#define PIOS_INCLUDE_GPIO -#define PIOS_INCLUDE_USB -#define PIOS_INCLUDE_USB_HID -#define PIOS_INCLUDE_LED -#define PIOS_INCLUDE_IAP -#define PIOS_INCLUDE_COM -#define PIOS_INCLUDE_COM_MSG -#define PIOS_INCLUDE_BL_HELPER -#define PIOS_INCLUDE_BL_HELPER_WRITE_SUPPORT - -#endif /* PIOS_CONFIG_H */ - -/** - * @} - * @} - */ diff --git a/flight/targets/boards/coptercontrol/bootloader/inc/pios_usb_board_data.h b/flight/targets/boards/coptercontrol/bootloader/inc/pios_usb_board_data.h deleted file mode 100644 index 5a40bf4cf..000000000 --- a/flight/targets/boards/coptercontrol/bootloader/inc/pios_usb_board_data.h +++ /dev/null @@ -1,53 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup PIOS PIOS Core hardware abstraction layer - * @{ - * @addtogroup PIOS_USB_BOARD Board specific USB definitions - * @brief Board specific USB definitions - * @{ - * - * @file pios_usb_board_data.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Board specific USB definitions - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef PIOS_USB_BOARD_DATA_H -#define PIOS_USB_BOARD_DATA_H - -// Note : changing below length will require changes to the USB buffer setup -#define PIOS_USB_BOARD_HID_DATA_LENGTH 64 - -#define PIOS_USB_BOARD_EP_NUM 2 - -#include /* struct usb_* */ - -#define PIOS_USB_BOARD_PRODUCT_ID USB_PRODUCT_ID_COPTERCONTROL -#define PIOS_USB_BOARD_DEVICE_VER USB_OP_DEVICE_VER(USB_OP_BOARD_ID_COPTERCONTROL, USB_OP_BOARD_MODE_BL) -#define PIOS_USB_BOARD_SN_SUFFIX "+BL" - -/* - * The bootloader uses a simplified report structure - * BL: ... - * FW: ... - * This define changes the behaviour in pios_usb_hid.c - */ -#define PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE - -#endif /* PIOS_USB_BOARD_DATA_H */ diff --git a/flight/targets/boards/coptercontrol/bootloader/main.c b/flight/targets/boards/coptercontrol/bootloader/main.c deleted file mode 100644 index 15068627c..000000000 --- a/flight/targets/boards/coptercontrol/bootloader/main.c +++ /dev/null @@ -1,223 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup CopterControlBL CopterControl BootLoader - * @brief These files contain the code to the CopterControl Bootloader. - * - * @{ - * @file main.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief This is the file with the main function of the OpenPilot BootLoader - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include -#include -#include -#include -#include -#include -#include - -/* Prototype of PIOS_Board_Init() function */ -extern void PIOS_Board_Init(void); -extern void FLASH_Download(); -#define BSL_HOLD_STATE ((PIOS_USB_DETECT_GPIO_PORT->IDR & PIOS_USB_DETECT_GPIO_PIN) ? 0 : 1) - -/* Private typedef -----------------------------------------------------------*/ -typedef void (*pFunction)(void); -/* Private define ------------------------------------------------------------*/ -/* Private macro -------------------------------------------------------------*/ -/* Private variables ---------------------------------------------------------*/ -pFunction Jump_To_Application; -uint32_t JumpAddress; - -/// LEDs PWM -uint32_t period1 = 5000; // 5 mS -uint32_t sweep_steps1 = 100; // * 5 mS -> 500 mS -uint32_t period2 = 5000; // 5 mS -uint32_t sweep_steps2 = 100; // * 5 mS -> 500 mS - - -//////////////////////////////////////// -uint8_t tempcount = 0; - -/* Extern variables ----------------------------------------------------------*/ -DFUStates DeviceState; -int16_t status = 0; -uint8_t JumpToApp = FALSE; -uint8_t GO_dfu = FALSE; -uint8_t USB_connected = FALSE; -uint8_t User_DFU_request = FALSE; -static uint8_t mReceive_Buffer[63]; -/* Private function prototypes -----------------------------------------------*/ -uint32_t LedPWM(uint32_t pwm_period, uint32_t pwm_sweep_steps, uint32_t count); -uint8_t processRX(); -void jump_to_app(); - -int main() -{ - PIOS_SYS_Init(); - PIOS_Board_Init(); - PIOS_IAP_Init(); - - USB_connected = PIOS_USB_CableConnected(0); - - if (PIOS_IAP_CheckRequest() == TRUE) { - PIOS_DELAY_WaitmS(1000); - User_DFU_request = TRUE; - PIOS_IAP_ClearRequest(); - } - - GO_dfu = (USB_connected == TRUE) || (User_DFU_request == TRUE); - - if (GO_dfu == TRUE) { - PIOS_Board_Init(); - if (User_DFU_request == TRUE) { - DeviceState = DFUidle; - } else { - DeviceState = BLidle; - } - } else { - JumpToApp = TRUE; - } - - uint32_t stopwatch = 0; - uint32_t prev_ticks = PIOS_DELAY_GetuS(); - while (TRUE) { - /* Update the stopwatch */ - uint32_t elapsed_ticks = PIOS_DELAY_GetuSSince(prev_ticks); - prev_ticks += elapsed_ticks; - stopwatch += elapsed_ticks; - - if (JumpToApp == TRUE) { - jump_to_app(); - } - - switch (DeviceState) { - case Last_operation_Success: - case uploadingStarting: - case DFUidle: - period1 = 5000; - sweep_steps1 = 100; - PIOS_LED_Off(PIOS_LED_HEARTBEAT); - period2 = 0; - break; - case uploading: - period1 = 5000; - sweep_steps1 = 100; - period2 = 2500; - sweep_steps2 = 50; - break; - case downloading: - period1 = 2500; - sweep_steps1 = 50; - PIOS_LED_Off(PIOS_LED_HEARTBEAT); - period2 = 0; - break; - case BLidle: - period1 = 0; - PIOS_LED_On(PIOS_LED_HEARTBEAT); - period2 = 0; - break; - default: // error - period1 = 5000; - sweep_steps1 = 100; - period2 = 5000; - sweep_steps2 = 100; - } - - if (period1 != 0) { - if (LedPWM(period1, sweep_steps1, stopwatch)) { - PIOS_LED_On(PIOS_LED_HEARTBEAT); - } else { - PIOS_LED_Off(PIOS_LED_HEARTBEAT); - } - } else { - PIOS_LED_On(PIOS_LED_HEARTBEAT); - } - - if (period2 != 0) { - if (LedPWM(period2, sweep_steps2, stopwatch)) { - PIOS_LED_On(PIOS_LED_HEARTBEAT); - } else { - PIOS_LED_Off(PIOS_LED_HEARTBEAT); - } - } else { - PIOS_LED_Off(PIOS_LED_HEARTBEAT); - } - - if (stopwatch > 50 * 1000 * 1000) { - stopwatch = 0; - } - if ((stopwatch > 6 * 1000 * 1000) && ((DeviceState == BLidle) || (DeviceState == DFUidle && !USB_connected))) { - JumpToApp = TRUE; - } - - processRX(); - DataDownload(start); - } -} - -void jump_to_app() -{ - const struct pios_board_info *bdinfo = &pios_board_info_blob; - - if (((*(__IO uint32_t *)bdinfo->fw_base) & 0x2FFE0000) == 0x20000000) { /* Jump to user application */ - FLASH_Lock(); - RCC_APB2PeriphResetCmd(0xffffffff, ENABLE); - RCC_APB1PeriphResetCmd(0xffffffff, ENABLE); - RCC_APB2PeriphResetCmd(0xffffffff, DISABLE); - RCC_APB1PeriphResetCmd(0xffffffff, DISABLE); - _SetCNTR(0); // clear interrupt mask - _SetISTR(0); // clear all requests - JumpAddress = *(__IO uint32_t *)(bdinfo->fw_base + 4); - Jump_To_Application = (pFunction)JumpAddress; - /* Initialize user application's Stack Pointer */ - __set_MSP(*(__IO uint32_t *)bdinfo->fw_base); - Jump_To_Application(); - } else { - DeviceState = failed_jump; - return; - } -} -uint32_t LedPWM(uint32_t pwm_period, uint32_t pwm_sweep_steps, uint32_t count) -{ - uint32_t curr_step = (count / pwm_period) % pwm_sweep_steps; /* 0 - pwm_sweep_steps */ - uint32_t pwm_duty = pwm_period * curr_step / pwm_sweep_steps; /* fraction of pwm_period */ - - uint32_t curr_sweep = (count / (pwm_period * pwm_sweep_steps)); /* ticks once per full sweep */ - - if (curr_sweep & 1) { - pwm_duty = pwm_period - pwm_duty; /* reverse direction in odd sweeps */ - } - return ((count % pwm_period) > pwm_duty) ? 1 : 0; -} - -uint8_t processRX() -{ - if (PIOS_COM_MSG_Receive(PIOS_COM_TELEM_USB, mReceive_Buffer, sizeof(mReceive_Buffer))) { - processComand(mReceive_Buffer); - } - return TRUE; -} - -int32_t platform_senddata(const uint8_t *msg, uint16_t msg_len) -{ - return PIOS_COM_MSG_Send(PIOS_COM_TELEM_USB, msg, msg_len); -} diff --git a/flight/targets/boards/coptercontrol/bootloader/pios_board.c b/flight/targets/boards/coptercontrol/bootloader/pios_board.c deleted file mode 100644 index e0a63193a..000000000 --- a/flight/targets/boards/coptercontrol/bootloader/pios_board.c +++ /dev/null @@ -1,106 +0,0 @@ -/** - ****************************************************************************** - * - * @file pios_board.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Defines board specific static initializers for hardware for the CopterControl board. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include -#include - -/* - * Pull in the board-specific static HW definitions. - * Including .c files is a bit ugly but this allows all of - * the HW definitions to be const and static to limit their - * scope. - * - * NOTE: THIS IS THE ONLY PLACE THAT SHOULD EVER INCLUDE THIS FILE - */ -#include "../board_hw_defs.c" - -uint32_t pios_com_telem_usb_id; - -/** - * PIOS_Board_Init() - * initializes all the core subsystems on this specific hardware - * called from System/openpilot.c - */ -static bool board_init_complete = false; -void PIOS_Board_Init(void) -{ - if (board_init_complete) { - return; - } - - /* Enable Prefetch Buffer */ - FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); - - /* Flash 2 wait state */ - FLASH_SetLatency(FLASH_Latency_2); - - /* Delay system */ - PIOS_DELAY_Init(); - - const struct pios_board_info *bdinfo = &pios_board_info_blob; - -#if defined(PIOS_INCLUDE_LED) - const struct pios_gpio_cfg *led_cfg = PIOS_BOARD_HW_DEFS_GetLedCfg(bdinfo->board_rev); - PIOS_Assert(led_cfg); - PIOS_LED_Init(led_cfg); -#endif /* PIOS_INCLUDE_LED */ - -#if defined(PIOS_INCLUDE_USB) - /* Initialize board specific USB data */ - PIOS_USB_BOARD_DATA_Init(); - - /* Activate the HID-only USB configuration */ - PIOS_USB_DESC_HID_ONLY_Init(); - - uint32_t pios_usb_id; - switch (bdinfo->board_rev) { - case BOARD_REVISION_CC: - PIOS_USB_Init(&pios_usb_id, &pios_usb_main_cfg_cc); - break; - case BOARD_REVISION_CC3D: - PIOS_USB_Init(&pios_usb_id, &pios_usb_main_cfg_cc3d); - break; - default: - PIOS_Assert(0); - } -#if defined(PIOS_INCLUDE_USB_HID) && defined(PIOS_INCLUDE_COM_MSG) - uint32_t pios_usb_hid_id; - if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) { - PIOS_Assert(0); - } - if (PIOS_COM_MSG_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id)) { - PIOS_Assert(0); - } -#endif /* PIOS_INCLUDE_USB_HID && PIOS_INCLUDE_COM_MSG */ - -#endif /* PIOS_INCLUDE_USB */ - - RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC, ENABLE); // TODO Tirar - - board_init_complete = true; -} - -void PIOS_ADC_DMA_Handler() -{} diff --git a/flight/targets/boards/coptercontrol/firmware/Makefile b/flight/targets/boards/coptercontrol/firmware/Makefile deleted file mode 100644 index d58b57e64..000000000 --- a/flight/targets/boards/coptercontrol/firmware/Makefile +++ /dev/null @@ -1,148 +0,0 @@ -# -# Copyright (c) 2009-2013, The OpenPilot Team, http://www.openpilot.org -# Copyright (c) 2012, PhoenixPilot, http://github.com/PhoenixPilot -# -# This program 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 3 of the License, or -# (at your option) any later version. -# -# This program 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 this program; if not, write to the Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -ifndef OPENPILOT_IS_COOL - $(error Top level Makefile must be used to build this target) -endif - -include ../board-info.mk -include $(ROOT_DIR)/make/firmware-defs.mk - -# ARM DSP library -USE_DSP_LIB ?= NO - -# Set to YES to build a FW version that will erase data flash memory -ERASE_FLASH ?= NO - -# Set to yes to include Gcsreceiver module -GCSRECEIVER ?= NO - -# Enable Diag tasks ? -DIAG_TASKS ?= NO - -# List of mandatory modules to include -MODULES += Attitude -MODULES += Stabilization -MODULES += Actuator -MODULES += Receiver -MODULES += ManualControl -MODULES += FirmwareIAP -MODULES += Telemetry - -# List of optional modules to include -OPTMODULES += CameraStab -OPTMODULES += ComUsbBridge -OPTMODULES += GPS -OPTMODULES += TxPID -OPTMODULES += Osd/osdoutput -#OPTMODULES += Altitude -#OPTMODULES += Fault - -SRC += $(FLIGHTLIB)/notification.c - -# Include all camera options -CDEFS += -DUSE_INPUT_LPF -DUSE_GIMBAL_LPF -DUSE_GIMBAL_FF - - - -# Erase flash firmware should be buildable from command line -ifeq ($(ERASE_FLASH), YES) - CDEFS += -DERASE_FLASH -endif - -# List C source files here (C dependencies are automatically generated). -# Use file-extension c for "c-only"-files -ifndef TESTAPP - ## The standard CMSIS startup - SRC += $(CMSIS_DEVICEDIR)/system_stm32f10x.c - - ## Application Core - SRC += ../pios_usb_board_data.c - SRC += $(OPMODULEDIR)/System/systemmod.c - SRC += $(OPSYSTEM)/coptercontrol.c - SRC += $(OPSYSTEM)/pios_board.c - SRC += $(FLIGHTLIB)/alarms.c - SRC += $(FLIGHTLIB)/instrumentation.c - SRC += $(OPUAVTALK)/uavtalk.c - SRC += $(OPUAVOBJ)/uavobjectmanager.c - SRC += $(OPUAVOBJ)/uavobjectpersistence.c - SRC += $(OPUAVOBJ)/eventdispatcher.c - - ## UAVObjects - SRC += $(OPUAVSYNTHDIR)/accessorydesired.c - SRC += $(OPUAVSYNTHDIR)/objectpersistence.c - SRC += $(OPUAVSYNTHDIR)/gcstelemetrystats.c - SRC += $(OPUAVSYNTHDIR)/flighttelemetrystats.c - SRC += $(OPUAVSYNTHDIR)/faultsettings.c - SRC += $(OPUAVSYNTHDIR)/flightstatus.c - SRC += $(OPUAVSYNTHDIR)/systemstats.c - SRC += $(OPUAVSYNTHDIR)/systemalarms.c - SRC += $(OPUAVSYNTHDIR)/systemsettings.c - SRC += $(OPUAVSYNTHDIR)/stabilizationdesired.c - SRC += $(OPUAVSYNTHDIR)/stabilizationsettings.c - SRC += $(OPUAVSYNTHDIR)/stabilizationsettingsbank1.c - SRC += $(OPUAVSYNTHDIR)/stabilizationsettingsbank2.c - SRC += $(OPUAVSYNTHDIR)/stabilizationsettingsbank3.c - SRC += $(OPUAVSYNTHDIR)/stabilizationstatus.c - SRC += $(OPUAVSYNTHDIR)/stabilizationbank.c - SRC += $(OPUAVSYNTHDIR)/actuatorcommand.c - SRC += $(OPUAVSYNTHDIR)/actuatordesired.c - SRC += $(OPUAVSYNTHDIR)/actuatorsettings.c - SRC += $(OPUAVSYNTHDIR)/accelstate.c - SRC += $(OPUAVSYNTHDIR)/accelgyrosettings.c - SRC += $(OPUAVSYNTHDIR)/gyrostate.c - SRC += $(OPUAVSYNTHDIR)/attitudestate.c - SRC += $(OPUAVSYNTHDIR)/manualcontrolcommand.c - SRC += $(OPUAVSYNTHDIR)/watchdogstatus.c - SRC += $(OPUAVSYNTHDIR)/manualcontrolsettings.c - SRC += $(OPUAVSYNTHDIR)/flightmodesettings.c - SRC += $(OPUAVSYNTHDIR)/mixersettings.c - SRC += $(OPUAVSYNTHDIR)/firmwareiapobj.c - SRC += $(OPUAVSYNTHDIR)/attitudesettings.c - SRC += $(OPUAVSYNTHDIR)/camerastabsettings.c - SRC += $(OPUAVSYNTHDIR)/cameradesired.c - SRC += $(OPUAVSYNTHDIR)/gpspositionsensor.c - SRC += $(OPUAVSYNTHDIR)/gpsvelocitysensor.c - SRC += $(OPUAVSYNTHDIR)/gpssettings.c - SRC += $(OPUAVSYNTHDIR)/hwsettings.c - SRC += $(OPUAVSYNTHDIR)/receiveractivity.c - SRC += $(OPUAVSYNTHDIR)/mixerstatus.c - SRC += $(OPUAVSYNTHDIR)/ratedesired.c - SRC += $(OPUAVSYNTHDIR)/txpidsettings.c - SRC += $(OPUAVSYNTHDIR)/mpu6000settings.c - # Command line option for Gcsreceiver module - ifeq ($(GCSRECEIVER), YES) - SRC += $(OPUAVSYNTHDIR)/gcsreceiver.c - endif - # Enable Diag tasks and UAVOs needed - ifeq ($(DIAG_TASKS), YES) - CDEFS += -DDIAG_TASKS - SRC += $(OPUAVSYNTHDIR)/taskinfo.c - SRC += $(OPUAVSYNTHDIR)/callbackinfo.c - SRC += $(OPUAVSYNTHDIR)/perfcounter.c - SRC += $(OPUAVSYNTHDIR)/i2cstats.c - endif -else - ## Test Code - SRC += $(OPTESTS)/test_common.c - SRC += $(OPTESTS)/$(TESTAPP).c -endif - -include $(ROOT_DIR)/make/apps-defs.mk -include $(ROOT_DIR)/make/common-defs.mk diff --git a/flight/targets/boards/coptercontrol/firmware/coptercontrol.c b/flight/targets/boards/coptercontrol/firmware/coptercontrol.c deleted file mode 100644 index e748f6317..000000000 --- a/flight/targets/boards/coptercontrol/firmware/coptercontrol.c +++ /dev/null @@ -1,117 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup OpenPilotSystem OpenPilot System - * @brief These files are the core system files of OpenPilot. - * They are the ground layer just above PiOS. In practice, OpenPilot actually starts - * in the main() function of openpilot.c - * @{ - * @addtogroup OpenPilotCore OpenPilot Core - * @brief This is where the OP firmware starts. Those files also define the compile-time - * options of the firmware. - * @{ - * @file openpilot.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Sets up and runs main OpenPilot tasks. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include "inc/openpilot.h" -#include -#include - -/* Task Priorities */ -#define PRIORITY_TASK_HOOKS (tskIDLE_PRIORITY + 3) - -/* Global Variables */ - -/* Prototype of PIOS_Board_Init() function */ -extern void PIOS_Board_Init(void); -extern void Stack_Change(void); - -/** - * OpenPilot Main function: - * - * Initialize PiOS
- * Create the "System" task (SystemModInitializein Modules/System/systemmod.c)
- * Start FreeRTOS Scheduler (vTaskStartScheduler) (Now handled by caller) - * If something goes wrong, blink LED1 and LED2 every 100ms - * - */ -int main() -{ - /* NOTE: Do NOT modify the following start-up sequence */ - /* Any new initialization functions should be added in OpenPilotInit() */ - - /* Brings up System using CMSIS functions, enables the LEDs. */ - PIOS_SYS_Init(); - - /* Architecture dependant Hardware and - * core subsystem initialisation - * (see pios_board.c for your arch) - * */ - PIOS_Board_Init(); - -#ifdef ERASE_FLASH - PIOS_Flash_Jedec_EraseChip(); -#if defined(PIOS_LED_HEARTBEAT) - PIOS_LED_Off(PIOS_LED_HEARTBEAT); -#endif /* PIOS_LED_HEARTBEAT */ - while (1) { - ; - } -#endif - - /* Initialize modules */ - MODULE_INITIALISE_ALL - /* swap the stack to use the IRQ stack */ - Stack_Change(); - - /* Start the FreeRTOS scheduler, which should never return. - * - * NOTE: OpenPilot runs an operating system (FreeRTOS), which constantly calls - * (schedules) function files (modules). These functions never return from their - * while loops, which explains why each module has a while(1){} segment. Thus, - * the OpenPilot software actually starts at the vTaskStartScheduler() function, - * even though this is somewhat obscure. - * - * In addition, there are many main() functions in the OpenPilot firmware source tree - * This is because each main() refers to a separate hardware platform. Of course, - * C only allows one main(), so only the relevant main() function is compiled when - * making a specific firmware. - * - */ - vTaskStartScheduler(); - - /* If all is well we will never reach here as the scheduler will now be running. */ - - /* Do some indication to user that something bad just happened */ - while (1) { -#if defined(PIOS_LED_HEARTBEAT) - PIOS_LED_Toggle(PIOS_LED_HEARTBEAT); -#endif /* PIOS_LED_HEARTBEAT */ - PIOS_DELAY_WaitmS(100); - } - - return 0; -} - -/** - * @} - * @} - */ diff --git a/flight/targets/boards/coptercontrol/firmware/inc/FreeRTOSConfig.h b/flight/targets/boards/coptercontrol/firmware/inc/FreeRTOSConfig.h deleted file mode 100644 index 429d86ade..000000000 --- a/flight/targets/boards/coptercontrol/firmware/inc/FreeRTOSConfig.h +++ /dev/null @@ -1,99 +0,0 @@ -#ifndef FREERTOS_CONFIG_H -#define FREERTOS_CONFIG_H - -/*----------------------------------------------------------- -* Application specific definitions. -* -* These definitions should be adjusted for your particular hardware and -* application requirements. -* -* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE -* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. -* -* See http://www.freertos.org/a00110.html. -*----------------------------------------------------------*/ - -/** - * @addtogroup PIOS PIOS - * @{ - * @addtogroup FreeRTOS FreeRTOS - * @{ - */ - -/* Notes: We use 5 task priorities */ - -#define configUSE_PREEMPTION 1 -#define configUSE_IDLE_HOOK 1 -#define configUSE_TICK_HOOK 0 -#define configUSE_MALLOC_FAILED_HOOK 1 -#define configCPU_CLOCK_HZ ((unsigned long)72000000) -#define configTICK_RATE_HZ ((portTickType)1000) -#define configMAX_PRIORITIES ((unsigned portBASE_TYPE)5) -#define configMINIMAL_STACK_SIZE ((unsigned short)48) -#define configTOTAL_HEAP_SIZE ((size_t)(53 * 256)) -#define configMAX_TASK_NAME_LEN (6) -#define configUSE_TRACE_FACILITY 0 -#define configUSE_16_BIT_TICKS 0 -#define configIDLE_SHOULD_YIELD 0 -#define configUSE_MUTEXES 1 -#define configUSE_RECURSIVE_MUTEXES 1 -#define configUSE_COUNTING_SEMAPHORES 0 -#define configUSE_ALTERNATIVE_API 0 -#define configQUEUE_REGISTRY_SIZE 0 - -/* Co-routine definitions. */ -#define configUSE_CO_ROUTINES 0 -#define configMAX_CO_ROUTINE_PRIORITIES (2) - -/* Set the following definitions to 1 to include the API function, or zero - to exclude the API function. */ - -#define INCLUDE_vTaskPrioritySet 1 -#define INCLUDE_uxTaskPriorityGet 1 -#define INCLUDE_vTaskDelete 1 -#define INCLUDE_vTaskCleanUpResources 0 -#define INCLUDE_vTaskSuspend 1 -#define INCLUDE_vTaskDelayUntil 1 -#define INCLUDE_vTaskDelay 1 -#define INCLUDE_xTaskGetSchedulerState 0 -#define INCLUDE_xTaskGetCurrentTaskHandle 1 -#define INCLUDE_uxTaskGetStackHighWaterMark 1 - -/* This is the raw value as per the Cortex-M3 NVIC. Values can be 255 - (lowest) to 1 (highest maskable) to 0 (highest non-maskable). */ -#define configKERNEL_INTERRUPT_PRIORITY 15 << 4 /* equivalent to NVIC priority 15 */ - #define configMAX_SYSCALL_INTERRUPT_PRIORITY 3 << 4 /* equivalent to NVIC priority 3 */ - -/* This is the value being used as per the ST library which permits 16 - priority values, 0 to 15. This must correspond to the - configKERNEL_INTERRUPT_PRIORITY setting. Here 15 corresponds to the lowest - NVIC value of 255. */ -#define configLIBRARY_KERNEL_INTERRUPT_PRIORITY 15 - -#if !defined(ARCH_POSIX) && !defined(ARCH_WIN32) -#define CHECK_IRQ_STACK -#endif - -/* Enable run time stats collection */ -#define configGENERATE_RUN_TIME_STATS 1 -#define INCLUDE_uxTaskGetRunTime 1 -#define INCLUDE_xTaskGetIdleTaskHandle 1 -#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() \ - do { \ - (*(unsigned long *)0xe000edfc) |= (1 << 24); /* DEMCR |= DEMCR_TRCENA */ \ - (*(unsigned long *)0xe0001000) |= 1; /* DWT_CTRL |= DWT_CYCCNT_ENA */ \ - } \ - while (0) -#define portGET_RUN_TIME_COUNTER_VALUE() (*(unsigned long *)0xe0001004) /* DWT_CYCCNT */ - -#ifdef DIAG_TASKS -#define configCHECK_FOR_STACK_OVERFLOW 2 -#else -#define configCHECK_FOR_STACK_OVERFLOW 1 -#endif - -/** - * @} - */ - -#endif /* FREERTOS_CONFIG_H */ diff --git a/flight/targets/boards/coptercontrol/firmware/inc/openpilot.h b/flight/targets/boards/coptercontrol/firmware/inc/openpilot.h deleted file mode 100644 index 5576baca6..000000000 --- a/flight/targets/boards/coptercontrol/firmware/inc/openpilot.h +++ /dev/null @@ -1,52 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup OpenPilotSystem OpenPilot System - * @{ - * @addtogroup OpenPilotCore OpenPilot Core - * @{ - * @file openpilot.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Main OpenPilot header. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef OPENPILOT_H -#define OPENPILOT_H - -/* PIOS Includes */ -#include - -/* OpenPilot Libraries */ -#include -#include -#include -#include - -#include "alarms.h" -#include - -/* Global Functions */ -void OpenPilotInit(void); - -#endif /* OPENPILOT_H */ - -/** - * @} - * @} - */ diff --git a/flight/targets/boards/coptercontrol/firmware/inc/pios_board_posix.h b/flight/targets/boards/coptercontrol/firmware/inc/pios_board_posix.h deleted file mode 100644 index 16364d7fa..000000000 --- a/flight/targets/boards/coptercontrol/firmware/inc/pios_board_posix.h +++ /dev/null @@ -1,81 +0,0 @@ -/** - ****************************************************************************** - * - * @file pios_board.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Defines board hardware for the OpenPilot Version 1.1 hardware. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - - -#ifndef PIOS_BOARD_H -#define PIOS_BOARD_H - - -// ------------------------ -// PIOS_LED -// ------------------------ -// #define PIOS_LED_LED1_GPIO_PORT GPIOC -// #define PIOS_LED_LED1_GPIO_PIN GPIO_Pin_12 -// #define PIOS_LED_LED1_GPIO_CLK RCC_APB2Periph_GPIOC -// #define PIOS_LED_LED2_GPIO_PORT GPIOC -// #define PIOS_LED_LED2_GPIO_PIN GPIO_Pin_13 -// #define PIOS_LED_LED2_GPIO_CLK RCC_APB2Periph_GPIOC -#define PIOS_LED_NUM 2 -// #define PIOS_LED_PORTS { PIOS_LED_LED1_GPIO_PORT, PIOS_LED_LED2_GPIO_PORT } -// #define PIOS_LED_PINS { PIOS_LED_LED1_GPIO_PIN, PIOS_LED_LED2_GPIO_PIN } -// #define PIOS_LED_CLKS { PIOS_LED_LED1_GPIO_CLK, PIOS_LED_LED2_GPIO_CLK } - - -// ------------------------- -// COM -// -// See also pios_board_posix.c -// ------------------------- -// #define PIOS_USART_TX_BUFFER_SIZE 256 -#define PIOS_COM_BUFFER_SIZE 1024 -#define PIOS_UDP_RX_BUFFER_SIZE PIOS_COM_BUFFER_SIZE - -#define PIOS_COM_TELEM_RF 0 -#define PIOS_COM_GPS 1 -#define PIOS_COM_TELEM_USB 2 - -#ifdef PIOS_ENABLE_AUX_UART -#define PIOS_COM_AUX 3 -#define PIOS_COM_DEBUG PIOS_COM_AUX -#endif - -/** - * glue macros for file IO - * STM32 uses DOSFS for file IO - */ -#define PIOS_FOPEN_READ(filename, file) (file = fopen((char *)filename, "r")) == NULL - -#define PIOS_FOPEN_WRITE(filename, file) (file = fopen((char *)filename, "w")) == NULL - -#define PIOS_FREAD(file, bufferadr, length, resultadr) (*resultadr = fread((uint8_t *)bufferadr, 1, length, *file)) != length - -#define PIOS_FWRITE(file, bufferadr, length, resultadr) *resultadr = fwrite((uint8_t *)bufferadr, 1, length, *file) - - -#define PIOS_FCLOSE(file) fclose(file) - -#define PIOS_FUNLINK(file) unlink((char *)filename) - -#endif /* PIOS_BOARD_H */ diff --git a/flight/targets/boards/coptercontrol/firmware/inc/pios_config.h b/flight/targets/boards/coptercontrol/firmware/inc/pios_config.h deleted file mode 100644 index a371b908f..000000000 --- a/flight/targets/boards/coptercontrol/firmware/inc/pios_config.h +++ /dev/null @@ -1,188 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup OpenPilotSystem OpenPilot System - * @{ - * @addtogroup OpenPilotCore OpenPilot Core - * @{ - * @file pios_config.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010-2013. - * @brief PiOS configuration header, the compile time config file for the PIOS. - * Defines which PiOS libraries and features are included in the firmware. - * @see The GNU Public License (GPL) Version 3 - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef PIOS_CONFIG_H -#define PIOS_CONFIG_H - -/* - * Below is a complete list of PIOS configurable options. - * Please do not remove or rearrange them. Only comment out - * unused options in the list. See main pios.h header for more - * details. - */ - -/* #define PIOS_INCLUDE_DEBUG_CONSOLE */ -/* #define DEBUG_LEVEL 0 */ -/* #define PIOS_ENABLE_DEBUG_PINS */ - -/* PIOS FreeRTOS support */ -#define PIOS_INCLUDE_FREERTOS - - -/* PIOS CallbackScheduler support */ -#define PIOS_INCLUDE_CALLBACKSCHEDULER - -/* PIOS bootloader helper */ -#define PIOS_INCLUDE_BL_HELPER -/* #define PIOS_INCLUDE_BL_HELPER_WRITE_SUPPORT */ - -/* PIOS system functions */ -#define PIOS_INCLUDE_DELAY -#define PIOS_INCLUDE_INITCALL -#define PIOS_INCLUDE_SYS -#define PIOS_INCLUDE_TASK_MONITOR -// #define PIOS_INCLUDE_INSTRUMENTATION -#define PIOS_INSTRUMENTATION_MAX_COUNTERS 5 - -/* PIOS hardware peripherals */ -#define PIOS_INCLUDE_IRQ -#define PIOS_INCLUDE_RTC -#define PIOS_INCLUDE_TIM -#define PIOS_INCLUDE_USART -#define PIOS_INCLUDE_ADC -/* #define PIOS_INCLUDE_I2C */ -#define PIOS_INCLUDE_SPI -#define PIOS_INCLUDE_GPIO -#define PIOS_INCLUDE_EXTI -#define PIOS_INCLUDE_WDG - -/* PIOS USB functions */ -#define PIOS_INCLUDE_USB -#define PIOS_INCLUDE_USB_HID -#define PIOS_INCLUDE_USB_CDC -#define PIOS_INCLUDE_USB_RCTX - -/* PIOS sensor interfaces */ -#define PIOS_INCLUDE_ADXL345 -/* #define PIOS_INCLUDE_BMA180 */ -/* #define PIOS_INCLUDE_L3GD20 */ -#define PIOS_INCLUDE_MPU6000 -#define PIOS_MPU6000_ACCEL -/* #define PIOS_INCLUDE_HMC5843 */ -/* #define PIOS_INCLUDE_HMC5X83 */ -/* #define PIOS_HMC5883_HAS_GPIOS */ -/* #define PIOS_INCLUDE_BMP085 */ -/* #define PIOS_INCLUDE_MS5611 */ -/* #define PIOS_INCLUDE_MPXV */ -/* #define PIOS_INCLUDE_ETASV3 */ -/* #define PIOS_INCLUDE_HCSR04 */ - -#define PIOS_SENSOR_RATE 500.0f - -/* PIOS receiver drivers */ -#define PIOS_INCLUDE_PWM -#define PIOS_INCLUDE_PPM -#define PIOS_INCLUDE_PPM_FLEXI -#define PIOS_INCLUDE_DSM -#define PIOS_INCLUDE_SBUS -/* #define PIOS_INCLUDE_GCSRCVR */ -/* #define PIOS_INCLUDE_OPLINKRCVR */ - -/* PIOS abstract receiver interface */ -#define PIOS_INCLUDE_RCVR - -/* PIOS common peripherals */ -#define PIOS_INCLUDE_LED -#define PIOS_INCLUDE_IAP -#define PIOS_INCLUDE_SERVO -/* #define PIOS_INCLUDE_I2C_ESC */ -/* #define PIOS_INCLUDE_OVERO */ -/* #define PIOS_OVERO_SPI */ -/* #define PIOS_INCLUDE_SDCARD */ -/* #define LOG_FILENAME "startup.log" */ -#define PIOS_INCLUDE_FLASH -#define PIOS_INCLUDE_FLASH_LOGFS_SETTINGS -/* #define FLASH_FREERTOS */ -/* #define PIOS_INCLUDE_FLASH_EEPROM */ -/* #define PIOS_INCLUDE_FLASH_INTERNAL */ - -/* PIOS radio modules */ -/* #define PIOS_INCLUDE_RFM22B */ -/* #define PIOS_INCLUDE_RFM22B_COM */ -/* #define PIOS_INCLUDE_PPM_OUT */ -/* #define PIOS_RFM22B_DEBUG_ON_TELEM */ - -/* PIOS misc peripherals */ -/* #define PIOS_INCLUDE_VIDEO */ -/* #define PIOS_INCLUDE_WAVE */ -/* #define PIOS_INCLUDE_UDP */ - -/* PIOS abstract comms interface with options */ -#define PIOS_INCLUDE_COM -/* #define PIOS_INCLUDE_COM_MSG */ -#define PIOS_INCLUDE_TELEMETRY_RF -/* #define PIOS_INCLUDE_COM_TELEM */ -/* #define PIOS_INCLUDE_COM_FLEXI */ -/* #define PIOS_INCLUDE_COM_AUX */ -/* #define PIOS_TELEM_PRIORITY_QUEUE */ -#define PIOS_INCLUDE_GPS -#define PIOS_GPS_MINIMAL -/* #define PIOS_INCLUDE_GPS_NMEA_PARSER */ -#define PIOS_INCLUDE_GPS_UBX_PARSER -/* #define PIOS_GPS_SETS_HOMELOCATION */ - -/* Stabilization options */ -/* #define PIOS_QUATERNION_STABILIZATION */ -#define PIOS_EXCLUDE_ADVANCED_FEATURES -/* Performance counters */ -#define IDLE_COUNTS_PER_SEC_AT_NO_LOAD 1995998 - -/* Alarm Thresholds */ -#define HEAP_LIMIT_WARNING 220 -#define HEAP_LIMIT_CRITICAL 40 -#define IRQSTACK_LIMIT_WARNING 100 -#define IRQSTACK_LIMIT_CRITICAL 60 -#define CPULOAD_LIMIT_WARNING 85 -#define CPULOAD_LIMIT_CRITICAL 95 - -/* Task stack sizes */ -#define PIOS_ACTUATOR_STACK_SIZE 820 -#define PIOS_MANUAL_STACK_SIZE 735 -#define PIOS_RECEIVER_STACK_SIZE 620 -#define PIOS_STABILIZATION_STACK_SIZE 400 - -#ifdef DIAG_TASKS -#define PIOS_SYSTEM_STACK_SIZE 740 -#else -#define PIOS_SYSTEM_STACK_SIZE 660 -#endif -#define PIOS_TELEM_RX_STACK_SIZE 410 -#define PIOS_TELEM_TX_STACK_SIZE 560 -#define PIOS_EVENTDISPATCHER_STACK_SIZE 95 - -/* This can't be too high to stop eventdispatcher thread overflowing */ -#define PIOS_EVENTDISAPTCHER_QUEUE 10 - -/* Revolution series */ -/* #define REVOLUTION */ - -#endif /* PIOS_CONFIG_H */ -/** - * @} - * @} - */ diff --git a/flight/targets/boards/coptercontrol/firmware/inc/pios_config_posix.h b/flight/targets/boards/coptercontrol/firmware/inc/pios_config_posix.h deleted file mode 100644 index 4e8aa47c6..000000000 --- a/flight/targets/boards/coptercontrol/firmware/inc/pios_config_posix.h +++ /dev/null @@ -1,48 +0,0 @@ -/** - ****************************************************************************** - * - * @file pios_config.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief PiOS configuration header. - * Central compile time config for the project. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - - -#ifndef PIOS_CONFIG_POSIX_H -#define PIOS_CONFIG_POSIX_H - - -/* Enable/Disable PiOS Modules */ -#define PIOS_INCLUDE_SYS -#define PIOS_INCLUDE_DELAY -#define PIOS_INCLUDE_LED -#define PIOS_INCLUDE_FREERTOS -#define PIOS_INCLUDE_CALLBACKSCHEDULER -#define PIOS_INCLUDE_TASK_MONITOR -#define PIOS_INCLUDE_COM -#define PIOS_INCLUDE_UDP -#define PIOS_INCLUDE_SERVO - - -/* Defaults for Logging */ -#define LOG_FILENAME "PIOS.LOG" -#define STARTUP_LOG_ENABLED 1 - -#endif /* PIOS_CONFIG_POSIX_H */ diff --git a/flight/targets/boards/coptercontrol/firmware/inc/pios_usb_board_data.h b/flight/targets/boards/coptercontrol/firmware/inc/pios_usb_board_data.h deleted file mode 100644 index 1fac7c659..000000000 --- a/flight/targets/boards/coptercontrol/firmware/inc/pios_usb_board_data.h +++ /dev/null @@ -1,47 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup PIOS PIOS Core hardware abstraction layer - * @{ - * @addtogroup PIOS_USB_BOARD Board specific USB definitions - * @brief Board specific USB definitions - * @{ - * - * @file pios_usb_board_data.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Board specific USB definitions - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef PIOS_USB_BOARD_DATA_H -#define PIOS_USB_BOARD_DATA_H - -// Note : changing below length will require changes to the USB buffer setup -#define PIOS_USB_BOARD_CDC_DATA_LENGTH 64 -#define PIOS_USB_BOARD_CDC_MGMT_LENGTH 32 -#define PIOS_USB_BOARD_HID_DATA_LENGTH 64 - -#define PIOS_USB_BOARD_EP_NUM 4 - -#include /* USB_* macros */ - -#define PIOS_USB_BOARD_PRODUCT_ID USB_PRODUCT_ID_COPTERCONTROL -#define PIOS_USB_BOARD_DEVICE_VER USB_OP_DEVICE_VER(USB_OP_BOARD_ID_COPTERCONTROL, USB_OP_BOARD_MODE_FW) -#define PIOS_USB_BOARD_SN_SUFFIX "+FW" - -#endif /* PIOS_USB_BOARD_DATA_H */ diff --git a/flight/targets/boards/coptercontrol/firmware/pios_board.c b/flight/targets/boards/coptercontrol/firmware/pios_board.c deleted file mode 100644 index 474a21330..000000000 --- a/flight/targets/boards/coptercontrol/firmware/pios_board.c +++ /dev/null @@ -1,920 +0,0 @@ -/** - ***************************************************************************** - * @file pios_board.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @author PhoenixPilot, http://github.com/PhoenixPilot, Copyright (C) 2012 - * @addtogroup OpenPilotSystem OpenPilot System - * @{ - * @addtogroup OpenPilotCore OpenPilot Core - * @{ - * @brief Defines board specific static initializers for hardware for the CopterControl board. - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include "inc/openpilot.h" -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef PIOS_INCLUDE_INSTRUMENTATION -#include -#endif -#if defined(PIOS_INCLUDE_ADXL345) -#include -#endif - -/* - * Pull in the board-specific static HW definitions. - * Including .c files is a bit ugly but this allows all of - * the HW definitions to be const and static to limit their - * scope. - * - * NOTE: THIS IS THE ONLY PLACE THAT SHOULD EVER INCLUDE THIS FILE - */ -#include "../board_hw_defs.c" - -/* One slot per selectable receiver group. - * eg. PWM, PPM, GCS, DSMMAINPORT, DSMFLEXIPORT, SBUS - * NOTE: No slot in this map for NONE. - */ -uint32_t pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE]; - -static SystemAlarmsExtendedAlarmStatusOptions CopterControlConfigHook(); -static void ActuatorSettingsUpdatedCb(UAVObjEvent *ev); - -#define PIOS_COM_TELEM_RF_RX_BUF_LEN 32 -#define PIOS_COM_TELEM_RF_TX_BUF_LEN 12 - -#define PIOS_COM_GPS_RX_BUF_LEN 32 - -#define PIOS_COM_TELEM_USB_RX_BUF_LEN 65 -#define PIOS_COM_TELEM_USB_TX_BUF_LEN 65 - -#define PIOS_COM_BRIDGE_RX_BUF_LEN 65 -#define PIOS_COM_BRIDGE_TX_BUF_LEN 12 - -#define PIOS_COM_HKOSD_TX_BUF_LEN 22 - -#if defined(PIOS_INCLUDE_DEBUG_CONSOLE) -#define PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN 40 -uint32_t pios_com_debug_id; -#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */ - -uint32_t pios_com_telem_rf_id; -uint32_t pios_com_telem_usb_id; -uint32_t pios_com_vcp_id; -uint32_t pios_com_gps_id; -uint32_t pios_com_bridge_id; -uint32_t pios_com_hkosd_id; - -uint32_t pios_usb_rctx_id; - -uintptr_t pios_uavo_settings_fs_id; -uintptr_t pios_user_fs_id = 0; -/** - * Configuration for MPU6000 chip - */ -#if defined(PIOS_INCLUDE_MPU6000) -#include "pios_mpu6000.h" -#include "pios_mpu6000_config.h" -static const struct pios_exti_cfg pios_exti_mpu6000_cfg __exti_config = { - .vector = PIOS_MPU6000_IRQHandler, - .line = EXTI_Line3, - .pin = { - .gpio = GPIOA, - .init = { - .GPIO_Pin = GPIO_Pin_3, - .GPIO_Speed = GPIO_Speed_10MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, - .irq = { - .init = { - .NVIC_IRQChannel = EXTI3_IRQn, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .exti = { - .init = { - .EXTI_Line = EXTI_Line3, // matches above GPIO pin - .EXTI_Mode = EXTI_Mode_Interrupt, - .EXTI_Trigger = EXTI_Trigger_Rising, - .EXTI_LineCmd = ENABLE, - }, - }, -}; - -static const struct pios_mpu6000_cfg pios_mpu6000_cfg = { - .exti_cfg = &pios_exti_mpu6000_cfg, - .Fifo_store = PIOS_MPU6000_FIFO_TEMP_OUT | PIOS_MPU6000_FIFO_GYRO_X_OUT | PIOS_MPU6000_FIFO_GYRO_Y_OUT | PIOS_MPU6000_FIFO_GYRO_Z_OUT, - // Clock at 8 khz, downsampled by 8 for 1000 Hz - .Smpl_rate_div_no_dlp = 7, - // Clock at 1 khz, downsampled by 1 for 1000 Hz - .Smpl_rate_div_dlp = 0, - .interrupt_cfg = PIOS_MPU6000_INT_CLR_ANYRD, - .interrupt_en = PIOS_MPU6000_INTEN_DATA_RDY, - .User_ctl = PIOS_MPU6000_USERCTL_DIS_I2C, - .Pwr_mgmt_clk = PIOS_MPU6000_PWRMGMT_PLL_X_CLK, - .accel_range = PIOS_MPU6000_ACCEL_8G, - .gyro_range = PIOS_MPU6000_SCALE_2000_DEG, - .filter = PIOS_MPU6000_LOWPASS_256_HZ, - .orientation = PIOS_MPU6000_TOP_180DEG, - .fast_prescaler = PIOS_SPI_PRESCALER_4, - .std_prescaler = PIOS_SPI_PRESCALER_64, - .max_downsample = 2 -}; -#endif /* PIOS_INCLUDE_MPU6000 */ - -/** - * PIOS_Board_Init() - * initializes all the core subsystems on this specific hardware - * called from System/openpilot.c - */ -int32_t init_test; -void PIOS_Board_Init(void) -{ - /* Delay system */ - PIOS_DELAY_Init(); - - const struct pios_board_info *bdinfo = &pios_board_info_blob; - -#if defined(PIOS_INCLUDE_LED) - const struct pios_gpio_cfg *led_cfg = PIOS_BOARD_HW_DEFS_GetLedCfg(bdinfo->board_rev); - PIOS_Assert(led_cfg); - PIOS_LED_Init(led_cfg); -#endif /* PIOS_INCLUDE_LED */ - -#ifdef PIOS_INCLUDE_INSTRUMENTATION - PIOS_Instrumentation_Init(PIOS_INSTRUMENTATION_MAX_COUNTERS); -#endif - -#if defined(PIOS_INCLUDE_SPI) - /* Set up the SPI interface to the serial flash */ - - switch (bdinfo->board_rev) { - case BOARD_REVISION_CC: - if (PIOS_SPI_Init(&pios_spi_flash_accel_id, &pios_spi_flash_accel_cfg_cc)) { - PIOS_Assert(0); - } - break; - case BOARD_REVISION_CC3D: - if (PIOS_SPI_Init(&pios_spi_flash_accel_id, &pios_spi_flash_accel_cfg_cc3d)) { - PIOS_Assert(0); - } - break; - default: - PIOS_Assert(0); - } - -#endif - - uintptr_t flash_id; - switch (bdinfo->board_rev) { - case BOARD_REVISION_CC: - if (PIOS_Flash_Jedec_Init(&flash_id, pios_spi_flash_accel_id, 1)) { - PIOS_DEBUG_Assert(0); - } - if (PIOS_FLASHFS_Logfs_Init(&pios_uavo_settings_fs_id, &flashfs_w25x_cfg, &pios_jedec_flash_driver, flash_id)) { - PIOS_DEBUG_Assert(0); - } - break; - case BOARD_REVISION_CC3D: - if (PIOS_Flash_Jedec_Init(&flash_id, pios_spi_flash_accel_id, 0)) { - PIOS_DEBUG_Assert(0); - } - if (PIOS_FLASHFS_Logfs_Init(&pios_uavo_settings_fs_id, &flashfs_m25p_cfg, &pios_jedec_flash_driver, flash_id)) { - PIOS_DEBUG_Assert(0); - } - break; - default: - PIOS_DEBUG_Assert(0); - } - - /* Initialize the task monitor */ - if (PIOS_TASK_MONITOR_Initialize(TASKINFO_RUNNING_NUMELEM)) { - PIOS_Assert(0); - } - - /* Initialize the delayed callback library */ - PIOS_CALLBACKSCHEDULER_Initialize(); - - /* Initialize UAVObject libraries */ - EventDispatcherInitialize(); - UAVObjInitialize(); - -#if defined(PIOS_INCLUDE_RTC) - /* Initialize the real-time clock and its associated tick */ - PIOS_RTC_Init(&pios_rtc_main_cfg); -#endif - PIOS_IAP_Init(); - // check for safe mode commands from gcs - if (PIOS_IAP_ReadBootCmd(0) == PIOS_IAP_CLEAR_FLASH_CMD_0 && - PIOS_IAP_ReadBootCmd(1) == PIOS_IAP_CLEAR_FLASH_CMD_1 && - PIOS_IAP_ReadBootCmd(2) == PIOS_IAP_CLEAR_FLASH_CMD_2) { - PIOS_FLASHFS_Format(pios_uavo_settings_fs_id); - PIOS_IAP_WriteBootCmd(0, 0); - PIOS_IAP_WriteBootCmd(1, 0); - PIOS_IAP_WriteBootCmd(2, 0); - } - - HwSettingsInitialize(); - -#ifndef ERASE_FLASH -#ifdef PIOS_INCLUDE_WDG - /* Initialize watchdog as early as possible to catch faults during init */ - PIOS_WDG_Init(); -#endif -#endif - - /* Initialize the alarms library */ - AlarmsInitialize(); - - /* Check for repeated boot failures */ - uint16_t boot_count = PIOS_IAP_ReadBootCount(); - if (boot_count < 3) { - PIOS_IAP_WriteBootCount(++boot_count); - AlarmsClear(SYSTEMALARMS_ALARM_BOOTFAULT); - } else { - /* Too many failed boot attempts, force hwsettings to defaults */ - HwSettingsSetDefaults(HwSettingsHandle(), 0); - AlarmsSet(SYSTEMALARMS_ALARM_BOOTFAULT, SYSTEMALARMS_ALARM_CRITICAL); - } - - /* Set up pulse timers */ - PIOS_TIM_InitClock(&tim_1_cfg); - PIOS_TIM_InitClock(&tim_2_cfg); - PIOS_TIM_InitClock(&tim_3_cfg); - PIOS_TIM_InitClock(&tim_4_cfg); - -#if defined(PIOS_INCLUDE_USB) - /* Initialize board specific USB data */ - PIOS_USB_BOARD_DATA_Init(); - - - /* Flags to determine if various USB interfaces are advertised */ - bool usb_hid_present = false; - bool usb_cdc_present = false; - -#if defined(PIOS_INCLUDE_USB_CDC) - if (PIOS_USB_DESC_HID_CDC_Init()) { - PIOS_Assert(0); - } - usb_hid_present = true; - usb_cdc_present = true; -#else - if (PIOS_USB_DESC_HID_ONLY_Init()) { - PIOS_Assert(0); - } - usb_hid_present = true; -#endif - - uint32_t pios_usb_id; - - switch (bdinfo->board_rev) { - case BOARD_REVISION_CC: - PIOS_USB_Init(&pios_usb_id, &pios_usb_main_cfg_cc); - break; - case BOARD_REVISION_CC3D: - PIOS_USB_Init(&pios_usb_id, &pios_usb_main_cfg_cc3d); - break; - default: - PIOS_Assert(0); - } - -#if defined(PIOS_INCLUDE_USB_CDC) - - uint8_t hwsettings_usb_vcpport; - /* Configure the USB VCP port */ - HwSettingsUSB_VCPPortGet(&hwsettings_usb_vcpport); - - if (!usb_cdc_present) { - /* Force VCP port function to disabled if we haven't advertised VCP in our USB descriptor */ - hwsettings_usb_vcpport = HWSETTINGS_USB_VCPPORT_DISABLED; - } - - switch (hwsettings_usb_vcpport) { - case HWSETTINGS_USB_VCPPORT_DISABLED: - break; - case HWSETTINGS_USB_VCPPORT_USBTELEMETRY: -#if defined(PIOS_INCLUDE_COM) - { - uint32_t pios_usb_cdc_id; - if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) { - PIOS_Assert(0); - } - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN); - PIOS_Assert(rx_buffer); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id, - rx_buffer, PIOS_COM_TELEM_USB_RX_BUF_LEN, - tx_buffer, PIOS_COM_TELEM_USB_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_COM */ - break; - case HWSETTINGS_USB_VCPPORT_COMBRIDGE: -#if defined(PIOS_INCLUDE_COM) - { - uint32_t pios_usb_cdc_id; - if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) { - PIOS_Assert(0); - } - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN); - PIOS_Assert(rx_buffer); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id, - rx_buffer, PIOS_COM_BRIDGE_RX_BUF_LEN, - tx_buffer, PIOS_COM_BRIDGE_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_COM */ - break; - case HWSETTINGS_USB_VCPPORT_DEBUGCONSOLE: -#if defined(PIOS_INCLUDE_COM) -#if defined(PIOS_INCLUDE_DEBUG_CONSOLE) - { - uint32_t pios_usb_cdc_id; - if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) { - PIOS_Assert(0); - } - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id, - NULL, 0, - tx_buffer, PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */ -#endif /* PIOS_INCLUDE_COM */ - break; - } -#endif /* PIOS_INCLUDE_USB_CDC */ - -#if defined(PIOS_INCLUDE_USB_HID) - /* Configure the usb HID port */ - uint8_t hwsettings_usb_hidport; - HwSettingsUSB_HIDPortGet(&hwsettings_usb_hidport); - - if (!usb_hid_present) { - /* Force HID port function to disabled if we haven't advertised HID in our USB descriptor */ - hwsettings_usb_hidport = HWSETTINGS_USB_HIDPORT_DISABLED; - } - - switch (hwsettings_usb_hidport) { - case HWSETTINGS_USB_HIDPORT_DISABLED: - break; - case HWSETTINGS_USB_HIDPORT_USBTELEMETRY: -#if defined(PIOS_INCLUDE_COM) - { - uint32_t pios_usb_hid_id; - if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) { - PIOS_Assert(0); - } - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN); - PIOS_Assert(rx_buffer); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id, - rx_buffer, PIOS_COM_TELEM_USB_RX_BUF_LEN, - tx_buffer, PIOS_COM_TELEM_USB_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_COM */ - break; - case HWSETTINGS_USB_HIDPORT_RCTRANSMITTER: -#if defined(PIOS_INCLUDE_USB_RCTX) - { - if (PIOS_USB_RCTX_Init(&pios_usb_rctx_id, &pios_usb_rctx_cfg, pios_usb_id)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_USB_RCTX */ - break; - } - -#endif /* PIOS_INCLUDE_USB_HID */ - -#endif /* PIOS_INCLUDE_USB */ - - /* Configure the main IO port */ - uint8_t hwsettings_DSMxBind; - HwSettingsDSMxBindGet(&hwsettings_DSMxBind); - uint8_t hwsettings_cc_mainport; - HwSettingsCC_MainPortGet(&hwsettings_cc_mainport); - - switch (hwsettings_cc_mainport) { - case HWSETTINGS_CC_MAINPORT_DISABLED: - break; - case HWSETTINGS_CC_MAINPORT_TELEMETRY: -#if defined(PIOS_INCLUDE_TELEMETRY_RF) - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_main_cfg)) { - PIOS_Assert(0); - } - - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN); - PIOS_Assert(rx_buffer); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_generic_id, - rx_buffer, PIOS_COM_TELEM_RF_RX_BUF_LEN, - tx_buffer, PIOS_COM_TELEM_RF_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_TELEMETRY_RF */ - break; - case HWSETTINGS_CC_MAINPORT_SBUS: -#if defined(PIOS_INCLUDE_SBUS) - { - uint32_t pios_usart_sbus_id; - if (PIOS_USART_Init(&pios_usart_sbus_id, &pios_usart_sbus_main_cfg)) { - PIOS_Assert(0); - } - - uint32_t pios_sbus_id; - if (PIOS_SBus_Init(&pios_sbus_id, &pios_sbus_cfg, &pios_usart_com_driver, pios_usart_sbus_id)) { - PIOS_Assert(0); - } - - uint32_t pios_sbus_rcvr_id; - if (PIOS_RCVR_Init(&pios_sbus_rcvr_id, &pios_sbus_rcvr_driver, pios_sbus_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_SBUS] = pios_sbus_rcvr_id; - } -#endif /* PIOS_INCLUDE_SBUS */ - break; - case HWSETTINGS_CC_MAINPORT_GPS: -#if defined(PIOS_INCLUDE_GPS) - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_main_cfg)) { - PIOS_Assert(0); - } - - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN); - PIOS_Assert(rx_buffer); - if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_generic_id, - rx_buffer, PIOS_COM_GPS_RX_BUF_LEN, - NULL, 0)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_GPS */ - break; - case HWSETTINGS_CC_MAINPORT_DSM: -#if defined(PIOS_INCLUDE_DSM) - { - uint32_t pios_usart_dsm_id; - if (PIOS_USART_Init(&pios_usart_dsm_id, &pios_usart_dsm_main_cfg)) { - PIOS_Assert(0); - } - - uint32_t pios_dsm_id; - if (PIOS_DSM_Init(&pios_dsm_id, - &pios_dsm_main_cfg, - &pios_usart_com_driver, - pios_usart_dsm_id, - 0)) { - PIOS_Assert(0); - } - - uint32_t pios_dsm_rcvr_id; - if (PIOS_RCVR_Init(&pios_dsm_rcvr_id, &pios_dsm_rcvr_driver, pios_dsm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_DSMMAINPORT] = pios_dsm_rcvr_id; - } -#endif /* PIOS_INCLUDE_DSM */ - break; - case HWSETTINGS_CC_MAINPORT_DEBUGCONSOLE: -#if defined(PIOS_INCLUDE_COM) -#if defined(PIOS_INCLUDE_DEBUG_CONSOLE) - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_main_cfg)) { - PIOS_Assert(0); - } - - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_debug_id, &pios_usart_com_driver, pios_usart_generic_id, - NULL, 0, - tx_buffer, PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */ -#endif /* PIOS_INCLUDE_COM */ - break; - case HWSETTINGS_CC_MAINPORT_COMBRIDGE: - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_main_cfg)) { - PIOS_Assert(0); - } - - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN); - PIOS_Assert(rx_buffer); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_bridge_id, &pios_usart_com_driver, pios_usart_generic_id, - rx_buffer, PIOS_COM_BRIDGE_RX_BUF_LEN, - tx_buffer, PIOS_COM_BRIDGE_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } - break; - case HWSETTINGS_CC_MAINPORT_OSDHK: - { - uint32_t pios_usart_hkosd_id; - if (PIOS_USART_Init(&pios_usart_hkosd_id, &pios_usart_hkosd_main_cfg)) { - PIOS_Assert(0); - } - - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_HKOSD_TX_BUF_LEN); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_hkosd_id, &pios_usart_com_driver, pios_usart_hkosd_id, - NULL, 0, - tx_buffer, PIOS_COM_HKOSD_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } - break; - } - - /* Configure the flexi port */ - uint8_t hwsettings_cc_flexiport; - HwSettingsCC_FlexiPortGet(&hwsettings_cc_flexiport); - - switch (hwsettings_cc_flexiport) { - case HWSETTINGS_CC_FLEXIPORT_DISABLED: - break; - case HWSETTINGS_CC_FLEXIPORT_TELEMETRY: -#if defined(PIOS_INCLUDE_TELEMETRY_RF) - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) { - PIOS_Assert(0); - } - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN); - PIOS_Assert(rx_buffer); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_generic_id, - rx_buffer, PIOS_COM_TELEM_RF_RX_BUF_LEN, - tx_buffer, PIOS_COM_TELEM_RF_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_TELEMETRY_RF */ - break; - case HWSETTINGS_CC_FLEXIPORT_COMBRIDGE: - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) { - PIOS_Assert(0); - } - - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN); - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN); - PIOS_Assert(rx_buffer); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_bridge_id, &pios_usart_com_driver, pios_usart_generic_id, - rx_buffer, PIOS_COM_BRIDGE_RX_BUF_LEN, - tx_buffer, PIOS_COM_BRIDGE_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } - break; - case HWSETTINGS_CC_FLEXIPORT_GPS: -#if defined(PIOS_INCLUDE_GPS) - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) { - PIOS_Assert(0); - } - uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN); - PIOS_Assert(rx_buffer); - if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_generic_id, - rx_buffer, PIOS_COM_GPS_RX_BUF_LEN, - NULL, 0)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_GPS */ - break; - case HWSETTINGS_CC_FLEXIPORT_PPM: -#if defined(PIOS_INCLUDE_PPM_FLEXI) - { - uint32_t pios_ppm_id; - PIOS_PPM_Init(&pios_ppm_id, &pios_ppm_flexi_cfg); - - uint32_t pios_ppm_rcvr_id; - if (PIOS_RCVR_Init(&pios_ppm_rcvr_id, &pios_ppm_rcvr_driver, pios_ppm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_PPM] = pios_ppm_rcvr_id; - } -#endif /* PIOS_INCLUDE_PPM_FLEXI */ - break; - case HWSETTINGS_CC_FLEXIPORT_DSM: -#if defined(PIOS_INCLUDE_DSM) - { - uint32_t pios_usart_dsm_id; - if (PIOS_USART_Init(&pios_usart_dsm_id, &pios_usart_dsm_flexi_cfg)) { - PIOS_Assert(0); - } - - uint32_t pios_dsm_id; - if (PIOS_DSM_Init(&pios_dsm_id, - &pios_dsm_flexi_cfg, - &pios_usart_com_driver, - pios_usart_dsm_id, - hwsettings_DSMxBind)) { - PIOS_Assert(0); - } - - uint32_t pios_dsm_rcvr_id; - if (PIOS_RCVR_Init(&pios_dsm_rcvr_id, &pios_dsm_rcvr_driver, pios_dsm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_DSMFLEXIPORT] = pios_dsm_rcvr_id; - } -#endif /* PIOS_INCLUDE_DSM */ - break; - case HWSETTINGS_CC_FLEXIPORT_DEBUGCONSOLE: -#if defined(PIOS_INCLUDE_COM) -#if defined(PIOS_INCLUDE_DEBUG_CONSOLE) - { - uint32_t pios_usart_generic_id; - if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) { - PIOS_Assert(0); - } - - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_debug_id, &pios_usart_com_driver, pios_usart_generic_id, - NULL, 0, - tx_buffer, PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */ -#endif /* PIOS_INCLUDE_COM */ - break; - case HWSETTINGS_CC_FLEXIPORT_I2C: -#if defined(PIOS_INCLUDE_I2C) - { - if (PIOS_I2C_Init(&pios_i2c_flexi_adapter_id, &pios_i2c_flexi_adapter_cfg)) { - PIOS_Assert(0); - } - } -#endif /* PIOS_INCLUDE_I2C */ - break; - case HWSETTINGS_CC_FLEXIPORT_OSDHK: - { - uint32_t pios_usart_hkosd_id; - if (PIOS_USART_Init(&pios_usart_hkosd_id, &pios_usart_hkosd_flexi_cfg)) { - PIOS_Assert(0); - } - - uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_HKOSD_TX_BUF_LEN); - PIOS_Assert(tx_buffer); - if (PIOS_COM_Init(&pios_com_hkosd_id, &pios_usart_com_driver, pios_usart_hkosd_id, - NULL, 0, - tx_buffer, PIOS_COM_HKOSD_TX_BUF_LEN)) { - PIOS_Assert(0); - } - } - break; - } - - /* Configure the rcvr port */ - uint8_t hwsettings_rcvrport; - HwSettingsCC_RcvrPortGet(&hwsettings_rcvrport); - - switch ((HwSettingsCC_RcvrPortOptions)hwsettings_rcvrport) { - case HWSETTINGS_CC_RCVRPORT_DISABLEDONESHOT: -#if defined(PIOS_INCLUDE_HCSR04) - { - uint32_t pios_hcsr04_id; - PIOS_HCSR04_Init(&pios_hcsr04_id, &pios_hcsr04_cfg); - } -#endif - break; - case HWSETTINGS_CC_RCVRPORT_PWMNOONESHOT: -#if defined(PIOS_INCLUDE_PWM) - { - uint32_t pios_pwm_id; - PIOS_PWM_Init(&pios_pwm_id, &pios_pwm_cfg); - - uint32_t pios_pwm_rcvr_id; - if (PIOS_RCVR_Init(&pios_pwm_rcvr_id, &pios_pwm_rcvr_driver, pios_pwm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_PWM] = pios_pwm_rcvr_id; - } -#endif /* PIOS_INCLUDE_PWM */ - break; - case HWSETTINGS_CC_RCVRPORT_PPMNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPMOUTPUTSNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPM_PIN8ONESHOT: -#if defined(PIOS_INCLUDE_PPM) - { - uint32_t pios_ppm_id; - if (hwsettings_rcvrport == HWSETTINGS_CC_RCVRPORT_PPM_PIN8ONESHOT) { - PIOS_PPM_Init(&pios_ppm_id, &pios_ppm_pin8_cfg); - } else { - PIOS_PPM_Init(&pios_ppm_id, &pios_ppm_cfg); - } - - uint32_t pios_ppm_rcvr_id; - if (PIOS_RCVR_Init(&pios_ppm_rcvr_id, &pios_ppm_rcvr_driver, pios_ppm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_PPM] = pios_ppm_rcvr_id; - } -#endif /* PIOS_INCLUDE_PPM */ - break; - case HWSETTINGS_CC_RCVRPORT_PPMPWMNOONESHOT: - /* This is a combination of PPM and PWM inputs */ -#if defined(PIOS_INCLUDE_PPM) - { - uint32_t pios_ppm_id; - PIOS_PPM_Init(&pios_ppm_id, &pios_ppm_cfg); - - uint32_t pios_ppm_rcvr_id; - if (PIOS_RCVR_Init(&pios_ppm_rcvr_id, &pios_ppm_rcvr_driver, pios_ppm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_PPM] = pios_ppm_rcvr_id; - } -#endif /* PIOS_INCLUDE_PPM */ -#if defined(PIOS_INCLUDE_PWM) - { - uint32_t pios_pwm_id; - PIOS_PWM_Init(&pios_pwm_id, &pios_pwm_with_ppm_cfg); - - uint32_t pios_pwm_rcvr_id; - if (PIOS_RCVR_Init(&pios_pwm_rcvr_id, &pios_pwm_rcvr_driver, pios_pwm_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_PWM] = pios_pwm_rcvr_id; - } -#endif /* PIOS_INCLUDE_PWM */ - break; - case HWSETTINGS_CC_RCVRPORT_OUTPUTSONESHOT: - break; - } - -#if defined(PIOS_INCLUDE_GCSRCVR) - GCSReceiverInitialize(); - uint32_t pios_gcsrcvr_id; - PIOS_GCSRCVR_Init(&pios_gcsrcvr_id); - uint32_t pios_gcsrcvr_rcvr_id; - if (PIOS_RCVR_Init(&pios_gcsrcvr_rcvr_id, &pios_gcsrcvr_rcvr_driver, pios_gcsrcvr_id)) { - PIOS_Assert(0); - } - pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_GCS] = pios_gcsrcvr_rcvr_id; -#endif /* PIOS_INCLUDE_GCSRCVR */ - - /* Remap AFIO pin for PB4 (Servo 5 Out)*/ - GPIO_PinRemapConfig(GPIO_Remap_SWJ_NoJTRST, ENABLE); - -#ifndef PIOS_ENABLE_DEBUG_PINS - switch ((HwSettingsCC_RcvrPortOptions)hwsettings_rcvrport) { - case HWSETTINGS_CC_RCVRPORT_DISABLEDONESHOT: - case HWSETTINGS_CC_RCVRPORT_PWMNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPMNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPMPWMNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPM_PIN8ONESHOT: - PIOS_Servo_Init(&pios_servo_cfg); - break; - case HWSETTINGS_CC_RCVRPORT_PPMOUTPUTSNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_OUTPUTSONESHOT: - PIOS_Servo_Init(&pios_servo_rcvr_cfg); - break; - } -#else - PIOS_DEBUG_Init(pios_tim_servoport_all_pins, NELEMENTS(pios_tim_servoport_all_pins)); -#endif /* PIOS_ENABLE_DEBUG_PINS */ - - switch (bdinfo->board_rev) { - case BOARD_REVISION_CC: - // Revision 1 with invensense gyros, start the ADC -#if defined(PIOS_INCLUDE_ADC) - PIOS_ADC_Init(&pios_adc_cfg); -#endif -#if defined(PIOS_INCLUDE_ADXL345) - PIOS_ADXL345_Init(pios_spi_flash_accel_id, 0); -#endif - break; - case BOARD_REVISION_CC3D: - // Revision 2 with MPU6000 gyros, start a SPI interface and connect to it - GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); - -#if defined(PIOS_INCLUDE_MPU6000) - // Set up the SPI interface to the serial flash - if (PIOS_SPI_Init(&pios_spi_gyro_id, &pios_spi_gyro_cfg)) { - PIOS_Assert(0); - } - PIOS_MPU6000_Init(pios_spi_gyro_id, 0, &pios_mpu6000_cfg); - PIOS_MPU6000_CONFIG_Configure(); - init_test = !PIOS_MPU6000_Driver.test(0); -#endif /* PIOS_INCLUDE_MPU6000 */ - - break; - default: - PIOS_Assert(0); - } - - /* Make sure we have at least one telemetry link configured or else fail initialization */ - PIOS_Assert(pios_com_telem_rf_id || pios_com_telem_usb_id); - - // Attach the board config check hook - SANITYCHECK_AttachHook(&CopterControlConfigHook); - // trigger a config check if actuatorsettings are updated - ActuatorSettingsInitialize(); - ActuatorSettingsConnectCallback(ActuatorSettingsUpdatedCb); -} - -SystemAlarmsExtendedAlarmStatusOptions CopterControlConfigHook() -{ - // inhibit usage of oneshot for non supported RECEIVER port modes - uint8_t recmode; - - HwSettingsCC_RcvrPortGet(&recmode); - uint8_t flexiMode; - uint8_t modes[ACTUATORSETTINGS_BANKMODE_NUMELEM]; - ActuatorSettingsBankModeGet(modes); - HwSettingsCC_FlexiPortGet(&flexiMode); - - switch ((HwSettingsCC_RcvrPortOptions)recmode) { - // Those modes allows oneshot usage - case HWSETTINGS_CC_RCVRPORT_DISABLEDONESHOT: - case HWSETTINGS_CC_RCVRPORT_OUTPUTSONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPM_PIN8ONESHOT: - if ((recmode == HWSETTINGS_CC_RCVRPORT_PPM_PIN8ONESHOT || - flexiMode == HWSETTINGS_CC_FLEXIPORT_PPM) && - (modes[3] == ACTUATORSETTINGS_BANKMODE_PWMSYNC || - modes[3] == ACTUATORSETTINGS_BANKMODE_ONESHOT125)) { - return SYSTEMALARMS_EXTENDEDALARMSTATUS_UNSUPPORTEDCONFIG_ONESHOT; - } else { - return SYSTEMALARMS_EXTENDEDALARMSTATUS_NONE; - } - - // inhibit oneshot for the following modes - case HWSETTINGS_CC_RCVRPORT_PPMNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPMOUTPUTSNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PPMPWMNOONESHOT: - case HWSETTINGS_CC_RCVRPORT_PWMNOONESHOT: - for (uint8_t i = 0; i < ACTUATORSETTINGS_BANKMODE_NUMELEM; i++) { - if (modes[i] == ACTUATORSETTINGS_BANKMODE_PWMSYNC || - modes[i] == ACTUATORSETTINGS_BANKMODE_ONESHOT125) { - return SYSTEMALARMS_EXTENDEDALARMSTATUS_UNSUPPORTEDCONFIG_ONESHOT;; - } - - return SYSTEMALARMS_EXTENDEDALARMSTATUS_NONE; - } - } - return SYSTEMALARMS_EXTENDEDALARMSTATUS_UNSUPPORTEDCONFIG_ONESHOT;; -} -// trigger a configuration check if ActuatorSettings are changed. -void ActuatorSettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) -{ - configuration_check(); -} - -/** - * @} - */ diff --git a/flight/targets/boards/coptercontrol/firmware/pios_board_posix.c b/flight/targets/boards/coptercontrol/firmware/pios_board_posix.c deleted file mode 100644 index 7fa958a38..000000000 --- a/flight/targets/boards/coptercontrol/firmware/pios_board_posix.c +++ /dev/null @@ -1,145 +0,0 @@ -/** - ****************************************************************************** - * - * @file pios_board.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Defines board specific static initializers for hardware for the OpenPilot board. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include "inc/openpilot.h" -#include -#include -#include - -/** - * PIOS_Board_Init() - * initializes all the core systems on this specific hardware - * called from System/openpilot.c - */ -void PIOS_Board_Init(void) -{ - /* Delay system */ - PIOS_DELAY_Init(); - - /* Initialize the delayed callback library */ - PIOS_CALLBACKSCHEDULER_Initialize(); - - /* Initialize UAVObject libraries */ - EventDispatcherInitialize(); - UAVObjInitialize(); - - /* Initialize the alarms library */ - AlarmsInitialize(); - - /* Initialize the task monitor */ - if (PIOS_TASK_MONITOR_Initialize(TASKINFO_RUNNING_NUMELEM)) { - PIOS_Assert(0); - } - - /* Initialize the PiOS library */ - PIOS_COM_Init(); -} - - -const struct pios_udp_cfg pios_udp0_cfg = { - .ip = "0.0.0.0", - .port = 9000, -}; -const struct pios_udp_cfg pios_udp1_cfg = { - .ip = "0.0.0.0", - .port = 9001, -}; -const struct pios_udp_cfg pios_udp2_cfg = { - .ip = "0.0.0.0", - .port = 9002, -}; - -#ifdef PIOS_COM_AUX -/* - * AUX USART - */ -const struct pios_udp_cfg pios_udp3_cfg = { - .ip = "0.0.0.0", - .port = 9003, -}; -#endif - -/* - * Board specific number of devices. - */ -struct pios_udp_dev pios_udp_devs[] = { -#define PIOS_UDP_TELEM 0 - { - .cfg = &pios_udp0_cfg, - }, -#define PIOS_UDP_GPS 1 - { - .cfg = &pios_udp1_cfg, - }, -#define PIOS_UDP_LOCAL 2 - { - .cfg = &pios_udp2_cfg, - }, -#ifdef PIOS_COM_AUX -#define PIOS_UDP_AUX 3 - { - .cfg = &pios_udp3_cfg, - }, -#endif -}; - -uint8_t pios_udp_num_devices = NELEMENTS(pios_udp_devs); - -/* - * COM devices - */ - -/* - * Board specific number of devices. - */ -extern const struct pios_com_driver pios_serial_com_driver; -extern const struct pios_com_driver pios_udp_com_driver; - -struct pios_com_dev pios_com_devs[] = { - { - .id = PIOS_UDP_TELEM, - .driver = &pios_udp_com_driver, - }, - { - .id = PIOS_UDP_GPS, - .driver = &pios_udp_com_driver, - }, - { - .id = PIOS_UDP_LOCAL, - .driver = &pios_udp_com_driver, - }, -#ifdef PIOS_COM_AUX - { - .id = PIOS_UDP_AUX, - .driver = &pios_udp_com_driver, - }, -#endif -}; - -const uint8_t pios_com_num_devices = NELEMENTS(pios_com_devs); - -/** - * @} - */ diff --git a/flight/targets/boards/coptercontrol/pios_board.h b/flight/targets/boards/coptercontrol/pios_board.h deleted file mode 100644 index f3c3e34d3..000000000 --- a/flight/targets/boards/coptercontrol/pios_board.h +++ /dev/null @@ -1,279 +0,0 @@ -/** - ****************************************************************************** - * - * @file pios_board.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Defines board hardware for the OpenPilot Version 1.1 hardware. - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef PIOS_BOARD_H -#define PIOS_BOARD_H -// ------------------------ -// Timers and Channels Used -// ------------------------ -/* - Timer | Channel 1 | Channel 2 | Channel 3 | Channel 4 - ------+-----------+-----------+-----------+---------- - TIM1 | Servo 4 | | | - TIM2 | RC In 5 | RC In 6 | Servo 6 | - TIM3 | Servo 5 | RC In 2 | RC In 3 | RC In 4 - TIM4 | RC In 1 | Servo 3 | Servo 2 | Servo 1 - ------+-----------+-----------+-----------+---------- - */ - -// ------------------------ -// DMA Channels Used -// ------------------------ -/* Channel 1 - */ -/* Channel 2 - */ -/* Channel 3 - */ -/* Channel 4 - */ -/* Channel 5 - */ -/* Channel 6 - */ -/* Channel 7 - */ -/* Channel 8 - */ -/* Channel 9 - */ -/* Channel 10 - */ -/* Channel 11 - */ -/* Channel 12 - */ - -// ------------------------ -// BOOTLOADER_SETTINGS -// ------------------------ -#define BOARD_READABLE TRUE -#define BOARD_WRITABLE TRUE -#define MAX_DEL_RETRYS 3 - -// ------------------------ -// WATCHDOG_SETTINGS -// ------------------------ -#define PIOS_WATCHDOG_TIMEOUT 250 -#define PIOS_WDG_REGISTER BKP_DR4 -#define PIOS_WDG_ACTUATOR 0x0001 -#define PIOS_WDG_STABILIZATION 0x0002 -#define PIOS_WDG_ATTITUDE 0x0004 -#define PIOS_WDG_MANUAL 0x0008 -#define PIOS_WDG_AUTOTUNE 0x0010 - -// ------------------------ -// TELEMETRY -// ------------------------ -#define TELEM_QUEUE_SIZE 10 - -// ------------------------ -// PIOS_LED -// ------------------------ -#define PIOS_LED_HEARTBEAT 0 - -// ------------------------- -// System Settings -// ------------------------- -#define PIOS_MASTER_CLOCK 72000000 -#define PIOS_PERIPHERAL_CLOCK (PIOS_MASTER_CLOCK / 2) - -// ------------------------- -// Interrupt Priorities -// ------------------------- -#define PIOS_IRQ_PRIO_LOW 12 // lower than RTOS -#define PIOS_IRQ_PRIO_MID 8 // higher than RTOS -#define PIOS_IRQ_PRIO_HIGH 5 // for SPI, ADC, I2C etc... -#define PIOS_IRQ_PRIO_HIGHEST 4 // for USART etc... -// ------------------------ -// PIOS_I2C -// See also pios_board.c -// ------------------------ -#define PIOS_I2C_MAX_DEVS 1 -extern uint32_t pios_i2c_flexi_adapter_id; -#define PIOS_I2C_MAIN_ADAPTER (pios_i2c_flexi_adapter_id) -#define PIOS_I2C_ESC_ADAPTER (pios_i2c_flexi_adapter_id) -#define PIOS_I2C_BMP085_ADAPTER (pios_i2c_flexi_adapter_id) - -// ------------------------ -// PIOS_BMP085 -// ------------------------ -#define PIOS_BMP085_OVERSAMPLING 3 - -// ------------------------- -// SPI -// -// See also pios_board.c -// ------------------------- -#define PIOS_SPI_MAX_DEVS 2 - -// ------------------------- -// PIOS_USART -// ------------------------- -#define PIOS_USART_MAX_DEVS 2 - -// ------------------------- -// PIOS_COM -// -// See also pios_board.c -// ------------------------- -#define PIOS_COM_MAX_DEVS 3 - -extern uint32_t pios_com_telem_rf_id; -#define PIOS_COM_TELEM_RF (pios_com_telem_rf_id) - -#if defined(PIOS_INCLUDE_GPS) -extern uint32_t pios_com_gps_id; -#define PIOS_COM_GPS (pios_com_gps_id) -#endif /* PIOS_INCLUDE_GPS */ - -extern uint32_t pios_com_bridge_id; -#define PIOS_COM_BRIDGE (pios_com_bridge_id) - -extern uint32_t pios_com_vcp_id; -#define PIOS_COM_VCP (pios_com_vcp_id) - -extern uint32_t pios_com_telem_usb_id; -#define PIOS_COM_TELEM_USB (pios_com_telem_usb_id) - -#if defined(PIOS_INCLUDE_DEBUG_CONSOLE) -extern uint32_t pios_com_debug_id; -#define PIOS_COM_DEBUG (pios_com_debug_id) -#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */ - -extern uint32_t pios_com_hkosd_id; -#define PIOS_COM_OSDHK (pios_com_hkosd_id) - -// ------------------------- -// ADC -// PIOS_ADC_PinGet(0) = Gyro Z -// PIOS_ADC_PinGet(1) = Gyro Y -// PIOS_ADC_PinGet(2) = Gyro X -// ------------------------- -// #define PIOS_ADC_OVERSAMPLING_RATE 1 -#define PIOS_ADC_USE_TEMP_SENSOR 1 -#define PIOS_ADC_TEMP_SENSOR_ADC ADC1 -#define PIOS_ADC_TEMP_SENSOR_ADC_CHANNEL 1 - -#define PIOS_ADC_PIN1_GPIO_PORT GPIOA // PA4 (Gyro X) -#define PIOS_ADC_PIN1_GPIO_PIN GPIO_Pin_4 // ADC12_IN4 -#define PIOS_ADC_PIN1_GPIO_CHANNEL ADC_Channel_4 -#define PIOS_ADC_PIN1_ADC ADC2 -#define PIOS_ADC_PIN1_ADC_NUMBER 1 - -#define PIOS_ADC_PIN2_GPIO_PORT GPIOA // PA5 (Gyro Y) -#define PIOS_ADC_PIN2_GPIO_PIN GPIO_Pin_5 // ADC123_IN5 -#define PIOS_ADC_PIN2_GPIO_CHANNEL ADC_Channel_5 -#define PIOS_ADC_PIN2_ADC ADC1 -#define PIOS_ADC_PIN2_ADC_NUMBER 2 - -#define PIOS_ADC_PIN3_GPIO_PORT GPIOA // PA3 (Gyro Z) -#define PIOS_ADC_PIN3_GPIO_PIN GPIO_Pin_3 // ADC12_IN3 -#define PIOS_ADC_PIN3_GPIO_CHANNEL ADC_Channel_3 -#define PIOS_ADC_PIN3_ADC ADC2 -#define PIOS_ADC_PIN3_ADC_NUMBER 2 - -#define PIOS_ADC_NUM_PINS 3 - -#define PIOS_ADC_PORTS { PIOS_ADC_PIN1_GPIO_PORT, PIOS_ADC_PIN2_GPIO_PORT, PIOS_ADC_PIN3_GPIO_PORT } -#define PIOS_ADC_PINS { PIOS_ADC_PIN1_GPIO_PIN, PIOS_ADC_PIN2_GPIO_PIN, PIOS_ADC_PIN3_GPIO_PIN } -#define PIOS_ADC_CHANNELS { PIOS_ADC_PIN1_GPIO_CHANNEL, PIOS_ADC_PIN2_GPIO_CHANNEL, PIOS_ADC_PIN3_GPIO_CHANNEL } -#define PIOS_ADC_MAPPING { PIOS_ADC_PIN1_ADC, PIOS_ADC_PIN2_ADC, PIOS_ADC_PIN3_ADC } -#define PIOS_ADC_CHANNEL_MAPPING { PIOS_ADC_PIN1_ADC_NUMBER, PIOS_ADC_PIN2_ADC_NUMBER, PIOS_ADC_PIN3_ADC_NUMBER } -#define PIOS_ADC_NUM_CHANNELS (PIOS_ADC_NUM_PINS + PIOS_ADC_USE_TEMP_SENSOR) -#define PIOS_ADC_NUM_ADC_CHANNELS 2 -#define PIOS_ADC_USE_ADC2 1 -#define PIOS_ADC_CLOCK_FUNCTION RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2, ENABLE) -#define PIOS_ADC_ADCCLK RCC_PCLK2_Div8 -/* RCC_PCLK2_Div2: ADC clock = PCLK2/2 */ -/* RCC_PCLK2_Div4: ADC clock = PCLK2/4 */ -/* RCC_PCLK2_Div6: ADC clock = PCLK2/6 */ -/* RCC_PCLK2_Div8: ADC clock = PCLK2/8 */ -#define PIOS_ADC_SAMPLE_TIME ADC_SampleTime_239Cycles5 -/* Sample time: */ -/* With an ADCCLK = 14 MHz and a sampling time of 239.5 cycles: */ -/* Tconv = 239.5 + 12.5 = 252 cycles = 18�s */ -/* (1 / (ADCCLK / CYCLES)) = Sample Time (�S) */ -#define PIOS_ADC_IRQ_PRIO PIOS_IRQ_PRIO_LOW - -// Currently analog acquistion hard coded at 480 Hz -// PCKL2 = HCLK / 16 -// ADCCLK = PCLK2 / 2 -#define PIOS_ADC_RATE (72.0e6f / 1.0f / 8.0f / 252.0f / (PIOS_ADC_NUM_CHANNELS >> PIOS_ADC_USE_ADC2)) -#define PIOS_ADC_MAX_OVERSAMPLING 48 - -#define PIOS_ADC_TEMPERATURE_PIN 0 - -// ------------------------ -// PIOS_RCVR -// See also pios_board.c -// ------------------------ -#define PIOS_RCVR_MAX_DEVS 3 -#define PIOS_RCVR_MAX_CHANNELS 12 -#define PIOS_GCSRCVR_TIMEOUT_MS 100 - -// ------------------------- -// Receiver PPM input -// ------------------------- -#define PIOS_PPM_MAX_DEVS 1 -#define PIOS_PPM_NUM_INPUTS 12 - -// ------------------------- -// Receiver PWM input -// ------------------------- -#define PIOS_PWM_MAX_DEVS 1 -#define PIOS_PWM_NUM_INPUTS 6 - -// ------------------------- -// Receiver DSM input -// ------------------------- -#define PIOS_DSM_MAX_DEVS 2 -#define PIOS_DSM_NUM_INPUTS 12 - -// ------------------------- -// Receiver S.Bus input -// ------------------------- -#define PIOS_SBUS_MAX_DEVS 1 -#define PIOS_SBUS_NUM_INPUTS (16 + 2) - -// ------------------------- -// Servo outputs -// ------------------------- -#define PIOS_SERVO_UPDATE_HZ 50 -#define PIOS_SERVOS_INITIAL_POSITION 0 /* dont want to start motors, have no pulse till settings loaded */ -#define PIOS_SERVO_BANKS 6 - -// -------------------------- -// Timer controller settings -// -------------------------- -#define PIOS_TIM_MAX_DEVS 3 - -// ------------------------- -// GPIO -// ------------------------- -#define PIOS_GPIO_PORTS {} -#define PIOS_GPIO_PINS {} -#define PIOS_GPIO_CLKS {} -#define PIOS_GPIO_NUM 0 - -// ------------------------- -// USB -// ------------------------- -#define PIOS_USB_HID_MAX_DEVS 1 - -#define PIOS_USB_ENABLED 1 -#define PIOS_USB_DETECT_GPIO_PORT GPIOC -#define PIOS_USB_MAX_DEVS 1 -#define PIOS_USB_DETECT_GPIO_PIN GPIO_Pin_15 - -#endif /* PIOS_BOARD_H */ diff --git a/flight/targets/boards/coptercontrol/pios_usb_board_data.c b/flight/targets/boards/coptercontrol/pios_usb_board_data.c deleted file mode 100644 index 20c49fdcf..000000000 --- a/flight/targets/boards/coptercontrol/pios_usb_board_data.c +++ /dev/null @@ -1,102 +0,0 @@ -/** - ****************************************************************************** - * @addtogroup PIOS PIOS Core hardware abstraction layer - * @{ - * @addtogroup PIOS_USB_BOARD Board specific USB definitions - * @brief Board specific USB definitions - * @{ - * - * @file pios_usb_board_data.c - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @brief Board specific USB definitions - * @see The GNU Public License (GPL) Version 3 - * - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include "inc/pios_usb_board_data.h" /* struct usb_*, USB_* */ -#include /* PIOS_SYS_SerialNumberGet */ -#include /* PIOS_USBHOOK_* */ -#include /* PIOS_USB_UTIL_AsciiToUtf8 */ - -static const uint8_t usb_product_id[28] = { - sizeof(usb_product_id), - USB_DESC_TYPE_STRING, - 'C', 0, - 'o', 0, - 'p', 0, - 't', 0, - 'e', 0, - 'r', 0, - 'C', 0, - 'o', 0, - 'n', 0, - 't', 0, - 'r', 0, - 'o', 0, - 'l', 0, -}; - -static uint8_t usb_serial_number[2 + PIOS_SYS_SERIAL_NUM_ASCII_LEN * 2 + (sizeof(PIOS_USB_BOARD_SN_SUFFIX) - 1) * 2] = { - sizeof(usb_serial_number), - USB_DESC_TYPE_STRING, -}; - -static const struct usb_string_langid usb_lang_id = { - .bLength = sizeof(usb_lang_id), - .bDescriptorType = USB_DESC_TYPE_STRING, - .bLangID = htousbs(USB_LANGID_ENGLISH_US), -}; - -static const uint8_t usb_vendor_id[28] = { - sizeof(usb_vendor_id), - USB_DESC_TYPE_STRING, - 'o', 0, - 'p', 0, - 'e', 0, - 'n', 0, - 'p', 0, - 'i', 0, - 'l', 0, - 'o', 0, - 't', 0, - '.', 0, - 'o', 0, - 'r', 0, - 'g', 0 -}; - -int32_t PIOS_USB_BOARD_DATA_Init(void) -{ - /* Load device serial number into serial number string */ - uint8_t sn[PIOS_SYS_SERIAL_NUM_ASCII_LEN + 1]; - - PIOS_SYS_SerialNumberGet((char *)sn); - - /* Concatenate the device serial number and the appropriate suffix ("+BL" or "+FW") into the USB serial number */ - uint8_t *utf8 = &(usb_serial_number[2]); - utf8 = PIOS_USB_UTIL_AsciiToUtf8(utf8, sn, PIOS_SYS_SERIAL_NUM_ASCII_LEN); - utf8 = PIOS_USB_UTIL_AsciiToUtf8(utf8, (uint8_t *)PIOS_USB_BOARD_SN_SUFFIX, sizeof(PIOS_USB_BOARD_SN_SUFFIX) - 1); - - PIOS_USBHOOK_RegisterString(USB_STRING_DESC_PRODUCT, (uint8_t *)&usb_product_id, sizeof(usb_product_id)); - PIOS_USBHOOK_RegisterString(USB_STRING_DESC_SERIAL, (uint8_t *)&usb_serial_number, sizeof(usb_serial_number)); - - PIOS_USBHOOK_RegisterString(USB_STRING_DESC_LANG, (uint8_t *)&usb_lang_id, sizeof(usb_lang_id)); - PIOS_USBHOOK_RegisterString(USB_STRING_DESC_VENDOR, (uint8_t *)&usb_vendor_id, sizeof(usb_vendor_id)); - - return 0; -} diff --git a/ground/openpilotgcs/src/plugins/config/cc_hw_settings.ui b/ground/openpilotgcs/src/plugins/config/cc_hw_settings.ui deleted file mode 100644 index e7c7ddf10..000000000 --- a/ground/openpilotgcs/src/plugins/config/cc_hw_settings.ui +++ /dev/null @@ -1,658 +0,0 @@ - - - CC_HW_Widget - - - - 0 - 0 - 646 - 596 - - - - Form - - - - - - 0 - - - - HW settings - - - - 0 - - - 0 - - - 0 - - - 0 - - - - - - - - - - 255 - 255 - 255 - - - - - - - 232 - 232 - 232 - - - - - - - - - 255 - 255 - 255 - - - - - - - 232 - 232 - 232 - - - - - - - - - 232 - 232 - 232 - - - - - - - 232 - 232 - 232 - - - - - - - - QFrame::NoFrame - - - QFrame::Plain - - - true - - - - - 0 - 0 - 624 - 510 - - - - - 12 - - - 12 - - - 12 - - - 12 - - - - - - 0 - 0 - - - - - 0 - 50 - - - - Messages - - - - - - - 75 - true - - - - - - - Qt::AutoText - - - true - - - - - - - - - - - 0 - 0 - - - - - 500 - 0 - - - - - 500 - 16777215 - - - - - 75 - true - - - - Changes on this page only take effect after board reset or power cycle - - - Qt::AlignCenter - - - true - - - - - - - Qt::Vertical - - - - 20 - 25 - - - - - - - - - - - - Select the speed here. - - - - - - - - 55 - 0 - - - - GPS speed: - - - - - - - Telemetry speed: - - - - - - - Select the speed here. - - - - - - - Select the speed here. - - - - - - - - 55 - 0 - - - - ComUsbBridge speed: - - - - - - - GPS protocol : - - - - - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - - - - - - - - - - USB HID Port - - - Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft - - - - - - - - - - - - - - USB VCP Port - - - Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft - - - - - - - - - - false - - - - - - - Main Port - - - Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft - - - - - - - Flexi Port - - - Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft - - - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - - - - - - Receiver Port - - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - Qt::Vertical - - - QSizePolicy::Fixed - - - - 20 - 10 - - - - - - - - - - - - - - - - 4 - - - - - Qt::Horizontal - - - - 369 - 20 - - - - - - - - - 0 - 0 - - - - - 25 - 25 - - - - - 25 - 25 - - - - Takes you to the wiki page - - - - - - - :/core/images/helpicon.svg:/core/images/helpicon.svg - - - - 25 - 25 - - - - true - - - - - - - - 0 - 0 - - - - - 16777215 - 16777215 - - - - - - - - - 255 - 255 - 255 - - - - - - - 232 - 232 - 232 - - - - - - - - - 255 - 255 - 255 - - - - - - - 232 - 232 - 232 - - - - - - - - - 232 - 232 - 232 - - - - - - - 232 - 232 - 232 - - - - - - - - Send to OpenPilot but don't write in SD. -Beware of not locking yourself out! - - - false - - - - - - Apply - - - - 16 - 16 - - - - false - - - - - - - - 0 - 0 - - - - - 16777215 - 16777215 - - - - Applies and Saves all settings to SD. -Beware of not locking yourself out! - - - false - - - - - - Save - - - - - - - - - - - - diff --git a/ground/openpilotgcs/src/plugins/config/ccattitude.ui b/ground/openpilotgcs/src/plugins/config/ccattitude.ui deleted file mode 100644 index 1a659982e..000000000 --- a/ground/openpilotgcs/src/plugins/config/ccattitude.ui +++ /dev/null @@ -1,597 +0,0 @@ - - - ccattitude - - - - 0 - 0 - 780 - 566 - - - - Form - - - - - - 0 - - - - Attitude - - - - 0 - - - 0 - - - 0 - - - 0 - - - - - - - - - - 255 - 255 - 255 - - - - - - - 232 - 232 - 232 - - - - - - - - - 255 - 255 - 255 - - - - - - - 232 - 232 - 232 - - - - - - - - - 232 - 232 - 232 - - - - - - - 232 - 232 - 232 - - - - - - - - QFrame::NoFrame - - - QFrame::Plain - - - true - - - - - 0 - 0 - 758 - 486 - - - - - 12 - - - 12 - - - 12 - - - 12 - - - - - Rotate virtual attitude relative to board - - - - - - background-color: qlineargradient(spread:reflect, x1:0.507, y1:0, x2:0.507, y2:0.772, stop:0.208955 rgba(74, 74, 74, 255), stop:0.78607 rgba(36, 36, 36, 255)); -color: rgb(255, 255, 255); -border-radius: 5; -margin:1px; -font:bold; - - - Roll - - - Qt::AlignCenter - - - - - - - -180 - - - 180 - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - -180 - - - 180 - - - - - - - background-color: qlineargradient(spread:reflect, x1:0.507, y1:0, x2:0.507, y2:0.772, stop:0.208955 rgba(74, 74, 74, 255), stop:0.78607 rgba(36, 36, 36, 255)); -color: rgb(255, 255, 255); -border-radius: 5; -margin:1px; -font:bold; - - - Yaw - - - Qt::AlignCenter - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - background-color: qlineargradient(spread:reflect, x1:0.507, y1:0, x2:0.507, y2:0.772, stop:0.208955 rgba(74, 74, 74, 255), stop:0.78607 rgba(36, 36, 36, 255)); -color: rgb(255, 255, 255); -border-radius: 5; -margin:1px; -font:bold; - - - Pitch - - - Qt::AlignCenter - - - - - - - -90 - - - 90 - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - - - Calibration - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - Place aircraft very flat, and then click level to compute the accelerometer and gyro bias - - - true - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - - - 500 - 16777215 - - - - Launch horizontal calibration. - - - Level - - - - - - - Qt::Horizontal - - - QSizePolicy::Fixed - - - - 10 - 20 - - - - - - - - - 300 - 0 - - - - 0 - - - - - - - - - If enabled, a fast recalibration of gyro zero point will be done -whenever the frame is armed. Do not move the airframe while -arming it in that case! - - - Zero gyros while arming aircraft - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - - - - - Filtering - - - - - - - 0 - 0 - - - - - - - Accelerometers - - - - - - - Qt::Horizontal - - - QSizePolicy::Fixed - - - - 10 - 0 - - - - - - - - - 60 - 0 - - - - Accelerometer filtering. - -Sets the amount of lowpass filtering of accelerometer data -for the attitude estimation. Higher values apply a stronger -filter, which may help with drifting in attitude mode. - -Range: 0.00 - 0.20, Good starting value: 0.05 - 0.10 -Start low and raise until drift stops. - -A setting of 0.00 disables the filter. - - - 2 - - - 0.200000000000000 - - - 0.010000000000000 - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - - - Qt::Vertical - - - - 20 - 10 - - - - - - - - - - - - - - - - 4 - - - - - Qt::Horizontal - - - - 380 - 20 - - - - - - - - - 0 - 0 - - - - - 25 - 25 - - - - Takes you to the wiki page - - - - - - - :/core/images/helpicon.svg:/core/images/helpicon.svg - - - - 25 - 25 - - - - true - - - - - - - - 0 - 0 - - - - Apply - - - - - - - - 0 - 0 - - - - Click to permanently save the accel bias in the CopterControl Flash. - - - Save - - - - - - - - - - - - diff --git a/ground/openpilotgcs/src/plugins/config/config.pro b/ground/openpilotgcs/src/plugins/config/config.pro index 18c0984ea..30199471c 100644 --- a/ground/openpilotgcs/src/plugins/config/config.pro +++ b/ground/openpilotgcs/src/plugins/config/config.pro @@ -21,8 +21,6 @@ HEADERS += \ configinputwidget.h \ configoutputwidget.h \ configvehicletypewidget.h \ - config_cc_hw_widget.h \ - configccattitudewidget.h \ configstabilizationwidget.h \ assertions.h \ defaultattitudewidget.h \ @@ -68,8 +66,6 @@ SOURCES += \ configinputwidget.cpp \ configoutputwidget.cpp \ configvehicletypewidget.cpp \ - config_cc_hw_widget.cpp \ - configccattitudewidget.cpp \ configstabilizationwidget.cpp \ defaultattitudewidget.cpp \ defaulthwsettingswidget.cpp \ @@ -106,12 +102,10 @@ FORMS += \ airframe_ground.ui \ airframe_multirotor.ui \ airframe_custom.ui \ - cc_hw_settings.ui \ stabilization.ui \ input.ui \ input_wizard.ui \ output.ui \ - ccattitude.ui \ defaultattitude.ui \ defaulthwsettings.ui \ inputchannelform.ui \ @@ -121,6 +115,6 @@ FORMS += \ txpid.ui \ mixercurve.ui \ configrevohwwidget.ui \ - oplink.ui + oplink.ui RESOURCES += configgadget.qrc diff --git a/ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.cpp b/ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.cpp deleted file mode 100644 index 4fe823e6a..000000000 --- a/ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.cpp +++ /dev/null @@ -1,156 +0,0 @@ -/** - ****************************************************************************** - * - * @file configtelemetrywidget.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @addtogroup GCSPlugins GCS Plugins - * @{ - * @addtogroup ConfigPlugin Config Plugin - * @{ - * @brief The Configuration Gadget used to update settings in the firmware - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -#include "config_cc_hw_widget.h" -#include "hwsettings.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -ConfigCCHWWidget::ConfigCCHWWidget(QWidget *parent) : ConfigTaskWidget(parent) -{ - m_telemetry = new Ui_CC_HW_Widget(); - m_telemetry->setupUi(this); - - ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); - Core::Internal::GeneralSettings *settings = pm->getObject(); - if (!settings->useExpertMode()) { - m_telemetry->saveTelemetryToRAM->setVisible(false); - } - - - UAVObjectUtilManager *utilMngr = pm->getObject(); - int id = utilMngr->getBoardModel(); - - switch (id) { - case 0x0101: - m_telemetry->label_2->setPixmap(QPixmap(":/uploader/images/deviceID-0101.svg")); - break; - case 0x0301: - m_telemetry->label_2->setPixmap(QPixmap(":/uploader/images/deviceID-0301.svg")); - break; - case 0x0401: - m_telemetry->label_2->setPixmap(QPixmap(":/configgadget/images/coptercontrol.svg")); - break; - case 0x0402: - m_telemetry->label_2->setPixmap(QPixmap(":/configgadget/images/coptercontrol.svg")); - break; - case 0x0201: - m_telemetry->label_2->setPixmap(QPixmap(":/uploader/images/deviceID-0201.svg")); - break; - default: - m_telemetry->label_2->setPixmap(QPixmap(":/configgadget/images/coptercontrol.svg")); - break; - } - addApplySaveButtons(m_telemetry->saveTelemetryToRAM, m_telemetry->saveTelemetryToSD); - addWidgetBinding("HwSettings", "CC_FlexiPort", m_telemetry->cbFlexi); - addWidgetBinding("HwSettings", "CC_MainPort", m_telemetry->cbTele); - addWidgetBinding("HwSettings", "CC_RcvrPort", m_telemetry->cbRcvr); - addWidgetBinding("HwSettings", "USB_HIDPort", m_telemetry->cbUsbHid); - addWidgetBinding("HwSettings", "USB_VCPPort", m_telemetry->cbUsbVcp); - addWidgetBinding("HwSettings", "TelemetrySpeed", m_telemetry->telemetrySpeed); - addWidgetBinding("HwSettings", "GPSSpeed", m_telemetry->gpsSpeed); - // Add Gps protocol configuration - - HwSettings *hwSettings = HwSettings::GetInstance(getObjectManager()); - HwSettings::DataFields hwSettingsData = hwSettings->getData(); - - if (hwSettingsData.OptionalModules[HwSettings::OPTIONALMODULES_GPS] != HwSettings::OPTIONALMODULES_ENABLED) { - m_telemetry->gpsProtocol->setEnabled(false); - m_telemetry->gpsProtocol->setToolTip(tr("Enable GPS module and reboot the board to be able to select GPS protocol")); - } else { - addWidgetBinding("GPSSettings", "DataProtocol", m_telemetry->gpsProtocol); - } - - addWidgetBinding("HwSettings", "ComUsbBridgeSpeed", m_telemetry->comUsbBridgeSpeed); - connect(m_telemetry->cchwHelp, SIGNAL(clicked()), this, SLOT(openHelp())); - enableSaveButtons(false); - populateWidgets(); - refreshWidgetsValues(); - forceConnectedState(); -} - -ConfigCCHWWidget::~ConfigCCHWWidget() -{ - // Do nothing -} - -void ConfigCCHWWidget::refreshValues() -{} - -void ConfigCCHWWidget::widgetsContentsChanged() -{ - ConfigTaskWidget::widgetsContentsChanged(); - - if (((m_telemetry->cbTele->currentIndex() == HwSettings::CC_MAINPORT_DEBUGCONSOLE) && - (m_telemetry->cbFlexi->currentIndex() == HwSettings::CC_FLEXIPORT_DEBUGCONSOLE)) || - ((m_telemetry->cbFlexi->currentIndex() == HwSettings::CC_FLEXIPORT_DEBUGCONSOLE) && - (m_telemetry->cbUsbVcp->currentIndex() == HwSettings::USB_VCPPORT_DEBUGCONSOLE)) || - ((m_telemetry->cbUsbVcp->currentIndex() == HwSettings::USB_VCPPORT_DEBUGCONSOLE) && - (m_telemetry->cbTele->currentIndex() == HwSettings::CC_MAINPORT_DEBUGCONSOLE))) { - enableSaveButtons(false); - m_telemetry->problems->setText(tr("Warning: you have configured more than one DebugConsole, this currently is not supported")); - } else if (((m_telemetry->cbTele->currentIndex() == HwSettings::CC_MAINPORT_TELEMETRY) && (m_telemetry->cbFlexi->currentIndex() == HwSettings::CC_FLEXIPORT_TELEMETRY)) || - ((m_telemetry->cbTele->currentIndex() == HwSettings::CC_MAINPORT_GPS) && (m_telemetry->cbFlexi->currentIndex() == HwSettings::CC_FLEXIPORT_GPS)) || - ((m_telemetry->cbTele->currentIndex() == HwSettings::CC_MAINPORT_DEBUGCONSOLE) && (m_telemetry->cbFlexi->currentIndex() == HwSettings::CC_FLEXIPORT_DEBUGCONSOLE)) || - ((m_telemetry->cbTele->currentIndex() == HwSettings::CC_MAINPORT_COMBRIDGE) && (m_telemetry->cbFlexi->currentIndex() == HwSettings::CC_FLEXIPORT_COMBRIDGE))) { - enableSaveButtons(false); - m_telemetry->problems->setText(tr("Warning: you have configured both MainPort and FlexiPort for the same function, this currently is not supported")); - } else if ((m_telemetry->cbUsbHid->currentIndex() == HwSettings::USB_HIDPORT_USBTELEMETRY) && (m_telemetry->cbUsbVcp->currentIndex() == HwSettings::USB_VCPPORT_USBTELEMETRY)) { - enableSaveButtons(false); - m_telemetry->problems->setText(tr("Warning: you have configured both USB HID Port and USB VCP Port for the same function, this currently is not supported")); - } else if ((m_telemetry->cbUsbHid->currentIndex() != HwSettings::USB_HIDPORT_USBTELEMETRY) && (m_telemetry->cbUsbVcp->currentIndex() != HwSettings::USB_VCPPORT_USBTELEMETRY)) { - enableSaveButtons(false); - m_telemetry->problems->setText(tr("Warning: you have disabled USB Telemetry on both USB HID Port and USB VCP Port, this currently is not supported")); - } else { - m_telemetry->problems->setText(""); - enableSaveButtons(true); - } -} - -void ConfigCCHWWidget::enableSaveButtons(bool enable) -{ - m_telemetry->saveTelemetryToRAM->setEnabled(enable); - m_telemetry->saveTelemetryToSD->setEnabled(enable); -} - -void ConfigCCHWWidget::openHelp() -{ - QDesktopServices::openUrl(QUrl(tr("http://wiki.openpilot.org/x/D4AUAQ"), QUrl::StrictMode)); -} - -/** - * @} - * @} - */ diff --git a/ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.h b/ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.h deleted file mode 100644 index 313231382..000000000 --- a/ground/openpilotgcs/src/plugins/config/config_cc_hw_widget.h +++ /dev/null @@ -1,56 +0,0 @@ -/** - ****************************************************************************** - * - * @file configtelemetrytwidget.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @addtogroup GCSPlugins GCS Plugins - * @{ - * @addtogroup ConfigPlugin Config Plugin - * @{ - * @brief Telemetry configuration panel - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -#ifndef CONFIGCCHWWIDGET_H -#define CONFIGCCHWWIDGET_H - -#include "ui_cc_hw_settings.h" -#include "../uavobjectwidgetutils/configtaskwidget.h" -#include "extensionsystem/pluginmanager.h" -#include "uavobjectmanager.h" -#include "uavobject.h" -#include -#include -#include "smartsavebutton.h" - -class ConfigCCHWWidget : public ConfigTaskWidget { - Q_OBJECT - -public: - ConfigCCHWWidget(QWidget *parent = 0); - ~ConfigCCHWWidget(); -private slots: - void openHelp(); - void refreshValues(); - void widgetsContentsChanged(); - void enableSaveButtons(bool enable); - -private: - Ui_CC_HW_Widget *m_telemetry; - QSvgRenderer *m_renderer; -}; - -#endif // CONFIGCCHWWIDGET_H diff --git a/ground/openpilotgcs/src/plugins/config/configccattitudewidget.cpp b/ground/openpilotgcs/src/plugins/config/configccattitudewidget.cpp deleted file mode 100644 index 4e872735b..000000000 --- a/ground/openpilotgcs/src/plugins/config/configccattitudewidget.cpp +++ /dev/null @@ -1,239 +0,0 @@ -/** - ****************************************************************************** - * - * @file configccattitudewidget.cpp - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @addtogroup GCSPlugins GCS Plugins - * @{ - * @addtogroup ConfigPlugin Config Plugin - * @{ - * @brief Configure Attitude module on CopterControl - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -#include "configccattitudewidget.h" -#include "ui_ccattitude.h" -#include "utils/coordinateconversions.h" -#include "attitudesettings.h" -#include -#include -#include -#include -#include -#include "accelstate.h" -#include "accelgyrosettings.h" -#include "gyrostate.h" -#include -#include -#include -ConfigCCAttitudeWidget::ConfigCCAttitudeWidget(QWidget *parent) : - ConfigTaskWidget(parent), - ui(new Ui_ccattitude) -{ - ui->setupUi(this); - connect(ui->zeroBias, SIGNAL(clicked()), this, SLOT(startAccelCalibration())); - - ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); - Core::Internal::GeneralSettings *settings = pm->getObject(); - if (!settings->useExpertMode()) { - ui->applyButton->setVisible(false); - } - - addApplySaveButtons(ui->applyButton, ui->saveButton); - addUAVObject("AttitudeSettings"); - addUAVObject("AccelGyroSettings"); - - // Connect the help button - connect(ui->ccAttitudeHelp, SIGNAL(clicked()), this, SLOT(openHelp())); - - addWidgetBinding("AttitudeSettings", "ZeroDuringArming", ui->zeroGyroBiasOnArming); - addWidgetBinding("AttitudeSettings", "AccelTau", ui->accelTauSpinbox); - - addWidgetBinding("AttitudeSettings", "BoardRotation", ui->rollBias, AttitudeSettings::BOARDROTATION_ROLL); - addWidgetBinding("AttitudeSettings", "BoardRotation", ui->pitchBias, AttitudeSettings::BOARDROTATION_PITCH); - addWidgetBinding("AttitudeSettings", "BoardRotation", ui->yawBias, AttitudeSettings::BOARDROTATION_YAW); - addWidget(ui->zeroBias); - populateWidgets(); - refreshWidgetsValues(); - forceConnectedState(); -} - -ConfigCCAttitudeWidget::~ConfigCCAttitudeWidget() -{ - delete ui; -} - -void ConfigCCAttitudeWidget::sensorsUpdated(UAVObject *obj) -{ - if (!timer.isActive()) { - // ignore updates that come in after the timer has expired - return; - } - - AccelState *accelState = AccelState::GetInstance(getObjectManager()); - GyroState *gyroState = GyroState::GetInstance(getObjectManager()); - - // Accumulate samples until we have _at least_ NUM_SENSOR_UPDATES samples - // for both gyros and accels. - // Note that, at present, we stash the samples and then compute the bias - // at the end, even though the mean could be accumulated as we go. - // In future, a better algorithm could be used. - if (obj->getObjID() == AccelState::OBJID) { - accelUpdates++; - AccelState::DataFields accelStateData = accelState->getData(); - x_accum.append(accelStateData.x); - y_accum.append(accelStateData.y); - z_accum.append(accelStateData.z); - } else if (obj->getObjID() == GyroState::OBJID) { - gyroUpdates++; - GyroState::DataFields gyroStateData = gyroState->getData(); - x_gyro_accum.append(gyroStateData.x); - y_gyro_accum.append(gyroStateData.y); - z_gyro_accum.append(gyroStateData.z); - } - - // update the progress indicator - ui->zeroBiasProgress->setValue((float)qMin(accelUpdates, gyroUpdates) / NUM_SENSOR_UPDATES * 100); - - // If we have enough samples, then stop sampling and compute the biases - if (accelUpdates >= NUM_SENSOR_UPDATES && gyroUpdates >= NUM_SENSOR_UPDATES) { - timer.stop(); - disconnect(obj, SIGNAL(objectUpdated(UAVObject *)), this, SLOT(sensorsUpdated(UAVObject *))); - disconnect(&timer, SIGNAL(timeout()), this, SLOT(timeout())); - - float x_bias = OpenPilot::CalibrationUtils::listMean(x_accum); - float y_bias = OpenPilot::CalibrationUtils::listMean(y_accum); - float z_bias = OpenPilot::CalibrationUtils::listMean(z_accum) + 9.81; - - float x_gyro_bias = OpenPilot::CalibrationUtils::listMean(x_gyro_accum); - float y_gyro_bias = OpenPilot::CalibrationUtils::listMean(y_gyro_accum); - float z_gyro_bias = OpenPilot::CalibrationUtils::listMean(z_gyro_accum); - accelState->setMetadata(initialAccelStateMdata); - gyroState->setMetadata(initialGyroStateMdata); - - AccelGyroSettings::DataFields accelGyroSettingsData = AccelGyroSettings::GetInstance(getObjectManager())->getData(); - AttitudeSettings::DataFields attitudeSettingsData = AttitudeSettings::GetInstance(getObjectManager())->getData(); - // We offset the gyro bias by current bias to help precision - accelGyroSettingsData.accel_bias[0] += x_bias; - accelGyroSettingsData.accel_bias[1] += y_bias; - accelGyroSettingsData.accel_bias[2] += z_bias; - accelGyroSettingsData.gyro_bias[0] = -x_gyro_bias; - accelGyroSettingsData.gyro_bias[1] = -y_gyro_bias; - accelGyroSettingsData.gyro_bias[2] = -z_gyro_bias; - attitudeSettingsData.BiasCorrectGyro = AttitudeSettings::BIASCORRECTGYRO_TRUE; - AttitudeSettings::GetInstance(getObjectManager())->setData(attitudeSettingsData); - AccelGyroSettings::GetInstance(getObjectManager())->setData(accelGyroSettingsData); - this->setDirty(true); - - // reenable controls - enableControls(true); - } -} - -void ConfigCCAttitudeWidget::timeout() -{ - UAVDataObject *obj = AccelState::GetInstance(getObjectManager()); - - disconnect(obj, SIGNAL(objectUpdated(UAVObject *)), this, SLOT(sensorsUpdated(UAVObject *))); - disconnect(&timer, SIGNAL(timeout()), this, SLOT(timeout())); - - AccelState *accelState = AccelState::GetInstance(getObjectManager()); - GyroState *gyroState = GyroState::GetInstance(getObjectManager()); - accelState->setMetadata(initialAccelStateMdata); - gyroState->setMetadata(initialGyroStateMdata); - - QMessageBox msgBox; - msgBox.setText(tr("Calibration timed out before receiving required updates.")); - msgBox.setStandardButtons(QMessageBox::Ok); - msgBox.setDefaultButton(QMessageBox::Ok); - msgBox.exec(); - - // reset progress indicator - ui->zeroBiasProgress->setValue(0); - // reenable controls - enableControls(true); -} - -void ConfigCCAttitudeWidget::startAccelCalibration() -{ - // disable controls during sampling - enableControls(false); - - accelUpdates = 0; - gyroUpdates = 0; - x_accum.clear(); - y_accum.clear(); - z_accum.clear(); - x_gyro_accum.clear(); - y_gyro_accum.clear(); - z_gyro_accum.clear(); - - // Disable gyro bias correction to see raw data - AttitudeSettings::DataFields attitudeSettingsData = AttitudeSettings::GetInstance(getObjectManager())->getData(); - attitudeSettingsData.BiasCorrectGyro = AttitudeSettings::BIASCORRECTGYRO_FALSE; - AttitudeSettings::GetInstance(getObjectManager())->setData(attitudeSettingsData); - - // Set up to receive updates - UAVDataObject *accelState = AccelState::GetInstance(getObjectManager()); - UAVDataObject *gyroState = GyroState::GetInstance(getObjectManager()); - connect(accelState, SIGNAL(objectUpdated(UAVObject *)), this, SLOT(sensorsUpdated(UAVObject *))); - connect(gyroState, SIGNAL(objectUpdated(UAVObject *)), this, SLOT(sensorsUpdated(UAVObject *))); - - // Speed up updates - initialAccelStateMdata = accelState->getMetadata(); - UAVObject::Metadata accelStateMdata = initialAccelStateMdata; - UAVObject::SetFlightTelemetryUpdateMode(accelStateMdata, UAVObject::UPDATEMODE_PERIODIC); - accelStateMdata.flightTelemetryUpdatePeriod = 30; // ms - accelState->setMetadata(accelStateMdata); - - initialGyroStateMdata = gyroState->getMetadata(); - UAVObject::Metadata gyroStateMdata = initialGyroStateMdata; - UAVObject::SetFlightTelemetryUpdateMode(gyroStateMdata, UAVObject::UPDATEMODE_PERIODIC); - gyroStateMdata.flightTelemetryUpdatePeriod = 30; // ms - gyroState->setMetadata(gyroStateMdata); - - // Set up timeout timer - timer.setSingleShot(true); - timer.start(5000 + (NUM_SENSOR_UPDATES * qMax(accelStateMdata.flightTelemetryUpdatePeriod, - gyroStateMdata.flightTelemetryUpdatePeriod))); - connect(&timer, SIGNAL(timeout()), this, SLOT(timeout())); -} - -void ConfigCCAttitudeWidget::openHelp() -{ - QDesktopServices::openUrl(QUrl(tr("http://wiki.openpilot.org/x/44Cf"), QUrl::StrictMode)); -} - -void ConfigCCAttitudeWidget::setAccelFiltering(bool active) -{ - Q_UNUSED(active); - setDirty(true); -} - -void ConfigCCAttitudeWidget::enableControls(bool enable) -{ - ui->zeroBias->setEnabled(enable); - ui->zeroGyroBiasOnArming->setEnabled(enable); - ui->accelTauSpinbox->setEnabled(enable); - ConfigTaskWidget::enableControls(enable); -} - -void ConfigCCAttitudeWidget::updateObjectsFromWidgets() -{ - ConfigTaskWidget::updateObjectsFromWidgets(); - - ui->zeroBiasProgress->setValue(0); -} diff --git a/ground/openpilotgcs/src/plugins/config/configccattitudewidget.h b/ground/openpilotgcs/src/plugins/config/configccattitudewidget.h deleted file mode 100644 index b4d84a5b9..000000000 --- a/ground/openpilotgcs/src/plugins/config/configccattitudewidget.h +++ /dev/null @@ -1,74 +0,0 @@ -/** - ****************************************************************************** - * - * @file configccattitudewidget.h - * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. - * @addtogroup GCSPlugins GCS Plugins - * @{ - * @addtogroup ConfigPlugin Config Plugin - * @{ - * @brief Configure the properties of the attitude module in CopterControl - *****************************************************************************/ -/* - * This program 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 3 of the License, or - * (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -#ifndef CCATTITUDEWIDGET_H -#define CCATTITUDEWIDGET_H - -#include "ui_ccattitude.h" -#include "../uavobjectwidgetutils/configtaskwidget.h" -#include "extensionsystem/pluginmanager.h" -#include "uavobjectmanager.h" -#include "uavobject.h" -#include -#include - -class Ui_Widget; - -class ConfigCCAttitudeWidget : public ConfigTaskWidget { - Q_OBJECT - -public: - explicit ConfigCCAttitudeWidget(QWidget *parent = 0); - ~ConfigCCAttitudeWidget(); - - virtual void updateObjectsFromWidgets(); - -private slots: - void sensorsUpdated(UAVObject *obj); - void timeout(); - void startAccelCalibration(); - void openHelp(); - void setAccelFiltering(bool active); - -private: - Ui_ccattitude *ui; - QTimer timer; - UAVObject::Metadata initialAccelStateMdata; - UAVObject::Metadata initialGyroStateMdata; - - int accelUpdates; - int gyroUpdates; - - QList x_accum, y_accum, z_accum; - QList x_gyro_accum, y_gyro_accum, z_gyro_accum; - - static const float DEFAULT_ENABLED_ACCEL_TAU = 0.1; - static const int NUM_SENSOR_UPDATES = 300; -protected: - virtual void enableControls(bool enable); -}; - -#endif // CCATTITUDEWIDGET_H diff --git a/ground/openpilotgcs/src/plugins/config/configgadget.qrc b/ground/openpilotgcs/src/plugins/config/configgadget.qrc index d89ac5bca..856c5edd4 100644 --- a/ground/openpilotgcs/src/plugins/config/configgadget.qrc +++ b/ground/openpilotgcs/src/plugins/config/configgadget.qrc @@ -12,9 +12,7 @@ images/fixedwing-shapes.svg images/ground-shapes.svg images/ccpm_setup.svg - images/PipXtreme.png images/help.png - images/coptercontrol.svg images/TX2.svg images/output_selected.png images/output_normal.png diff --git a/ground/openpilotgcs/src/plugins/config/configgadgetwidget.cpp b/ground/openpilotgcs/src/plugins/config/configgadgetwidget.cpp index a611c6c51..51e69d562 100644 --- a/ground/openpilotgcs/src/plugins/config/configgadgetwidget.cpp +++ b/ground/openpilotgcs/src/plugins/config/configgadgetwidget.cpp @@ -28,14 +28,12 @@ #include "configgadgetwidget.h" #include "configvehicletypewidget.h" -#include "configccattitudewidget.h" #include "configinputwidget.h" #include "configoutputwidget.h" #include "configstabilizationwidget.h" #include "configcamerastabilizationwidget.h" #include "configtxpidwidget.h" #include "configrevohwwidget.h" -#include "config_cc_hw_widget.h" #include "configoplinkwidget.h" #include "configrevowidget.h" #include "defaultattitudewidget.h" @@ -183,19 +181,13 @@ void ConfigGadgetWidget::onAutopilotConnect() UAVObjectUtilManager *utilMngr = pm->getObject(); if (utilMngr) { int board = utilMngr->getBoardModel(); - if ((board & 0xff00) == 1024) { - // CopterControl family - QWidget *qwd = new ConfigCCAttitudeWidget(this); - stackWidget->replaceTab(ConfigGadgetWidget::sensors, qwd); - - qwd = new ConfigCCHWWidget(this); - stackWidget->replaceTab(ConfigGadgetWidget::hardware, qwd); - } else if ((board & 0xff00) == 0x0900) { + if ((board & 0xff00) == 0x0900) { // Revolution family QWidget *qwd = new ConfigRevoWidget(this); stackWidget->replaceTab(ConfigGadgetWidget::sensors, qwd); - - qwd = new ConfigRevoHWWidget(this); + if (board == 0x0903) { + qwd = new ConfigRevoHWWidget(this); + } stackWidget->replaceTab(ConfigGadgetWidget::hardware, qwd); } else { // Unknown board diff --git a/ground/openpilotgcs/src/plugins/config/configoutputwidget.cpp b/ground/openpilotgcs/src/plugins/config/configoutputwidget.cpp index 33c6466b7..9159f5315 100644 --- a/ground/openpilotgcs/src/plugins/config/configoutputwidget.cpp +++ b/ground/openpilotgcs/src/plugins/config/configoutputwidget.cpp @@ -354,11 +354,7 @@ void ConfigOutputWidget::refreshWidgetsValues(UAVObject *obj) if (utilMngr) { int board = utilMngr->getBoardModel(); // Setup labels and combos for banks according to board type - if ((board & 0xff00) == 0x0400) { - // Coptercontrol family of boards 4 timer banks - bankLabels << "1 (1-3)" << "2 (4)" << "3 (5,7-8)" << "4 (6,9-10)"; - channelBanks << 1 << 1 << 1 << 2 << 3 << 4 << 3 << 3 << 4 << 4; - } else if ((board & 0xff00) == 0x0900) { + if ((board & 0xff00) == 0x0900) { // Revolution family of boards 6 timer banks bankLabels << "1 (1-2)" << "2 (3)" << "3 (4)" << "4 (5-6)" << "5 (7-8)" << "6 (9-10)"; channelBanks << 1 << 1 << 2 << 3 << 4 << 4 << 5 << 5 << 6 << 6; diff --git a/ground/openpilotgcs/src/plugins/config/images/PipXtreme.png b/ground/openpilotgcs/src/plugins/config/images/PipXtreme.png deleted file mode 100644 index cd9396e6c0cba462963e10eee2497294bef92a71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 78915 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̋&1x0|kG&AbGp`G1#LdQQF^gVdal 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 - - -image/svg+xml \ No newline at end of file diff --git a/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.cpp b/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.cpp index a225b97e6..ed0599128 100644 --- a/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.cpp +++ b/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.cpp @@ -89,6 +89,8 @@ void ConnectionManager::init() // new connection object from plugins QObject::connect(ExtensionSystem::PluginManager::instance(), SIGNAL(objectAdded(QObject *)), this, SLOT(objectAdded(QObject *))); QObject::connect(ExtensionSystem::PluginManager::instance(), SIGNAL(aboutToRemoveObject(QObject *)), this, SLOT(aboutToRemoveObject(QObject *))); + + ccWarningClosed = true; } @@ -435,16 +437,23 @@ void ConnectionManager::devChanged(IConnection *connection) } // clear device list combobox m_availableDevList->clear(); + ccFound = false; // remove registered devices of this IConnection from the list updateConnectionList(connection); updateConnectionDropdown(); + if (ccFound && ccWarningClosed) { + ccWarningClosed = false; + QMessageBox::information(this, tr("CopterControl Not Supported"), + tr("This version of OpenPilot GCS does not support CC and CC3D boards.\n\nPlease use OpenPilot GCS version 15.02.xx instead")); + ccWarningClosed = true; + } + qDebug() << "# devices " << m_devList.count(); emit availableDevicesChanged(m_devList); - // disable connection button if the liNameif (m_availableDevList->count() > 0) if (m_availableDevList->count() > 0) { m_connectBtn->setEnabled(true); @@ -457,17 +466,21 @@ void ConnectionManager::updateConnectionDropdown() { // add all the list again to the combobox foreach(DevListItem d, m_devList) { - m_availableDevList->addItem(d.getConName()); - m_availableDevList->setItemData(m_availableDevList->count() - 1, d.getConName(), Qt::ToolTipRole); - if (!m_ioDev && d.getConName().startsWith("USB")) { - if (m_mainWindow->generalSettings()->autoConnect() || m_mainWindow->generalSettings()->autoSelect()) { - m_availableDevList->setCurrentIndex(m_availableDevList->count() - 1); - } - if (m_mainWindow->generalSettings()->autoConnect() && polling) { - qDebug() << "Automatically opening device"; - connectDevice(d); - qDebug() << "ConnectionManager::updateConnectionDropdown autoconnected USB device"; + if (!d.getConName().contains("CopterControl")) { + m_availableDevList->addItem(d.getConName()); + m_availableDevList->setItemData(m_availableDevList->count() - 1, d.getConName(), Qt::ToolTipRole); + if (!m_ioDev && d.getConName().startsWith("USB")) { + if (m_mainWindow->generalSettings()->autoConnect() || m_mainWindow->generalSettings()->autoSelect()) { + m_availableDevList->setCurrentIndex(m_availableDevList->count() - 1); + } + if (m_mainWindow->generalSettings()->autoConnect() && polling) { + qDebug() << "Automatically opening device"; + connectDevice(d); + qDebug() << "ConnectionManager::updateConnectionDropdown autoconnected USB device"; + } } + } else { + ccFound = true; } } if (m_ioDev) { diff --git a/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.h b/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.h index b19cc7c5d..1b133d831 100644 --- a/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.h +++ b/ground/openpilotgcs/src/plugins/coreplugin/connectionmanager.h @@ -38,6 +38,7 @@ #include #include #include +#include #include "core_global.h" #include @@ -149,6 +150,8 @@ protected: private: bool connectDevice(); bool polling; + bool ccFound; + bool ccWarningClosed; Internal::MainWindow *m_mainWindow; QList connectionBackup; QTimer *reconnect; diff --git a/ground/openpilotgcs/src/plugins/coreplugin/mainwindow.cpp b/ground/openpilotgcs/src/plugins/coreplugin/mainwindow.cpp index 7fc46b3a3..3710fadaf 100644 --- a/ground/openpilotgcs/src/plugins/coreplugin/mainwindow.cpp +++ b/ground/openpilotgcs/src/plugins/coreplugin/mainwindow.cpp @@ -134,7 +134,7 @@ MainWindow::MainWindow() : #endif m_toggleFullScreenAction(0) { - setWindowTitle(tr("OpenPilot GCS ")+VersionInfo::label()); + setWindowTitle(tr("OpenPilot GCS ") + VersionInfo::label()); #ifndef Q_WS_MAC qApp->setWindowIcon(QIcon(":/core/images/openpilot_logo_128.png")); #endif diff --git a/ground/openpilotgcs/src/plugins/ophid/inc/ophid_usbmon.h b/ground/openpilotgcs/src/plugins/ophid/inc/ophid_usbmon.h index eda27387f..ac806e33c 100644 --- a/ground/openpilotgcs/src/plugins/ophid/inc/ophid_usbmon.h +++ b/ground/openpilotgcs/src/plugins/ophid/inc/ophid_usbmon.h @@ -135,10 +135,9 @@ public: }; enum USBConstants { - idVendor_OpenPilot = 0x20a0, - idProduct_OpenPilot = 0x415a, - idProduct_CopterControl = 0x415b, - idProduct_OPLinkMini = 0x415c + idVendor_OpenPilot = 0x20a0, + idProduct_OpenPilot = 0x415a, + idProduct_OPLinkMini = 0x415c }; static USBMonitor *instance(); diff --git a/ground/openpilotgcs/src/plugins/setupwizard/connectiondiagram.cpp b/ground/openpilotgcs/src/plugins/setupwizard/connectiondiagram.cpp index adea4b89f..7acb7721c 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/connectiondiagram.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/connectiondiagram.cpp @@ -81,10 +81,6 @@ void ConnectionDiagram::setupGraphicsScene() QList elementsToShow; switch (m_configSource->getControllerType()) { - case VehicleConfigurationSource::CONTROLLER_CC: - case VehicleConfigurationSource::CONTROLLER_CC3D: - elementsToShow << "controller-cc"; - break; case VehicleConfigurationSource::CONTROLLER_REVO: elementsToShow << "controller-revo"; break; @@ -164,14 +160,6 @@ void ConnectionDiagram::setupGraphicsScene() QString prefix = ""; QString suffix = ""; switch (m_configSource->getControllerType()) { - case VehicleConfigurationSource::CONTROLLER_CC: - case VehicleConfigurationSource::CONTROLLER_CC3D: - prefix = "cc-"; - if (m_configSource->getEscType() == VehicleConfigurationSource::ESC_ONESHOT || - m_configSource->getEscType() == VehicleConfigurationSource::ESC_SYNCHED) { - suffix = "-oneshot"; - } - break; case VehicleConfigurationSource::CONTROLLER_REVO: prefix = "revo-"; break; diff --git a/ground/openpilotgcs/src/plugins/setupwizard/pages/controllerpage.cpp b/ground/openpilotgcs/src/plugins/setupwizard/pages/controllerpage.cpp index 6384ef239..4424d811d 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/pages/controllerpage.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/pages/controllerpage.cpp @@ -80,9 +80,6 @@ bool ControllerPage::isComplete() const bool ControllerPage::validatePage() { getWizard()->setControllerType((SetupWizard::CONTROLLER_TYPE)ui->boardTypeCombo->itemData(ui->boardTypeCombo->currentIndex()).toInt()); - if (getWizard()->getControllerType() == SetupWizard::CONTROLLER_CC || getWizard()->getControllerType() == SetupWizard::CONTROLLER_CC3D) { - getWizard()->setGpsType(SetupWizard::GPS_DISABLED); - } return true; } @@ -101,12 +98,6 @@ SetupWizard::CONTROLLER_TYPE ControllerPage::getControllerType() case 0x0301: return SetupWizard::CONTROLLER_OPLINK; - case 0x0401: - return SetupWizard::CONTROLLER_CC; - - case 0x0402: - return SetupWizard::CONTROLLER_CC3D; - case 0x0903: return SetupWizard::CONTROLLER_REVO; @@ -129,8 +120,6 @@ void ControllerPage::setupBoardTypes() QVariant v(0); ui->boardTypeCombo->addItem(tr(""), SetupWizard::CONTROLLER_UNKNOWN); - ui->boardTypeCombo->addItem(tr("OpenPilot CopterControl"), SetupWizard::CONTROLLER_CC); - ui->boardTypeCombo->addItem(tr("OpenPilot CopterControl 3D"), SetupWizard::CONTROLLER_CC3D); ui->boardTypeCombo->addItem(tr("OpenPilot Revolution"), SetupWizard::CONTROLLER_REVO); ui->boardTypeCombo->addItem(tr("OpenPilot OPLink Radio Modem"), SetupWizard::CONTROLLER_OPLINK); ui->boardTypeCombo->addItem(tr("OpenPilot DiscoveryF4"), SetupWizard::CONTROLLER_DISCOVERYF4); diff --git a/ground/openpilotgcs/src/plugins/setupwizard/pages/escpage.cpp b/ground/openpilotgcs/src/plugins/setupwizard/pages/escpage.cpp index 92bd64206..d56a2ec1b 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/pages/escpage.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/pages/escpage.cpp @@ -73,29 +73,5 @@ void EscPage::initializePage() bool EscPage::isSynchOrOneShotAvailable() { - bool available = true; - - switch (getWizard()->getControllerType()) { - case SetupWizard::CONTROLLER_CC: - case SetupWizard::CONTROLLER_CC3D: - switch (getWizard()->getVehicleType()) { - case SetupWizard::VEHICLE_MULTI: - switch (getWizard()->getVehicleSubType()) { - case SetupWizard::MULTI_ROTOR_TRI_Y: - case SetupWizard::MULTI_ROTOR_QUAD_X: - case SetupWizard::MULTI_ROTOR_QUAD_H: - case SetupWizard::MULTI_ROTOR_QUAD_PLUS: - available = getWizard()->getInputType() != SetupWizard::INPUT_PWM; - break; - default: - available = false; - break; - } - break; - default: break; - } - break; - default: break; - } - return available; + return true; } diff --git a/ground/openpilotgcs/src/plugins/setupwizard/pages/inputpage.cpp b/ground/openpilotgcs/src/plugins/setupwizard/pages/inputpage.cpp index 849284e68..1fd221706 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/pages/inputpage.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/pages/inputpage.cpp @@ -72,27 +72,6 @@ bool InputPage::restartNeeded(VehicleConfigurationSource::INPUT_TYPE selectedTyp HwSettings *hwSettings = HwSettings::GetInstance(uavoManager); HwSettings::DataFields data = hwSettings->getData(); switch (getWizard()->getControllerType()) { - case SetupWizard::CONTROLLER_CC: - case SetupWizard::CONTROLLER_CC3D: - { - switch (selectedType) { - case VehicleConfigurationSource::INPUT_PWM: - return data.CC_RcvrPort != HwSettings::CC_RCVRPORT_PWMNOONESHOT; - - case VehicleConfigurationSource::INPUT_PPM: - return data.CC_RcvrPort != HwSettings::CC_RCVRPORT_PPMNOONESHOT; - - case VehicleConfigurationSource::INPUT_SBUS: - return data.CC_MainPort != HwSettings::CC_MAINPORT_SBUS; - - case VehicleConfigurationSource::INPUT_DSM: - // TODO: Handle all of the DSM types ?? Which is most common? - return data.CC_MainPort != HwSettings::CC_MAINPORT_DSM; - - default: return true; - } - break; - } case SetupWizard::CONTROLLER_REVO: case SetupWizard::CONTROLLER_DISCOVERYF4: { diff --git a/ground/openpilotgcs/src/plugins/setupwizard/resources/connection-diagrams.svg b/ground/openpilotgcs/src/plugins/setupwizard/resources/connection-diagrams.svg index eef9bb92b..e01370ac0 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/resources/connection-diagrams.svg +++ b/ground/openpilotgcs/src/plugins/setupwizard/resources/connection-diagrams.svg @@ -15,7 +15,7 @@ height="1074.8231" width="1398.5884" version="1.1" - inkscape:version="0.48.5 r10040" + inkscape:version="0.48.4 r9939" sodipodi:docname="connection-diagrams.svg"> Satellite - - - - - + style="display:none"> @@ -30266,7 +29551,7 @@ id="path5636-1" /> @@ -30278,19 +29563,19 @@ id="path5728-7" /> @@ -30363,73 +29648,73 @@ id="path12850-3" /> @@ -30441,7 +29726,7 @@ id="path12876-7" /> @@ -30453,19 +29738,19 @@ id="path12880-3" /> @@ -30538,73 +29823,73 @@ id="path12850_1_" /> @@ -30616,7 +29901,7 @@ id="path12876_1_" /> @@ -30628,19 +29913,19 @@ id="path12880_1_" /> @@ -30654,7 +29939,7 @@ @@ -30681,7 +29966,7 @@ id="path3787-5" /> @@ -30696,7 +29981,7 @@ id="path3793-1" /> @@ -30711,7 +29996,7 @@ id="path3799-5" /> @@ -30726,7 +30011,7 @@ id="path3805-2" /> @@ -30741,7 +30026,7 @@ id="path3811-3" /> @@ -30756,7 +30041,7 @@ id="path3817-6" /> @@ -30771,7 +30056,7 @@ id="path3823-6" /> @@ -30786,7 +30071,7 @@ id="path3829-6" /> @@ -30801,7 +30086,7 @@ id="path3835-7" /> @@ -30816,7 +30101,7 @@ id="path3841-9" /> @@ -30831,7 +30116,7 @@ id="path3847-6" /> @@ -30846,7 +30131,7 @@ id="path3853-7" /> @@ -30861,7 +30146,7 @@ id="path3859-7" /> @@ -30876,7 +30161,7 @@ id="path3865-5" /> @@ -30891,7 +30176,7 @@ id="path3871-3" /> @@ -30901,12 +30186,12 @@ id="g3927"> @@ -30916,12 +30201,12 @@ id="g3933"> @@ -30931,12 +30216,12 @@ id="g3939"> @@ -30946,12 +30231,12 @@ id="g3945"> @@ -30961,12 +30246,12 @@ id="g3951"> @@ -30976,12 +30261,12 @@ id="g3957"> @@ -30991,12 +30276,12 @@ id="g3963"> @@ -31006,12 +30291,12 @@ id="g3969"> @@ -31021,12 +30306,12 @@ id="g3975"> @@ -31036,12 +30321,12 @@ id="g3981"> @@ -31051,12 +30336,12 @@ id="g3987"> @@ -31066,12 +30351,12 @@ id="g3993"> @@ -31081,12 +30366,12 @@ id="g3999"> @@ -31096,12 +30381,12 @@ id="g4005"> @@ -31111,12 +30396,12 @@ id="g4011"> @@ -31126,12 +30411,12 @@ id="g4017"> @@ -31141,12 +30426,12 @@ id="g4025"> @@ -31156,12 +30441,12 @@ id="g4031"> @@ -31171,12 +30456,12 @@ id="g4037"> @@ -31186,12 +30471,12 @@ id="g4043"> @@ -31201,12 +30486,12 @@ id="g4049"> @@ -31216,12 +30501,12 @@ id="g4055"> @@ -31231,12 +30516,12 @@ id="g4061"> @@ -31251,7 +30536,7 @@ id="path4069-6" /> @@ -31261,12 +30546,12 @@ id="g4073"> @@ -31276,12 +30561,12 @@ id="g4079"> @@ -31291,12 +30576,12 @@ id="g4085"> @@ -31306,12 +30591,12 @@ id="g4091"> @@ -31326,7 +30611,7 @@ id="path4099-5" /> @@ -31336,12 +30621,12 @@ id="g4103"> @@ -31351,12 +30636,12 @@ id="g4109"> @@ -31366,12 +30651,12 @@ id="g4115"> @@ -31381,12 +30666,12 @@ id="g4123"> @@ -31396,12 +30681,12 @@ id="g4129"> @@ -31411,12 +30696,12 @@ id="g4135"> @@ -31426,12 +30711,12 @@ id="g4141"> @@ -31441,12 +30726,12 @@ id="g4147"> @@ -31456,12 +30741,12 @@ id="g4153"> @@ -31471,12 +30756,12 @@ id="g4159"> @@ -31486,12 +30771,12 @@ id="g4165"> @@ -31501,12 +30786,12 @@ id="g4171"> @@ -31516,12 +30801,12 @@ id="g4177"> @@ -31531,12 +30816,12 @@ id="g4183"> @@ -31546,12 +30831,12 @@ id="g4189"> @@ -31561,12 +30846,12 @@ id="g4195"> @@ -31576,12 +30861,12 @@ id="g4201"> @@ -31591,12 +30876,12 @@ id="g4207"> @@ -31606,12 +30891,12 @@ id="g4213"> @@ -31689,7 +30974,7 @@ @@ -32641,11 +31926,11 @@ + d="m 110.126,10.926 0.563,1.734 c 3.82,-1.425 2.62,-7.761 -2.074,-6.405 4.021,-0.446 4.084,4.377 1.511,4.671 z" /> + d="m 108.854,7.167 -0.563,-1.734 c -3.82,1.425 -2.62,7.761 2.075,6.405 -4.021,0.446 -4.084,-4.377 -1.512,-4.671 z" /> + d="m 98.619,13.405 h -1.59 L 95.548,10.35 H 95.39 v 2.083 H 93.94 V 5.672 c 0.381,-0.009 1.283,-0.148 1.711,-0.148 0.437,0 0.949,0.019 1.396,0.25 0.734,0.372 1.134,1.154 1.087,2.558 -0.093,1.144 -0.502,1.692 -1.125,1.916 l 1.61,3.157 z m -1.936,-5.39 c 0,-0.576 -0.205,-1.199 -0.819,-1.199 -0.158,0 -0.333,0.018 -0.474,0.046 v 2.38 c 0.892,0.336 1.293,-0.389 1.293,-1.227 z" /> + d="M 98.329,12.433 V 5.672 h 3.05 v 1.274 h -1.562 v 1.479 h 1.488 v 1.209 h -1.488 v 1.479 h 1.562 v 1.32 h -3.05 z" /> + d="m 103.88,10.359 0.707,-4.687 h 1.553 l -1.404,6.761 h -1.85 l -1.414,-6.761 h 1.562 l 0.708,4.687 0.074,0.567 0.064,-0.567 z" /> + d="M 113.285,12.433 V 5.672 h 1.469 v 5.44 h 1.646 v 1.32 h -3.115 z" /> + d="M 116.558,10.573 V 5.672 h 1.487 v 4.817 c 0.009,0.456 0.038,0.818 0.651,0.818 0.613,0 0.642,-0.362 0.651,-0.818 V 5.672 h 1.487 v 4.901 c 0,1.376 -0.763,1.99 -2.139,1.99 -1.356,0 -2.137,-0.614 -2.137,-1.99 z" /> + d="m 121.022,6.946 0.102,-1.274 h 3.952 l 0.121,1.274 h -1.292 v 5.487 H 122.38 V 6.946 h -1.358 z" /> + d="m 125.41,5.672 h 1.517 v 6.761 H 125.41 V 5.672 z" /> + d="m 127.177,9.029 c 0,-1.692 0.633,-3.542 2.604,-3.533 1.962,-0.009 2.595,1.841 2.586,3.533 0,1.711 -0.595,3.543 -2.586,3.534 -1.999,0.009 -2.584,-1.823 -2.604,-3.534 z m 1.563,0.019 c 0,0.93 0.186,2.269 1.041,2.306 0.847,-0.038 1.032,-1.376 1.032,-2.306 0,-0.921 -0.186,-2.111 -1.032,-2.167 -0.856,0.056 -1.041,1.246 -1.041,2.167 z" /> + d="M 132.598,12.433 V 5.672 h 1.256 l 1.423,3.32 v -3.32 h 1.433 v 6.761 h -1.19 l -1.469,-3.311 v 3.311 h -1.453 z" /> + d="m 35.028,179.497 c 0,1.104 -0.896,2 -2,2 H 6.084 c -1.104,0 -2,-0.896 -2,-2 l 2,-1.341 -2,-2.125 v -31 l 2,-2.375 -2,-1.288 c 0,-1.104 0.896,-2 2,-2 h 26.945 c 1.104,0 2,0.896 2,2 v 38.129 z" /> + points="186.083,4.74 191.036,13.319 186.194,11.031 181.129,13.319 " /> + points="36.083,4.74 41.036,13.319 36.194,11.031 31.129,13.319 " /> @@ -32981,2619 +32266,27 @@ transform="translate(-721.32539,-464.51938)"> - - - - + d="m 1286.1956,653.36166 c 0,0.42069 -0.1679,0.77058 -0.5036,1.04968 -0.3156,0.27102 -0.6877,0.40653 -1.1165,0.40652 -0.4328,0 -0.8009,-0.13348 -1.1043,-0.40045 l -2.0144,5.59425 c -0.1901,0.53799 -0.5198,0.80698 -0.989,0.80698 -0.631,0 -1.0052,-0.27304 -1.1225,-0.81911 l -1.0072,-4.77514 -1.3652,4.04097 c -0.1415,0.42068 -0.4126,0.75642 -0.813,1.0072 -0.3762,0.23866 -0.7928,0.35799 -1.2499,0.35799 l -2.8821,0 c 0.178,-0.44495 0.3297,-0.75844 0.4551,-0.94047 0.2386,-0.35191 0.5177,-0.52787 0.8373,-0.52787 0.1941,0 0.4874,0.0425 0.8798,0.12742 0.3964,0.0809 0.6957,0.12135 0.898,0.12135 0.4247,0 0.726,-0.26091 0.904,-0.78271 l 1.8688,-5.4183 c 0.1578,-0.46921 0.2933,-0.77056 0.4066,-0.90406 0.1901,-0.24269 0.4894,-0.36404 0.8979,-0.36405 0.6108,0 1.0032,0.4308 1.1771,1.29238 l 0.8313,4.15019 1.256,-3.52524 c 0.4651,-1.30248 1.173,-1.95373 2.1236,-1.95374 0.4288,0 0.8029,0.1335 1.1225,0.40046 0.3398,0.28316 0.5097,0.63508 0.5097,1.05575" /> + d="m 1291.7352,659.65974 c -0.1942,0.64721 -0.6897,0.97081 -1.4865,0.97081 l -2.2996,0 c -0.6553,0 -0.983,-0.21034 -0.983,-0.63102 -0.4409,0.50158 -0.9829,0.75237 -1.6261,0.75237 -0.4732,0 -0.8575,-0.14562 -1.1528,-0.43686 -0.2953,-0.29124 -0.4429,-0.67147 -0.4429,-1.1407 0,-0.8454 0.3236,-1.51283 0.9708,-2.00228 0.5865,-0.44494 1.3126,-0.66742 2.1782,-0.66742 l 3.4646,0 -1.1407,3.1551 2.518,0 m -3.9135,-2.1843 -1.341,0 -0.4247,1.41373 c -0.024,0.089 -0.036,0.16989 -0.036,0.2427 0,0.35192 0.3438,0.52787 1.0315,0.52787 l 0.7706,-2.1843" /> + d="m 1300.0477,659.65974 c -0.1052,0.35597 -0.3378,0.61889 -0.6978,0.78878 -0.2548,0.12135 -0.5278,0.18203 -0.8191,0.18203 l -2.4209,0 c -0.5542,0 -0.8313,-0.18203 -0.8313,-0.54608 0,-0.12135 0.028,-0.26292 0.085,-0.42473 l 0.4611,-1.30451 -2.0872,1.76565 c -0.4895,0.33978 -0.8919,0.50967 -1.2074,0.50967 l -1.1165,0 1.4502,-4.12591 2.1903,0 -0.6856,1.9416 1.8506,-1.51688 c 0.5016,-0.40854 1.0456,-0.60472 1.6322,-0.58855 0.3964,0.0162 0.5946,0.22653 0.5946,0.63102 0,0.14967 -0.032,0.31754 -0.097,0.50361 l -0.7827,2.1843 2.4816,0" /> + d="m 1310.314,656.50464 c -0.1619,0.6472 -0.6473,0.9708 -1.4562,0.9708 l -3.7983,0 c 0.1335,0.089 0.2427,0.25281 0.3276,0.49147 0.085,0.23461 0.1194,0.43889 0.1032,0.61282 -0.057,0.67552 -0.354,1.20541 -0.8919,1.58969 -0.5138,0.36809 -1.1812,0.55416 -2.0023,0.55821 -0.9547,0.008 -1.6888,-0.18001 -2.2025,-0.56428 -0.4571,-0.33978 -0.6857,-0.78675 -0.6857,-1.34092 0,-0.10921 0.01,-0.21843 0.03,-0.32765 0.1051,-0.61079 0.4085,-1.09013 0.9101,-1.438 0.5339,-0.36809 1.2459,-0.55214 2.1358,-0.55214 l 7.5298,0 m -6.6136,0.9708 -1.3895,0 -0.5461,1.55329 c -0.028,0.0809 -0.043,0.15775 -0.043,0.23056 0,0.34787 0.3236,0.52181 0.9709,0.52181 0.077,0 0.1435,-0.002 0.2002,-0.006 l 0.807,-2.29959" /> @@ -37012,19 +33705,19 @@ style="font-size:12px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Arial;-inkscape-font-specification:Arial Bold" id="text15590"> @@ -37378,7 +34071,7 @@ style="fill:none;stroke:#000000;stroke-width:0.99212599px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none" /> + d="m 386.44699,686.89099 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51878,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51878 1.23122,-2.75 2.75,-2.75 1.51878,0 2.75,1.23122 2.75,2.75 z" /> + d="m 411.435,717.672 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51879,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51879 1.23121,-2.75 2.75,-2.75 1.51878,0 2.75,1.23121 2.75,2.75 z" /> + d="m 216.804,613.62 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51878,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51879 1.23122,-2.75 2.75,-2.75 1.51878,0 2.75,1.23121 2.75,2.75 z" /> + d="m 216.804,613.62 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51878,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51879 1.23122,-2.75 2.75,-2.75 1.51878,0 2.75,1.23121 2.75,2.75 z" /> + d="m 586.448,613.99402 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51879,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51878 1.23121,-2.75 2.75,-2.75 1.51878,0 2.75,1.23122 2.75,2.75 z" /> + d="m 386.44699,686.89099 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51878,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51878 1.23122,-2.75 2.75,-2.75 1.51878,0 2.75,1.23122 2.75,2.75 z" /> + d="m 411.435,717.672 c 0,1.51878 -1.23122,2.75 -2.75,2.75 -1.51879,0 -2.75,-1.23122 -2.75,-2.75 0,-1.51879 1.23121,-2.75 2.75,-2.75 1.51878,0 2.75,1.23121 2.75,2.75 z" /> ").append(tr("Controller type: ")).append(""); switch (getControllerType()) { - case CONTROLLER_CC: - summary.append(tr("OpenPilot CopterControl")); - break; - case CONTROLLER_CC3D: - summary.append(tr("OpenPilot CopterControl 3D")); - break; case CONTROLLER_REVO: summary.append(tr("OpenPilot Revolution")); break; diff --git a/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp b/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp index a14970afe..be8604362 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp @@ -100,15 +100,7 @@ bool VehicleConfigurationHelper::setupHardwareSettings(bool save) bool VehicleConfigurationHelper::isApplicable(UAVObject *dataObj) { - switch (m_configSource->getControllerType()) { - case VehicleConfigurationSource::CONTROLLER_CC: - case VehicleConfigurationSource::CONTROLLER_CC3D: - if (dataObj->getName() == "EKFConfiguration") { - return false; - } - default: - return true; - } + return true; } void VehicleConfigurationHelper::addModifiedObject(UAVDataObject *object, QString description) @@ -136,39 +128,6 @@ void VehicleConfigurationHelper::applyHardwareConfiguration() data.OptionalModules[HwSettings::OPTIONALMODULES_AIRSPEED] = 0; switch (m_configSource->getControllerType()) { - case VehicleConfigurationSource::CONTROLLER_CC: - case VehicleConfigurationSource::CONTROLLER_CC3D: - // Reset all ports - data.CC_RcvrPort = HwSettings::CC_RCVRPORT_DISABLEDONESHOT; - - // Default mainport to be active telemetry link - data.CC_MainPort = HwSettings::CC_MAINPORT_TELEMETRY; - - data.CC_FlexiPort = HwSettings::CC_FLEXIPORT_DISABLED; - switch (m_configSource->getInputType()) { - case VehicleConfigurationSource::INPUT_PWM: - data.CC_RcvrPort = HwSettings::CC_RCVRPORT_PWMNOONESHOT; - break; - case VehicleConfigurationSource::INPUT_PPM: - if (m_configSource->getEscType() == VehicleConfigurationSource::ESC_ONESHOT || - m_configSource->getEscType() == VehicleConfigurationSource::ESC_SYNCHED) { - data.CC_RcvrPort = HwSettings::CC_RCVRPORT_PPM_PIN8ONESHOT; - } else { - data.CC_RcvrPort = HwSettings::CC_RCVRPORT_PPMNOONESHOT; - } - break; - case VehicleConfigurationSource::INPUT_SBUS: - // We have to set teletry on flexport since s.bus needs the mainport. - data.CC_MainPort = HwSettings::CC_MAINPORT_SBUS; - data.CC_FlexiPort = HwSettings::CC_FLEXIPORT_TELEMETRY; - break; - case VehicleConfigurationSource::INPUT_DSM: - data.CC_FlexiPort = HwSettings::CC_FLEXIPORT_DSM; - break; - default: - break; - } - break; case VehicleConfigurationSource::CONTROLLER_REVO: case VehicleConfigurationSource::CONTROLLER_NANO: case VehicleConfigurationSource::CONTROLLER_DISCOVERYF4: @@ -430,10 +389,7 @@ void VehicleConfigurationHelper::applyActuatorConfiguration() // Servo always on channel 4 data.BankUpdateFreq[0] = escFrequence; data.BankMode[0] = bankMode; - if (m_configSource->getControllerType() == VehicleConfigurationSource::CONTROLLER_CC || - m_configSource->getControllerType() == VehicleConfigurationSource::CONTROLLER_CC3D) { - data.BankUpdateFreq[1] = servoFrequence; - } else if (m_configSource->getControllerType() == VehicleConfigurationSource::CONTROLLER_REVO) { + if (m_configSource->getControllerType() == VehicleConfigurationSource::CONTROLLER_REVO) { data.BankUpdateFreq[1] = escFrequence; data.BankMode[1] = bankMode; data.BankUpdateFreq[2] = servoFrequence; @@ -625,20 +581,6 @@ void VehicleConfigurationHelper::applySensorBiasConfiguration() addModifiedObject(accelGyroSettings, tr("Writing gyro and accelerometer bias settings")); switch (m_configSource->getControllerType()) { - case VehicleConfigurationSource::CONTROLLER_CC: - case VehicleConfigurationSource::CONTROLLER_CC3D: - { - AttitudeSettings *copterControlCalibration = AttitudeSettings::GetInstance(m_uavoManager); - Q_ASSERT(copterControlCalibration); - AttitudeSettings::DataFields data = copterControlCalibration->getData(); - - data.AccelTau = DEFAULT_ENABLED_ACCEL_TAU; - data.BiasCorrectGyro = AttitudeSettings::BIASCORRECTGYRO_TRUE; - - copterControlCalibration->setData(data); - addModifiedObject(copterControlCalibration, tr("Writing board settings")); - break; - } case VehicleConfigurationSource::CONTROLLER_REVO: { RevoCalibration *revolutionCalibration = RevoCalibration::GetInstance(m_uavoManager); diff --git a/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationsource.h b/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationsource.h index b0b2b09d0..cf7127bdb 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationsource.h +++ b/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationsource.h @@ -57,7 +57,7 @@ class VehicleConfigurationSource { public: VehicleConfigurationSource(); - enum CONTROLLER_TYPE { CONTROLLER_UNKNOWN, CONTROLLER_CC, CONTROLLER_CC3D, CONTROLLER_REVO, CONTROLLER_NANO, CONTROLLER_OPLINK, CONTROLLER_DISCOVERYF4 }; + enum CONTROLLER_TYPE { CONTROLLER_UNKNOWN, CONTROLLER_REVO, CONTROLLER_NANO, CONTROLLER_OPLINK, CONTROLLER_DISCOVERYF4 }; enum VEHICLE_TYPE { VEHICLE_UNKNOWN, VEHICLE_MULTI, VEHICLE_FIXEDWING, VEHICLE_HELI, VEHICLE_SURFACE }; enum VEHICLE_SUB_TYPE { MULTI_ROTOR_UNKNOWN, MULTI_ROTOR_TRI_Y, MULTI_ROTOR_QUAD_X, MULTI_ROTOR_QUAD_PLUS, MULTI_ROTOR_QUAD_H, MULTI_ROTOR_HEXA, MULTI_ROTOR_HEXA_H, MULTI_ROTOR_HEXA_X, MULTI_ROTOR_HEXA_COAX_Y, MULTI_ROTOR_OCTO, diff --git a/ground/openpilotgcs/src/plugins/uavobjectutil/devicedescriptorstruct.h b/ground/openpilotgcs/src/plugins/uavobjectutil/devicedescriptorstruct.h index fc3e0c3cd..62b4ea01c 100644 --- a/ground/openpilotgcs/src/plugins/uavobjectutil/devicedescriptorstruct.h +++ b/ground/openpilotgcs/src/plugins/uavobjectutil/devicedescriptorstruct.h @@ -14,51 +14,23 @@ public: static QString idToBoardName(int id) { switch (id) { - case 0x0101: - // MB - return QString("OpenPilot MainBoard"); - - break; - case 0x0201: - // INS - return QString("OpenPilot INS"); - - break; case 0x0301: // OPLink Mini return QString("OPLink"); - break; - case 0x0401: - // Coptercontrol - return QString("CopterControl"); - - break; - case 0x0402: - // Coptercontrol 3D - // It would be nice to say CC3D here but since currently we use string comparisons - // for firmware compatibility and the filename path that would break - return QString("CopterControl"); - - break; case 0x0901: // Revolution return QString("Revolution"); - break; case 0x0903: // Revo Mini return QString("Revolution"); - break; case 0x0904: return QString("DiscoveryF4"); - break; default: return QString(""); - - break; } } deviceDescriptorStruct() {} diff --git a/ground/openpilotgcs/src/plugins/uploader/devicewidget.cpp b/ground/openpilotgcs/src/plugins/uploader/devicewidget.cpp index 451f63a12..fab29c935 100644 --- a/ground/openpilotgcs/src/plugins/uploader/devicewidget.cpp +++ b/ground/openpilotgcs/src/plugins/uploader/devicewidget.cpp @@ -78,6 +78,11 @@ void DeviceWidget::populate() { int id = m_dfu->devices[deviceID].ID; + // Exclude CC/CC3D + if ((id == 0x0401) || (id == 0x0402)) { + return; + } + myDevice->lbldevID->setText(tr("Device ID: ") + QString::number(id, 16)); // DeviceID tells us what sort of HW we have detected: // display a nice icon: @@ -86,22 +91,10 @@ void DeviceWidget::populate() myDevice->lblHWRev->setText(tr("HW Revision: ") + QString::number(id & 0x00FF, 16)); switch (id) { - case 0x0101: - case 0x0201: - devicePic.load(""); - break; case 0x0301: devicePic.load(":/uploader/images/gcs-board-oplink.png"); break; - case 0x0401: - devicePic.load(":/uploader/images/gcs-board-cc.png"); - break; - case 0x0402: - devicePic.load(":/uploader/images/gcs-board-cc3d.png"); - break; case 0x0903: - devicePic.load(":/uploader/images/gcs-board-revo.png"); - break; case 0x0904: devicePic.load(":/uploader/images/gcs-board-revo.png"); break; @@ -361,8 +354,7 @@ void DeviceWidget::uploadFirmware() // - Check whether board type matches firmware: int board = m_dfu->devices[deviceID].ID; int firmwareBoard = ((desc.at(12) & 0xff) << 8) + (desc.at(13) & 0xff); - if ((board == 0x401 && firmwareBoard == 0x402) || - (board == 0x901 && firmwareBoard == 0x902) || // L3GD20 revo supports Revolution firmware + if ((board == 0x901 && firmwareBoard == 0x902) || // L3GD20 revo supports Revolution firmware (board == 0x902 && firmwareBoard == 0x903)) { // RevoMini1 supporetd by RevoMini2 firmware // These firmwares are designed to be backwards compatible } else if (firmwareBoard != board) { diff --git a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0101.svg b/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0101.svg deleted file mode 100644 index adc9a3d05..000000000 --- a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0101.svg +++ /dev/null @@ -1,2466 +0,0 @@ - - - - - - - - - - image/svg+xml - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0201.svg b/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0201.svg deleted file mode 100644 index 3b6a15ebb..000000000 --- a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0201.svg +++ /dev/null @@ -1,2948 +0,0 @@ - - - - - - - - - - image/svg+xml - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0301.svg b/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0301.svg deleted file mode 100644 index be0166618..000000000 --- a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0301.svg +++ /dev/null @@ -1,61 +0,0 @@ - - - - - - - - image/svg+xml - - - - - - - - - diff --git a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0401.svg b/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0401.svg deleted file mode 100644 index d18741f4a..000000000 --- a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0401.svg +++ /dev/null @@ -1,2646 +0,0 @@ - - - -image/svg+xml \ No newline at end of file diff --git a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0402.svg b/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0402.svg deleted file mode 100644 index 90121943d..000000000 --- a/ground/openpilotgcs/src/plugins/uploader/images/deviceID-0402.svg +++ /dev/null @@ -1,2389 +0,0 @@ - - - -image/svg+xmlCC3D - \ No newline at end of file diff --git a/ground/openpilotgcs/src/plugins/uploader/images/gcs-board-cc.png b/ground/openpilotgcs/src/plugins/uploader/images/gcs-board-cc.png deleted file mode 100644 index ee6affc3cd5e5d5d7208418dcf1b53b41a7c6d29..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 242648 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 }oaD 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 w91n^$X4%lQ)JHf@w(QI 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 Q0|q`+%JI)60WrCM0n@N9!T%<1l>MB`8e+DHZb; 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

UtHFIM{OWBKmo zrczLh;CEN_pWaEJ90bVhAdZ~QhY3nxslpv+`Mi|Iqb#1PiSW!8KBay7IDvimuU8r+ zv(=#roL;Y3HQxS(cem!pD_3oD%6=SxwF4yW*YwmlQ#6PmS&+Icwq0$_b8 z8OSzLu!j}}Xjj#7f}u(P&qfGdoH;VS0gC|&5-YH_5X@*U-Dk8+|4J zPYV#n=p?TJ7*JDFGlAC#^Vwx!uJrWIwDP`6+^T%^DZtgiqG9U)T(QK(D4-kM{P_4W z?=Dld!YWIvMuz^xAKV;Auj%MqEXa3ZZj5++<-o{+g|y_%u05NUVz?sDKe|%F$UOSE z=9>u$FpgST*wT<#$-$`|&pF$4vqhLU067lFf5j z2+-2;{?9>@){0CKTfAh)Nj8`F4}xBfFv; z;tNG=yya-OZE$-X@^Me18ar=S$GX8eu*pP=2#N=F9WwNF@vWj`Gr>&<5=y^4<>sHA z-_vzrdas`VoqxUKtxVhE0}}>aL#GSWNER)LpMs<{A9p0#Hh`#l;OC8L;&DNITfLsW z%Ikod{mQ$&C~BnZz!-bEJwqEWCN}*vqjo>+nRq9ro^#9N_0`fNU4Q-ayhifh26J+R zaxcWHjsC#Fie!-Y9Xa)l)Xq!)Y9|m@g?%)Nv9+e9L;5UU>?V1-DH|1QzWp9kFAEfm zwDHi^ZdbV1)4s;M(9nJ4+f9*$_iwgn(8F90Thx6bUk`7pudnZ_xGj3EVwMr$4YSPm z(wz7UT7pB{bw5d+2~E17ahUuOp*bP6um;o*UV@_waQgIz97FFK4qKWln$$M$-^gan z$7Xm1|CR3?*md3n;0sCJs$9&htcFtKhURO;d~E% zKe8T*|Ine~dZ|?*srjlMC0IjyqtpQN=1fojYDE0X&nx&G*b{k_1$PC{u#Q?bnJo=h zFXVq^YK^pEo0x}bh3ZJeAGr-cJwIl?JLo5icMB{UESh(LQ4Ko1BJ>_T)mS4f=>&-8 z9oX82Mi&s0vbZjB>%rfBUj3F^o_mYkOfuK4;A>8*^3%nquDl;fWZ&gqi#S|PWNZox zdjUY8=FPyboWeu1?^FX>^_NreS0B{*jHa{;0%{FO!5vv2?#O#JgqqpOk zat}7yPfKvBxN;TR@ZM{t6Sr!5bVFF5GO)T(hk6vxMg)Ix0`6WS03wwPsCxb2ht@FW z<@l2d*j;}Ec12tR1r{x^I6Xp3jluz=ff;gXNz9Wp`}MwNyHWwUg@%TOhfO}Gco!aq z-`FjEJW5qtE%jy<5UzvLDM3BtxS5jU7Wyp1y0~ZJ_3k6Fw?IZht27+k6KV<5aVIz(0VyVlK3@tM8dqbMy64N3~z zL70&@05A!mk^X&sZ{vu1j@*&(q8 z`i5WXY*5t)YcFg$xsUDH+iqo2@820#`qNFb;Vb)4KKqcA8tof1aYGF=n51w|AnXmf zkq9t8r>9qSywm86yZgRSZXrp@oC{h(wFBhaU}$ONP99NRTz2jEQ58MF)yUr7_wo{Z z7xSTu5gBRBcK(Zb;@>{zq_;%}%>1|+@TJxB@9mADQIo)CA<>feXB4{q*A_Y+(0-~6 zCt{Rj?L(rEQ7YF3Dy0m4!B^-C#D$EAMzUYsw(df^nSd5%uYY;XXapg>z%rki=A*6e zJ33M-i}UYIAFbnXlx*pS=MC<1R5yDFLJ1iUxguId;H0EB26_D9@~V24^Yuw{S&aWz z)h9bn)Cu%YjngqGGWL6PZ~&>r<(;nJa?WhUxkwUsJ)U% z^u$wOqB!%F6mx@hA^4g`GhOjf?KP+G2zrj^^;!=#1f{#beQhKstV67>Ui~&^i^Yeo%ATcW|;7Xj!eYCltK(x9? z#304~@sx!~v_LNdUqDeE*Et+ie;P~}UL}Y~AqjcdHukAa&RAt_^?Y^6(RC+WOlzEz zlokKdJvq@?FlsAqaase5lC8n{a)c7g7DUi>aq5Y_GB#+r?JM%Z*w=^PV ztHvD2r3t(POh%NEgn|F|=zu$B*VOCoS$2q@U@*&3D=Ds93ZHljD5)0Q#{A#n%9d&$ zYNC1~Sr}-Y0C0bI6wU8<>C*XRYYLg5ZkYo=*?&}mUBNeA^+JJ)to)jFN%*joR{7r*NE@SkN64yeBzur26%EyD$zE>Xy9 z$UX*Oou4QEmQNgmj|Ez>g{dIVW(3TsfD8nOT|GGU`|#TIVYjuV{wrt!(O8m$0%hnw zvIv()RkPo>`*|nhMW)@jxh`%MV|%wd@$wfl`oCr;8hZ={cjLtXF-r24h-MjWH7Eyw z{rKJIXLCJUaG~K|H%GsqD{#NvIvH&lI`d0lA@s8W;NpK++Me=l8zbURNFH=|ELZ9- zkJ;&14bkV=Z~d_FE9lu;YV6^gwjcJzP`EBFVz!~!upZr0T278aXi}1PQl>x337SX% zKc|+W`@dcnCmK|}a_2mwW+5%Hv&IIa+e?2PkD}b<{n%V#P5XU=ynZL=_Z_h!Jl)4b zm$>V>j(#zu4HeV?bb)IHDcUNWJ6p$o@on9JCKZJZR;5O0O85^SzJhj5EcP9xcbBt4 zPUU}_I_ZUe9Ysfw!1o2*rvV0HaCSs-a?N9A4=6b}3a$u0nkl_z&BV%Tfmeon31qRv z2nD`K7P~{?v^7VO$8$#^p6x!_^Bj4xr|yy3CsIPyn2!caej+}9hBA*scP-38z{Iy3w$(~0JzC>kS9KTgq{SIWEJ zVG4sGn@I6U%u!E|BCM||Gle}M>Ny$xnY(>F>V9t0qf5Zo5#|lhyHz@;(k1iF8g~(?1_{%8z1W_MS^#F{a`#IsdIm;&$WEs5k==kN5vak%qVoE$ zU)h7{`vRtp?e%mkcW@jI&d26~iwXyp; z|D+GKgkWdErRA8}+dmu=sZj6MFn72vEiJ`Yeyuxui7N6AKXn8BDm~wSdZ}$LqI%j;`rR~q+tA>(|<>813h#4U$&yypfTJ_^B_){hwbHM2ECMm#CzR~ zuB99mULLdBB=i2L zQ!i{y5cwm!sT$le-mvC)srZNpMxwSNdN}y&|NJ-BShs)4!{DJje~+uZ@`xJ`NYu>{_&jmL8RI7xmckm@Ip z))UMEEdy_e5^bQ|Ic)}jelUJQ8NB)Kv9prvdiPt)?m0&7^H;sW;b2>^Q;kaTh4<>A zuOmK$Cd?i>5tINU*S>%C3cojL9nkxMziC9geQ2vPqsx0!l5bcK9dVSDrz9LeUGGCD z8r7e+({sHIU+mn}&4+g!RtL6C&FR>jKe8G9$TR(4|A+NYvE9S7*CA z@@+r9fZ#xK{_DndIKR)&@iCt{eySOgNs^HWE?ZMHvk?jVUyNtInZ{SRO=g^mpKZh& zlzTzj(O7J+X0!^CHl9XdZrthY9D~boudYiE?ynjzi zG);iolnrTkWLw^M->j6un@Z*?Z*rGfXGl0$5l znv;E6Mf))7FTa1;gmVgv2g9Ep9K2{}AkG$+lzasFDh74pkrICnxWnWp(q38;6UAEH z*3=zm`+mqT-Dji?{mi{>b2DSloxt@yzIm~d*z8FA)`IurOMrOZP+VCKbIS?JC{QN2(7sJ9CxiZ`92htCY z(H^Jty+}im5VAEqe9C$%fzN*Utu|x`#JK=)y2@4rGGpkSAVtW}7eFg;1KJT-aqzF` zCXGxTr_-y`#Ra{6#hHJY+>|LaJS(|t&}7$2^Cv;wu$7UyCB6KlN4Xxeneg+GPygEAvA7cr`G=6pagPJW~ zRVI_RG|lYy_Q=<5I(Tm`5Q6ndo%83v9QHG9T)JMn2o)F&Mkmidik?aHgRcw(J^m!J zfpvLJaVx^?xs;w|_@-!LPjwI{?kW<4mGkNsl0{gcMsCl%fNWAf%>u4)+UNsf8Wr0$ zFP{5I+2^}KOfFFfx9-Bi0y*DbZckQZ8C9@^HNHVWsmnxRr!zuIPQdO;%d3gAcNqWy zVOg6Z4W61-KU-*wg9CpB#vXKv&_V!xc^ql%5d~5g zPo7xX#~eVX)Dm+xd5>&G_K3$m`uq29$y%9FE96fu-+XpAw6r8Ydv@pEmK}H$43~bc zlw5QVF3A%~v3Cz`Jvw%OlkYEmuXURf?*flBE$BMJw2c&ZT&Ga%<>_wA70ua~o0SDv z=msM0;FYg|2FYb{ER}qy@LbVRXkKl6*v4My!==Y}AtG6fBkBup-h}Ee#!7W=pZ^*z z__1+wu#;ULkZt4LC1{n@+UQzRa{Rhvf-JVszsk1(PDsh@%A-V5*EL-Hl;Ww(o?}tpW(A z24|4E)XFg;ekMX{2#5Mt{}wODug!Q81)G2WD3_E}e9TW<8dmW)5bcu~-UPl~+cqN) zz!bFc=Lsi4gOdNI2J6FRjepq8AvXg;mVXJ=v6F5OU{sW*3|?8Ct5oNs*EFcrT(IO- z|8rE2OLHRfQC8A;y+gH6+2OFx^f~Iy_Yg+%!nBqOkOiZ^52jiY3k=r?_-)0^_JLVf zUpda9k&)2Y*cQ_N0dG`GrK{`@s`)0J*?vH#9T_AaK0rm;))BGbd?`cHO!I~M#M|A* zYJCE4PJi^77b#^`I>PkEq5x)FXdl5N($YLYy>l$N?gE$Aiyfdb@cKv#%GeZ<-S8#gbm zloF4XGSh1HRJ)zU=b^E#=WvpR^h;NE|;|^ z?|^9j21U-DKyRLa{C2Hi1=Ws0xx74v)YilJ0fZ8BdW8?cuc!n10_4EqM1{(j z-HOu%*8doA&zC0>Sk$(+;Ri`=(=B%vLM*{Dq5A<$XfB>BI@Qqrwmpyg?w$A(H&yhC z?Ich~Yb*-*sh*?zaJ_vSv?t|TxnvL>-yzUHv}#O}-M zkTzOgj#`TXm#Cfz59QFLh5$wL;3|PB<)>D{^TDV!hxM{M4pVwP8=edHZb(_c;0am^ zAMYt-zY(P?a6B>;5QUabw!S=qk8rjj?Z3G^e*^k-T@hRm{Oj_LMLj6P8hYpc2Fjz8##KqsDe^qpHDjKjW#8|ufjcxUAuII|QpHmSe zIV6>wL||gJc-QT2DZXaw*uQ@+WbxJk84kVgD#^!VbIvxJX`KB8)~xZ}J02-1HW^xI zw1-AV3CRV>PX5v*4jeN?TcDT)s-=<=3!4$@Qh0cHjHLThj6)=5Y;w}GHQiB4@JU8( z+)Hm&rj3tvgNG`u8|2s-!(MdRlJJMynaEf8eXzJ2_ZK3Tm!tHdbzgj(nm+F-3MVwtU(AGVUf5y(PurvNX&eKte(M8F7*QPgrbHd z9+NQ`;6G_o&^I33pJVmWo}2%2PUpC`KiS4tL2scH3=fF%Ff=dK_7(( z5>TX=JBZd66B6O+^M#FM7D$RfWu@F{mI z#RdROC?*IZu=Lu~V*Bz^+u28L6O*&9dU>Xs`seFJ0TKiM==(~N>s?Uy!+#pE1X^_O zmX)yDv5ki8Wx(Z)P8qeOk40jr{QqeIT*nVNi0{L$49^;JV98AN^|}}&3nRn`0}yeo z8aML#6h}6dVYQGSueHwhrSr^2WwA|eY8;Z^Ui!B5XV~O*v0!fHJa6FPBz;U1c42O1 zq@V^zhi#O0auPw)2+Jr|T|MGfX7m54Bf2rHRn0@hn)8IRfF|3?g=?nU6BO>XPS)EM zLx>6iLc+5b!SMft;NbH4!9@qAkGNd1Wfsw+`EZ7zRHmn=UxHOnIaIS`iwYgfYWmzW z%ijGwez$olBV}bzhD~yPXg_H5{s>Fp0in|Xm)FHedB$Po4i=E8BbN_t1>TjmFJGF& z4_-*&qcihYz|V!R1KAyTQn<2VNk0&kXV#$1&i+fV9SsLrQqG3=R8wDH1=7iXa^%t2 zTj*D{y_%1+Y{z|1%)!NGl<_@z_i)8OVwF%qhrLI{&TML+7RF=Qa@X^xxLl$BNZ0y4gi|55tHXGXckF!kDh zv7386ce8q%aBv6*JM)+G^DC>jkR8W`p6@qhzE?wzcB9}%sH^;JYH>jjZ0YV6)@Lxd zz{-Mjs0Q?~CxAbLa{Gohd_T#-fL{>7QzY8L$YnU3qIkDUewg7l6MHXkQ!IJ|vj1U_nF8lWFlb+Zx)(F^)e$9E< zjo(;%6C!ySYN>sLQW7PyeocWP~U2AJOg zogIbJ5rP(j3R}AzWKxdK4&Ih8yV<0JjO2T*qgn%^7%ve&Ln$H!5d;}=a44XS!S8@t zjU+?DesS+oZm|5jbf5Hw z|Bf9(V=DRl?pYKpXh?Dlo$lCm*q|gBVW$0)KvE!yC(S-)1lUO^5yc8|68u3VSaEsT z4GG4d3vG5I8Iat{q+XK$64N61E@E>*sM7l}2d$U3!D3UEh57_wVF~nmPdRn|iCyu< zE@QP1`sdC)+q$7K9ZSFPPJ#L%HzyebvG#L{1OefQC*`ppF*g)o+|SGV0I~)$l>*}+ zP|LS!A6&s9(a}wC%+v3F2|@QNX1p+x)Bv5=K`Y1h(U=wr&%};r=k2V2IF98{HIKMj zH$To(pdGN|z`0V{G=n&YfD~j>AuCb zJ44v+9^tsp{~*n)>%jxX$1EpU0`G%Z!}W_l3|IVgx6SQz!xwkdJr~;`@;c!C3VdHq zj-5EK@X@nzbUX!)$(#&R6JhIT!-P2Vo_H&8(fXfdGzy^O2|SS9X=Z)Rg$-{a_%DVt z`j}eLSP|@C0ITA;@y8P;6x8Fk&G#}6Y0au)?t!`wa=O1g*HV!|u&bTtR${CuL|6K=qZ{czy$LIe1{Afg#J9B(VA`Bvy^j3M1tag$P_fL?(@9F-!+jes3nHV+Ri^X=s>T7@0K|7Q$PdA~_1G70FUAeI5SH+wW<{c|r zTe(nfG@2xc5%N^oP;Q(DpzS0j7I;6pU>ATTWD0^;!SBeEoOeF1)%bvLB#_7Tyri!| zCkmMjC1i$9ZZL*K)?RSdTrRtCPkvcyB2CrFJi4 z>sK`ljDavm5@-0MM`V>LUPz}``~I(I+-YKftoea^>7gcvhxmXUK-aqL+6y>@G~mTd5gpmak*Mi$wX z^!`d}J{vZ1p1Kdh0KC49eEQ#XQ;l({T8T@sEe@T z)KHes_-p*-aaBzvF|la42Fb(abCN*xcaFLaQTukf6nwlzEzmK$yDQnu2!k$#u3 zM%s(U$vI;eDc@EHQV( z5K4dO`QEQ5am>+4fWRCf?-dXc;u~`v+u!H0bd{_~gA?;Iq1Y4>HIB_qdxr;{4~ryX zg+~YUg4yjhVe|BbEH>8)qjVz)=+~iUd26aCdYTr{B8CbWrx>A#1%hUR(*vjRV>*Y7 zeiS0Iq6r=DQ?g|eUI)0HN`a0-tDFKKA1Q{UAN+}Z$kOc3=DkzP9t<@uE4+MQ&2d1R zcEO?kol}2T4DZ6;#tF?=UrxlTF&;Jw(8(M|(uzT)M=T};P;U@0QEa%&e6VwERd(f( zYCctz!B($3nzt`ka|)GS{iq2U6`z2BDO`ORMe!2p;j=>px?n167WoVdlh+aZ{s%5a zA(lWnt`N!%p>jsrhqU_|edl+q?@AD}@}=e3&6{zjfp_QmI3|lNI6F$*MFABKEg8u$^o!HnipYwIZm$gU|>Jq z4!EUxfsl4~Dnhvf-~l&N^>bSNY)1cDueK9!@$JJCa&CC>(g`T*#XS;B(h_U%#aiXm zlj>z9M~BZ=tS@f8m}C~L{LoT3sz{zQgsaNr#kh_E-#v9nGEZEDMd6s`5he$P#2Xvg zE>EwYI#3Qx2{@<#czUL%r^V3U0GcBKHi$cfD)){;;k6WkUg{r02pWhn`5O1JkNf}UQ^Rz{uV06k6#w{m zCaGXoGh;fB^ulYhM+8|~1U3cVhyYgRUbi9T?lFgHU{A!Tfgbp9`ERcQD&VwM2vWk> zs>ChK{65Z0H_3nQ$r$UWC7wAA@eN@DWbh>Pte&aZP3nZ;TpABaQqMwLf zOq%^a4A-s|t8@|ia~7xf=czBpIH*7U%tQTq`sN*PjkB~AFZDHU_=ah{2KJ)9(A(eN zilYX#)_)+dVeol@rs`MeoDn!HB@dbPxV*3$kFv@mU*d;9rSMD?yW91L0C-QnUJ@ktDM)fs z;UOjah?xNi#y3Gb-RZI&AyGAFj2Cx7cR>W>M58^?eVmYO;Lf^=u99fS<;u0WHB4xi zp%x&g4uA*H2Op!{)YQ}m_}p+N=i75Vd|E8H&=o`8ik1f^U%Z3+!WxyFoM<4UhEa#` zaObq-uJ$U6GOAu#A2Mn9tAFTfLYhWt>sbjAZ8qM+t$()JaZpI(##De>-~{c~pVSX( zYKo`5nB9a!qQZqs%rOP0VqC!bZN_P#d@rR?xg$*2th5bQJ2(PSXG!85Ld;r6|BaKV z1Z0pyJAl3dzyWFz9NBL7aoTT!A0o0#=pGU+#N0uJ>acCrfUJ!tG z|2m_JT-WMt4{FeFOb>;rlOBa*>jpA{iQO3R*0cdSOSpjO7Qes8_f0)XUum2R_T%He z()e_&ukC8Qve@mzN(|Q^`Esp@gPD3*54N>{SMA$nR+f1?R9)iuZ(YdttIRYs?8To8 zn;OHwEi4>EBifL!J0QeydyXK&qqlyVAn}fAn*y|#dAha(Co(ohw@*ZI@1(m=o6NeY zI*HLRQJHN=@@vtkm^VTG#s?Xr9cDjTJ3eXQ*{?96;OiLE{2lsdm5!q8V$B$<7hv;L zI>sWO_~8YJMC>kBwzJDIZ3hSo^YUGEh`8bj1_J3bx0IBzuTW-Ajs=2<(PxlTi1@{3 zVyOkQgj8*tPH|)niS6z3v&m3Py$q}vtU3k_2GMutDY#-2xE5H$DjgS2G%$`0xqqy@ zJlP)_a_V(IX9M>eL^F#zSM* ?qzap};+Lo_`f-vvO#)G^P4SJ++ZW?H0c^4yb2G0b=0d9@3`1qjKQH0mQ#fmC|zj&v{r?j}j zXBip^>(6hnt#0Q%HtAKiSh^Ui-0T&8fcZ_5j>q(U^MU6@&$yi)Wo*j0p>UNFK4Vxv zZ=!`HVj=)w$WKwo?Ieaa6cmzRhH-s(a`o4wrJWrQMo9pN7(AeXBkANMNdT;0V&^!C zNyDBM(TyAL`Sn}^$O(FodME*XzOm}nq zDbke}Bfh1w)-V;~6}X%LQG(T`K?{K;5E-8ROe^-A0Nq%Ii}0zP0NIo3$yG+L#Y#a>V48KD?-Sce+tr) z4DC!^z=If%5gSh;A_(+NB%Tl=psOZP4;Xz(oGGAwo~nJ^xLX!-COr9WpBzjv+@~27|D!S;xi#eZJO+-rG-m|Q9iC@>x}OPh3*ryjuP@3Knj?e zVBPX_YK6BT5*U)(ubc58(H?hn=zvis>cG^t8vxjWC8_~gBYy-=5=l@82V)QICxH(D zVlfbdAAWI&I*cpd5n>s(P4fPPa(_U$Qm>sNy*#%vQk78Z$0jCX6G|g^gP~=_=^33t z;3a@k5~+!!^#DudVV;J}tj6*f&n90rh6t_LH4EKsaHWvAf|oDpA=Sadg<0z@_ug%r z5s5bllyZbz`LGa6rkhcnM0_mKtKzDn(8)Z0^_6Bw=$;#;DvW=w{pm|Rx#mzcp8n9h z>}L9;5W}U%&z-6^?D`_{Y2vNP<|MaBvv0Qty562q_U676E6~IB?8C!=+ozbeZN{TQ zp%E}D$JT-olVdF5oX(-#sHqLGypsjnUwi(ACJ;{_CaHOMNgibx&YdBLpX&B-Ekx^V zN;zu99Oc%^6QpINp{x?h&U@2yKZ`U^{~XpTd`bqVpfgaJLYF`6i5nY_AAK;{!2_wV zhJor~6#b@QQ`|%_15J^YoLgnTWRH_(VaE=HV+C{j0!$!VkDsV@h3bI&9EHqA+PL{3=;ApI;2VDVWfPd>~BAm{!k|efUmpV^zlF>4=T~k;0 zVT%Q#Hc(n>kWrzHrcw^W2AJT;CV8;C92~{>b#--NDwS`1%DLuWYYGJ`1gpsK z%hvJlvgJ8=kQx;hz!%u3?+)U%S1D8CzogJnJs7y|kkklg z3`Pq4hd}vcH|M_%X?UjL^i@(&;?9qHu3jOsvYKy7F7AaUf@^A{1IK!FBf6{^!$RD8 z&p)j{e>HBRP_x!0EmEuZ79^T{zeVU=8rgShU4D2c>19#=u#6CA!?|p&)Uo!5oam8N zP9cg2qMgCHC0q*s4NjR9=;78CCn`<&Y`&&SwGb~Ow3vW;4C1e+)5&jdl)VvSYq_gi z%BqWY7mKKJ22Zam4^52eitip3(~Oxk>$#+P3kAhkbc%US6Z)iCfV3ch&(BYoBi84f zN6;|UFkvgf_6#pC%n%p&Kld3NHz(G?GP{45@AdiLmq-JR*&58p!-R)02Sd454zLqo z8AP9t6MXCq_ui{|_9icl?TbTyqpA+oYz1JMe`>Ucpbqlv+YeC4JVSHIL36Nosx46K z$LptKx8ojh_sR+<95Jjg@_YprRf4s(r+7e?*)2a9V7ePSE*a7tSLkOK1?*^`!Z?j< z10XU5$N!<}yW_d;*Z(CIlI%noh3r)nDtqsdqC)mABOz3>M^;2g_9m;c8)QXUA)>O9 z+(HsjzvsL2`<}n<^Eh{hKA+d?dR^CZU2Gg**M9%Y$cCXAYJq%Exk$m^i@v$nzU9-E zM?lyxJ-;S$5W&YH3(qKm^4}m@Vcw(FkSd}IJQ0^i?~Ym_t8Ha<$v#k z(2L8+c!QajU<3%qHddq=Y;deMd%a-^0yMcxTT} zG^-pzJ{g8u5RqHu3_3#m{5jc^_YJyFjT}05aKHN6LeI=K=`6R% zwr#;dP+`bp#v7Wbr#Ncs*|Hmlk;eV%Nzoh<3Tuc$r zAP}e!bX`~^%C{|_X5Tlg*G5iTz5$gUC>zRPJWLb`dHr)-GBW3TJ8kUjkn#sr9VY`N zj7xZJ@zhr!PzECn5s*$z%`b79OkR$mb^rF^=?Ms`o{Vbaqea-2&4UdiHC3&F-(9B{ z2%9+M!UW`wsJUefuZe`H{>+(RNG-nfW^ev({wpK9(HnEOI=8<@=EGFU_>m7mG8e!5 zEmwq-+JBwTpHKB%XiibH+Y@&Wu11DFkL;=0wf%GC<2iDt9hAc^pJh+A-=eX$47|zf zNKO_=a0j5&6f!w5qg^<0;{iI|D#taETRnm`MplXmhs4zsC#WC7!m z_S>e#r93L?#zzN_XVVT$%mW{Z$Kc`|hxu{3aL9(qcWwttKy;pX!^KjC z!m{KzJ_0eki$>MLaZ|O(&5ECv=Toxhg1WNlX_B>KKJ8oHnF`sxPZ^(1t*i?N#O`VT zI2lX`YPKtK(0nS^gtVND`zlGtXk{(h+G6>9Hm$YtOvhV*;S?dQ)R zAxCUIc5+@pA{T*F0}h5N>r?8)W?uYdsLP1GB*Y#)q-bHkkd3D&gFMau^nVzK?>f$a z;~s-a%nxv59?XZBrg7DglOMhtJ)HXuuu_RPUxSkeNe}1{MH%P@galAxA^{EYA^JQk zQ`K?qdH0PH-hvnirHmmX(zfbOaz<(vj-mvcBsu8{4@}GX~?{hsF zMIwC^G{+-S1O+~c^+?uXHFk)%MNzNRD1FGX1Mu!4Hg@sT zJzpi9z;!&c5T!{VA~bsESFP=45exwmpBV!R{`%AuNIN~-H?I-TAfm)uAaZP_{-jR~ z?{9A3v+A9DbWLS>$~e?LcW|Bj#Qe8f>Qx8$-vxK3pD+J74( z6;RXF-Aibf*8%DfJ{tTT00v<2FnHTD?T!Q|d@O_!8Tc=xOrg{Vvw(;b+ub0!GcYuK z2?-@wAYw!9BnB;4h0F>#9FSSqiQ~yQM48=7^p}9s(BERaOe-KG{Ob{;H+}mKu&`i3 zg&0O+q=dE-`ALJ0Hb7;7tC7I|hTn_O22XpYT;a;U7SuwaTBi62)E}Tx)GI%;-{ay!tn;WNeN8baxfIf6J`L|%C7@$(phsN9}w94+k{ zc7Dk8)~@nG1G~#7&o-{}Mgza|rQ4k2v`)sW$8ojx`*w0cN-yAGF%cQN`a7D7Ni5it zoZ`Apnd)>{y!UDS0dQhr95>r0(Ru+mC~u(##e}MiTb5f|is;Nxqx^v zo4e@v$GRxQ1KnNTBaB6p}4FWA@)tBEpKXi zFS9sBFVezG5xLY21pNCY37*?A!UX=bm!a3*^8!PwSk=hpepm5zz+#^O7@Q=wl(hHs z5DVNt5`FSNPZ7eYTlbk0&%K7uI=(#a)WrXZ+kl-R?i&VOv;l-80vxL$_!wnVY>DZErT?GyrYxw zg#o=tJh=u_Fhy|XfI{6#DQ?~IWoh+zA~h5;Zi3iG$03TR1SmclT5vw_Lcl;b4LNe> zdcVVvp~>mKg`<#!f#W!VWqtT~XO76OQxFd*2_5Nl8@{vdZX2{s7{O79E*Ds?F?^D3 z5?|m-)46%?#+#5Jt!o$RoN{F(5867aE_;nc>*)NQTlKA-yd%SK?JMA+Y<-!o;-nNA`rYnOLzjVLn6c?RZy8?_J+0$ z9eq~++=;6j4ASZEOVzxx>3HrjM!w(@)8Nr5D0*;v0~)w{7pu4)j?y1iWuMGA{`J@L z!p_br<(%-;$QCZL=>6w^kxEm}i7`Ap!>5L42kPqKgVb>ENO3oM9ik0;BA4AuL>Z1Q zSliiINv5g^zCPi@9;cR!O^lE5;IjFC;l!`<6hj{1WaIc-?NcWcS2@?O)h#Oic|27y zip5FB#(7WICw-e-!)Xib9}Fd;KgQOO*lefGMrSLBZ8xq zmUe*qt-qh&1vkU^a8>?mfm6db@nr%X0nWw^Isx+64r>JlWzt(W@kL#*cgqxaudA+LYS^tj1?svIla zf7ADz2Kf)2!QjA7Whcw}oJ|pSj?BSVRY!4JA>h9yN786UOe1I=2&M%0D;1{M*S1v# zx(fOI2w}$!kN)E6OD2DGe?DjCz^7z&d+n#}JQN1*4{L9>$dRd}>o>WjhWvfp`|K;_ zsh#>9{H?{gPRCvZ-BOdI`(Yg_Oy6((Hs9kR_qeSTZ9B3V0anb+%mlG08@|t>E1)l} zcbC3&=|vGII<;+tB9jl}e-NO_yKL^S5-|HhzgNLM z`VB{Se$4(SkyeyH#^Tb`+3AaZ@5@tlE^NoSNtjs#O)AMCQb3-d1DpR3{nINcZysU1 zCj4et2ZrE3M0vtvBn8eB2@P1uMR*f{qvCT!f)*%8U zIa-Qu{N4({zlKtXWzG;EVG}X5mmoh0!{Gnlg$%^3)l&b$Q=}eZO2VD$wI_@V=)a&~ zfl>$XhD~2u^!50Y9bY}Ap~XOU09q)U^RR``lMK&lIE6kc(^ZWML$N>(lkg_4h?x`(IOy6p1eFPG$)b zZs#JqDpyxmeq=%sA0tXOA?9jqJc#Dv)Y_P$vT|^|L??dPGE=sgP#E$0-}hztCed33 z3Tm~z(fRu6nCr+}EuXXb@p0JSadwd=qjUf4-%-m+k5v_Sp+lbva-PaLklh+?aTEPS z&7<7D=ci~{Mpv@EO0m5D3BWq=HbYbbDvZnem4=MhH)DVs0>lmF>9a2wE2BQg`P1hh}kQ-B_Z>deH13HU?2 z-W6k4!=fq9xssyrH$siMQ;OuLGe`$lcgXcQ)_A7pbhBC|XMS zOG`_k-oiY3SL{PvmSy2GMHe3Gn-tedBOE=6%wYOg`H$wX#(s zzn_*en0T##z@rf^yXyJ96M@Z`T-Sdf=p5pg{RgjpUftknZyzAr;ZA9BHIheJq2{W* zjXWa<1J!5GJCAIBdo_73sz};AIZQ5=6@ODjjcZWMVOe_Vq4z=GOLsTJ?&%wHe-IYY zhMH$+o>rL_Ek7DYO!9=X#47Qj=#!40uOi8cnlBEfbJ1?1Z7C`)?s)SCQU)=2oUUK5 zw_H8*Ku$1(tpAR#sEM8)58LuDVR~ktw8Y5^Xm|icv|5NFV}Mv$0M-az7~^8@JIG41A_M6S@K@(g|f4!zx}lS-YXY!)B1ZR zgq4j>Pez|aW+k_2KMF*1SZ3DPiS{0=pC+L;AhPRGo%U@`9g+P+i4y` zwXe@1eXuz8XroyNB`$N0sfMs7eCouM6eC@~- z*>{GDjFdRy_qtY_f^1f=4z}f2nZAD27k?-Db@iXda|iMctA71+S6vNd(pi$&vZAD) zQ(hheP6ogL4k>Opp2SaAygTa?x4riIqJJ$#I)HSrx8sAf!*TVohl5}5GH(L_$s2*s z5!4mB1w+A5d`Opu%FKy?0|YUfAS(knHN?lz$$tOsuVE`V?aS9x?-?Cc@77w%b4%_f z>c@j$eFSztq*OwqW4G zl0po_z$bxlLc#%?6Bkz#N2^SV+OeshJf=I9^oe&1LNCO5-TnNCP)ydjrv$Y-gicQy zM7vZD9%hM#Zs@L!$#d?u&O)JnfC`kgfgK+`L5c+gG+8cT9>ZcK(f=u8QJX%QT~_)O z-^r5G6caPNCL|iSUo*e|gY7YvZq)j}|GGB6e}gKEWyLx4kv~iXlis+|UwFh(w!Sz& zPh=e*IPJ#_tsVA(0g@*?(nO*Pv1S55NWkVKJ5cc6`8~r?oRwDtJd2x1Q~xp*`U`!c6smFGOtN@ABvsZBSvH2M+w&(lLyLS6R)MsmxYB~fB}$L6Q+)1EV-cX zi3JC89FT}Su$;S@5*~_~?V>sGYbXh{-P|fF&B}+cc9TJYE~WjRxrx+V1h<{D`o1;M z1WiS8ir66-0`R)xjN&Cl!N>RuLHhFNND(}u$$C=f{L9v)3-kJfb!HW~tt4BxMp`v{ z!;0U1AdlZsV(n7yD_b+Mj>eQwEx`(jib}vR=L8`gAe6B90@U)Z>V zUI6{|58shix4wv2wU5(-9m=PVoIgMrj3u#XMZ(~F@aA5!kCM0ARx5V+=M{Q;!A^hO zx2#$8uIE_f<_|ii3%A5h#G~eE_`*SM|_P-DVK@TTAb&7R?P@s7DUM%X0i4pj(!hJJ3Oo z?dW4(t`){KW%?MzG#h1jy@D$yr*!JEyradc$8hClJO>2X1EIZ;Vb@J8jtH4 z`REh|=AQaa^P_9Tm&Na@y)4^k7W2UsvpVd#2vEY5cGhj1lY>Jh2wdE;664~}`GQYm z1{>upA60yFO}yh>5HmQxdZFGc8gL6gRNq!M$Hk*n02Xp!Ab=YNd^qD;kx^i|pR3Pu zdf}dqW}EnP7cNANE)b+U)Fg6z?~}g{uZb7t(SJ@j((b8bRp*o^t?MUMvv*C4^siQs z+Jbwo+3b=xu!KqYLGQ+QU^;bzO9jV_APR9np4%UT;0AY%qD+MS@uOw^)`4q>#11EY zuKB?h*2eX@MiO)lVK0QP2=X!tfsf3vO61@k0fm8nZFU80I|M~bhk}pjd|dJEZD$Ek z7kbE3GZxP7%{cy~*tGBe&p{XUt^E%NgR#QB&v6$fC>1_J_pVj*EGyx|dWD((!Xzj6ZYjf8T-G{`)nD`C@$1x8#s-_WR-)hC-roCH{<7CTTrjfanGx z>(3XwuyGDS6^5VrT~^}fdZ zKnRTh>Y*nhWKy^=iKHCs{yIN*(9`Y9{UyT?-Abq=KpYvCFn|T-rG^(vve-;m(TRCW_;%e`6E;YHOKCIH^k`VPvQjPO@L{c(do5w ztVZUt{Ab$>x-?|K-qazTM=$|s>BWt$KkriCHc*`o`G;!YKz^ddVok7A+GAw9!+0aG zOorGt0;$;C+}tJHf5Lh5?R`z;~G{4`pskk}mc;=ph5XW#$>h=hI)O5x`gYRQ{03EfNh;6$tqL{kFa z5D-r*QD)ZyS!hlGc2bIA`!cbW5~de?SJa`~>p$r5GJFQ@i{gnJm~USZKgn-BRB9B& znfNT-vGH2~kDXiK2?zW+qSbX1b8l`qTe{`Uvp7PNVbqqh{9LEuUG#a@_);Cm?$WMl z*kO`ERaGJ}pSxxSZwqt+;BECl_IFqVPKPd}hv-8W7Fws>xt}JqYj5~-b5?~g(eu565LdMjlZBahgBs|MKZ9kPcN8z|s$emgOti_kr&62TAyi5!uVvge|>_fAPk z@FDLN3jMJ9rRWXIZ>~RAJ_pn2TxPyK^-BEmDUY)ycnye+Wj`0;zFKla(KSli?sHOq z)zH9Pv+oDxw$*du`@OMsYY7Pn*<=Y_TRZ}Hl7t(h(e~)WLlf1HjWk2^ zhJEWrAIjo|I2<(z+#P}&d=kjCxl6_he*(H1=v#)HZ^&Zsi;$UeUNUQI+PnQ|wc+C+ zd*uH>%;?9#O!YHBPP^;l;UI#SI=roX==yuamm~Z_?D%s^*bgvP6CDwe>J3{t>yy!g z8SSL$K}n~>ZRd>15*U@0XpYhUjn5(HQz74@&ll<5O`?=d9(W?NJCc?>h{4?4q-*HI z2W_}ga7X!$+$m&vrzECa#z+{)h;3s;%Y5PhL4q>&TqXma0kHY?%u|c+n=5Z%)5Q4F zie)nhnS)HOo5-PE_oFa%U!7u)R>AX)b)(z$8Gy&Bs})MI7W`JEZn`&r11oibj-q2A zeEYy8`$tAn#4k=eU!>_ z?k@r`-$Q|Pk}byIa{K%$p|wXtM?(&Y#NRjL*LQTdJy;uW{;$KwqeVrK=~5hh97U`J z37?+jT|chg3};O*lhZaIQudiAis+=v_SV9R{4!zliNhK?e4cME|mll@Y5`*{#%$^7)js3Ea$*BU}-DeQ25(_V)k##+B%3&8jP4O4m}hK)Z`8c zt3unj#r8(28Mrnbga8o>n!)Yd7Mxu^k5BH~w~~zjU0q$nix<8Mw&B3+SEZfx$*;bZi4vbv2X*y-BB0d@X|*h&#BW};6>Kf@3rEd&y|94YAtx7v5C?RSHkaf2IaBphl&}) zdcBXdw6tQic!=aNyq5T-Uz8S9#6Vp51yT0xNu!kU7CYNG6tkDC3*@lwMteQzlKnlHW1E@5_ z+EoHALvIb)^Vn0j+lVyKObqy%>+U<(#2ewre3ARY7md|&l?Yu;Z2e2^CKkG{px=1} zGfCx$Aj~#!fK@7trD^0RO)5CLFo7wNj8?s`MA_cqdISP`&6-cFRCAa&+=jirs@t(AE}t zc=9B0rglr232>$XAWG2+!5@J`msog2_H0;Y+`I3I0%Tr&`rUh2Bm{^ zdLI7ohg1{7+7h}RKG4Z0d^yhpA75~3k>9GbmP~~m!f1s95|R*9vDCssKJk>-Svw0v z$&Vh&zIr+LHyhcoUz(A9quHi#d!=Ax*0~w?+B--W&#O1>#;J{Y zNT+v$U>N$Gxyy`p2j@Mh<1Ep*L0wCeM^5-niOL)wqP?yu&AJYe~!LU%hHeNlnGZNV@#~ZU`~fr$ugbpn*N3-EKO1UyTdw z4Pmno@t@Ny@`Qk#w!osDYYv;pL2<>m*pg^j%q#fCsQ-011ABrw8f*Ep2VWd2=Z4VQHzh_S=-I>oKCz(vHJTbfqeqnfCH#frkTQ zkEEM>-P5V4Q_`$tYOSdEm{j?^bYiI7Jiq+OzN(R+K}UVX|M;)UpT1pwH*w;Q-$d!2 zg9ia67HawY*T^{dZ9KNW0EhGpt0BS)03zG{nLkB3xiu`v6mN1Xt{^-vC^*imZx z@?YDBzfo)1(g$(~^PC=sW~re+%w{gFtHcAImP$ySFaS6ZGJXVHS3Mc_*>k~AvK~!m4Zi)9(_p&Yl(a* z=v#r3rljo0K!|r%+)`En3vY+=4n_l2q&eTM`3|;ZY+27k&o?O8r0LcV%xR zie0DK)86M1nwB#8G~V$UY+giDan0A)t!?vZ5Z9la#6LT3t(Q<#skd-NoGUR_O4xs? zSB!NJNB?8PX34KLOzT_iS955{d+%kw3C=lH#zid%ClQDPM{zlM8uFdD0TV(Ch=PnS z0Ko`@tJ<`W?7NN@ncs-cx+Lyv?9^*u|9hDu?`%fWh_P58^VWU4igWJ~JRbsEK!*S4 zJ%YW8^4uf_S)maqW=KL0mpO39u2%PZrs%|oa}plem0y!FRd_W{vhADmjQ{kBZ$?pH zi))F?YV09ps8s&KGwYq!;(usAKN+|3`Y4^}8Q=C*>%jTTSv^NYY-NwrlLtYL7K*qo zNH?!YU+l`cq>{61kB0pikqt)F4VceRfuWg%1bc#rftb8R@}VGk&`kH>^&CY;H4;x01dPrPufN_<+ZzDxVg-JjFd z%$j+py0jmWZBy!1I>~0|DlF&WvD@{U&f&bE_%r{Zxy5r$7fy!9H8@yQ&E&qLQ^8m1 zFj*^GcVEiX*1$)+gZqq*a_jFe2wYLkm}?kb8u-~5yZwnl$U8elPLvm5;FW2bv0w1n zT8l&HfGvPuGb#WELcirwS_*+Q-ui(tH5DhD%tZ~ED3Srw9Y+KxBqDNStXx^6Z~Yl_ zT$|6@P8qpI&J>y3_34U{u%KYW(z886y^6a3&d;4gaqTwf{IM|X$rW}}XdIC=Pl&Jy zR0&AR;V$td??4Mts`g~9LvvA4=hKd`)QH*%y%dbF&X$i~6Q=#P9%gZ(I}6qRB4 z^_ILZ*n}i1ffTrRPViMrOUwO(eTj8<8@T2?@5A(u8@7!|Nt0dg(1j~NfcfYRq0}PU zs>b*|zGBmJT@pohLOIoTs2)Tb19fN|#X>9Gqd~V;7 zY>)R&Q8Sesc=%if}pv1Mv>UDucI1N zK4NWA?c}ddYOVCCeX-=a!gtK9&co5$taxxEY|v3V^yR0$r`OHyeyPf#BjM|PsaDCQ ze#-U9?=$X;_Prd)%5aBFm&k0D`2ECkUXYv=F<(eDL7%`YQZ7g0=N^_yyU)NP=*ve5 zTLlkicZ!pvuD0{iw4rBgy(HV8J%f&bkWyde+5t{F$y++nHX$BuyogXO}JnpU~$ z;jRP0T)v&j+;kMsx3R^j?qI7`J1O-sTWwdO-(jclx48q{>U4PXJ37?i>+2XBJJ7s2 zEkZ0ghMv3Y*r~O{%7QI|%<7k-UtOv>ZQo|lMecBXT4C+0dXf!D{S|i~qS6qF6yS!x zLrwb|L0nY&3;@I&nFsM9^Z_~e-xf}gl5g>;^CxB@ZX2TmqaTr93LOtddFY!>JZnP3 zM|_6uJ9d$|zYnb$Z)Q+1PO{-LF;4mW?GUp*Nn5Zsb!9|hHGk1d#* zGwxt+uZ;TO3f`0E$!PY*Y2Ix-3|F#G=%;G&5c}lq#ocCqx|Ch4RT89Yb*{L%Q6|u| zC(=W6d&{x}V<5};1=-7#+6mkaQjX25(~jMBKUU7G(>!(P$1?LrECGI&mVp4G(a4|S zL?k44uRTM?8&w}4DO6E3Ovr9P29fcQS?&kNax$x<+J|{A>IToG1Wdd&TXRS;m>Yfa zuI6lW2$Sh~iTgDBX|Q5@k|)6dnbl_N=VT1=lxdLUC;{wG=nxBisqauVLM_O~?^u(_ zMS})f(T-N%{3>@nhv?JN9+!IvdUTzHDwbQ1VY)Up(~(p#X8%RrN1vmDrvuQ3D}Lesl8; zvD;o@IIwy7`99w&+K7#;(C*;1gX%m)u#4#Op{#?*lTr%?<)qa{GC3->cXkZsM&e(@ zJ@z$S{8VYfrEc6^c2~Cbh~l>Oh>+)BKJ2@?Sory4!;j5n?Yq^sy8kxW%+1eZ&#O-N z`J58Qh@Clgb@!oa0H6jB4(X&-_PN*ZTEESs@>|pu2E19Ue_z({hdiRsdOzPYhZ>*D zTqJtDi5f)G6mnC_mw@lAV6yFh`$0$B zTlF+hsI{q08^-OlE2lg0?lo_Qd3Xy6jM)usl zJqi0q^ruf0uWfhRdI(cSbA*L-v<8vN6bg0~B}}foktL#vz@d^W^sKv0zKSL?Q}Jma zLT3N|{rX40^V4QA2;F({Jyd~{aFBq|0R~LC7~tGM;2p-k!)!6dd6K4&GXHkf$gCBv znfGciaH}I#`H`EL^qZ+EF19!EKRod~HmXw0o)5dbfy07Aif;T56WJ}K;+|yFHT!Zg z+smoTw6tunhf(}qpOZ*bXTRz=pVw`(Ice_OTli$rJHs{Cw35C^m?s8vgyYl-{>VW? z3ycM!T5Xu?eg3S^dKftAb0u^Tqa%8F=z;;sagqn#FIhpdVNri`hqb}2uZ}L87Y|!i zJxm*xXQj~8T$jCSx_8fay=S-+CRBs`mXZR`WHQw0&m6gI#be$ZB$yIhcqY3<_kFD_ z1YpqI4@`yPAk~6KNWR@*Ra4Ypg8sk`X;643h}(7~qN>eR4S;3ztEM^v@XuvuPL@ z;h{#2fF2G#EX&6DT!vzRtg$((F@5F9Z-KWG-+dW;mhzw3j-W8?f=F?eyv`G+7UgHU z#oL>&`mZla;!=-*#`R|ZoZqcO5*)D!=d^Wo`^U%2X5PM)_I5lvwBhH)!qOF6sqXiV zEQ=#fO)VpAR*#Z@RzWIDFhNf%vy-+hc&rKtG4ft7SBtl>+E{cJ`v`7xZhOS{Sj)w z1St_cJ$=#T5Xf!aSEHVgisPme899(jl@Aqf1o7S}0bTd{&70!=K{Yvd z)4Of|=iFpu$TJ|W9lDzr5DOhWny~MbEw{r*jT!P{m-oeDdwu5|Is0N#-Ca0W1hT~> ziwyU_MDi^m$LO1@E>iY5aR6nEaBCvQ2+6op1pWg`rO3mFKk+mE4r5LJtW_g~mtmm5 z^0@05b|f%^Clq8dTugoNKzRK&bF7#l#YS$2eKo_|O#9Oe2``QKbIWuoNjg$A?stg2 zdo>fk?$X;$o5Z}vUD~!>TV8T2-21={4moIG?pFX|^_YCMXWVZ^TOuQF#L{?6gTb6( zhlPFDMOVsPGd+t7tF$fFeREn5Y7<U3zfk2)e$uQ!T%rBdnHOLhzlS6LXC6 zjG{%yX%iDU?08NvH2gN+m`cP~5-kS!3#^Y_@Pg$UTnKl%j#Z5*Xg*tniZ~BHx&>p$ zvu8Jpp6ihW^F{#2hP#WuX0*w_{=UOC3k$gq)iu;JDy%n`O~NXKt7~y4i4=dlVVF~~ zc$`dLk2^G6Nx>x}KKdM=Zn#cf^7(BTYtU5V;21oIdgh8**r!C2u*ctajZCe6)O=&X zu-)C*Lwe})v*NgSx(^|&fEtVBjKU}q`3R=nZMu{3Ukt^oT9aXaCL$<^5K*`lF3#M`xpQ0ozdbf-jBjmg zObIyk&4W`A(O6WCK%#;6fH;P(;|+!PtIeAHh%N0nWhy)g`Za85=kYqkcW@C`7*s-$ z`M3tv569jzV~d78ZB8}wvQGRe&$7+gcdzPi*CCT*Qtq91uO+g${yyloeVL)RPvgga zJ&K!mzhvg4;qRYZYTzdiOgtnH6&2csWXN=!GQV}_llo76)vcF>^?%917)uH zV&LIU@0hA)i`c(Ss=KZ7smvy;|dV=$R4!jw#74 z92hKR1003sM9tFe9B|Uihk33A>)`PXQ@(9SW?s<0Ip*4K^E91|>xA)J>y9#4CLb_dy-o=Xqcje*XfjjZdYt(Wn;+26C zO_FL+*HP`hn$~vxiw>Hcw{9aJ%-8omC_Ukebu9pyz`yldHc}So|7X-)&y+r{+-;h5 zKdex(<^rqz0JZW_U%bUlKWoZ~FlhXdoQ)TZb>(lz7?tC!#nmBq0jCUc*#BRdA-grF zd*<&6lJcRh-;2$<;3-)pojKBVifcE8!X3XJf(>T3=n~oRN)4SSxw=Ld4GRDun`IAq%408o&+ekim3aLhETN9*lO9a zon7NPV}GrJ*6S_j0hQE`j`8h-%;7bGQI_wK^JG*yjMw&Z(>hP3;EF1u|B0Oh!0Vv6 zp7UhE%-@}QJmtXyo&(e#2n|9oqBqj#;E{tXKwM1hIrF&5-M!iLrrq49Siw* zzL;BYCYYBpvNM$1B6hD1)8f#Hp6ps3U4*TZlaVab85LzjJU;wp)-pvYB<-C|Z3yq* zgQk7|QIM*|LmD)L7$|HGCIyIweLp>?zDDR#*z_?ABGvmO57c6Y)1jM&&P<42hW9+G~q!g+@gdpU?WU8rRuM^p#I! z{A>^~eruW2D{A^Ts%+38^NY=f#0U^2ENRk)OURB{nm+N%iVD$Lz1e}h5lyr5wMd?X z!VrlQIp7hq$g6d+=i)YL=epsto3|I644UtQa&=N~)kYx}!SG-)Gtz*<~L zGos+bP0C>EcSohys(Q=c%_`7oWLr7KMKEb<)JB+`K`}D_yD>EK=+bt8qv+DMLoCDO zaZ+okSCt*n&qNB-$LF{4(~9pb5D_c3wnR8GAP;~&}`V9x0VAo&SZr~639Tt?syw1 zZt@q&{d1eAB1qU-3Mud+VGMveW7`zn-wzEw2}DFZL z7SA1YB9?^u=4LWgH^+NzrCi=oztX5Zx<^m5>D7p8nC+EI48)>Ao_neH?_(Dmk?oEo z-C;a!5W*4<4$SW;Fdal*0k&hl2BCYxf8&_>M&G@#w#f^1o(?H4 z&DfRc@^E91YIq5x3StsP28ZG}SfWWky4NDm3tcE7?p^mI?2S+lgY^QT2Fk3ELt|U8 z>5S&6WcFhwgT;NC0^1@jZz^%B=RUa9obi~kNF<@-5fB+;iPaeh z>8})|4_5-qiEvvu1E7&0h94AK9v&Xl{q;XCQ?JcyT+V*gd#4UyY|v4N`5mh}O9GfU z6vuPt>F0$$aa(<;<$1)7{>Uy!%i5Nk3)}yHnQGBwvprbz`Oweb*<#c`cI)Jn_{h z-L_RwQC*9ut5w=7M6~6nk2A!yU59c&rFgI|8g-~`(hU?l{DegmgxbG9mnN~7&PPj`Pi3{ca3r?Hs8Goga6_^LX z9Fenrh=#mCPMLFy=Mq=%#qj54a17<;sc47T!-fbsNs5*`iWlxPB&TRsEG1J3Jl)YT zLW?K+{`t9;_>$^R^K$``9hN=&SoUoVe`!<9Ox%=Z3ra!n3tLZLZ?8P;l(1i*_mWv` zcuC}#R^eO`JK8F*&Ku*wg@X8N)l;|05SBa>L>sWnmf6;0=bB`=QXpI=M06~+nWNdk zo7i}LZTUg}qBsfPPQRS~{gxF^S$aI3Oq}2%&h? zOIKB+Y|-gwFD$1WSs4PfWHJUPBV7c@0)tzxYMb%9oBWL$U$L=zcp={*waI^D=@z%0 z+rlbPeSEl>P!PBWs1=gtfz^6AmvJ<((;e_i*Y1_ZzD?6^>&`DvK^{5Qu-xBysvtJ| zty}i;?!k4FWSdf@;?gdGX!#0%6Th8bot&yh?xb|j$RR-VO7ntnuiZa#|`Tk=f?@gcW=d z_*-Jn8oU1wTBJe|S{LLT<;=F0 z+~TDEu)JVH2Eb7WHt@&(Oq>4+2AbZqT6%d2XdU=r?Abz5?gfkuzTiIV4B#QWODn{J zLELGcgv|Q-^Mfi26KLck@tC1^1FBF(E|--2DKvcBhM?Ns(+s7mlBtpBo*)q((K}%J z+u%K4`#nB5x|m-cGfJx(XT)@^d9@RRf1_S7#bugU#(<$Kd& z-z4n7p41%5FQ=KbumxD z$?ciQXBNhw6Cha0QKe*q|)R7 zhNCvl76$*P1+abJofG>qpGzHWFyTl)#_})l0{RU`f`V<>0%i;{k%dfd_vz}b^V*c> zqGFWAc#MiyKeRg-Pw*TT3VRSmq9i8yR^Z^-PV`fgKw$l#dm>g=`7Jn^6Jwjwq0EgS z6qBMM>b-l3NF>m!L|_)sCUExy0}Si|zc{maD^XT(>#>xsdEyN&C|nHhrt(Eu9p3~D zsX3j_@#Ak|18`0R{SOQ%;Vk37pp211G^KO$fnK-xR)8##OJ4Fil!Kgb{O9+l+^gT^ zo@sMWE>u!IhlzpJK_+U5dIv*+9M|G0bBYThQnmB@EtS2q52lW>#L>s|u9zK-FB-XP z8IpVA`PqLQAMk7|TU(V?dNI?~YJaotBU*dTJ3mTt2&P*1?_m#(QQTfZ$H8x#?)~;^ znO?0^<172IA4Bt_TVmBFyA?2&SIyFgw|ud$2y4=nWn9U%PZfi-VlkdZU|i>60^H62PpC+ z5N0`?6Fdc2Mpn|v#rXbNw4|F$X&Kw zwsX-H=EVu#Vo^7n7F6yhSdKnnap*GGv_+7S_fqS=!s6n?G~@(ZIJ$u68H@CgFHT4z ziP3-2n5|C@qv;H^!%io)Etxsc^u@ulI zFe>a-LveuOq7S75PZ1u4~{C;^sro+r>hY#F&J3Op*@!~1ls&H@w3Yj|; zZO`u(zdO0{#^&Ke5=ECEuB_XfPC3Yj{CUb!bhebWZ;lF1Y;11lxVNSnZgJ*|2!3^) z{FLNm3r9zd)k}TGPSvOR+p49ct1UEdEL5ImV3yrF75u8FpusZb`r%t4kMAguKGcn* zjIQ}PrZJfctNJdfhr>s@d|+E6gn;u63aAsC*9 z;l}HD143^63cW#qY!H$4zkjbGoj!vv$Is1BYc=mddI0nhJ9>;HtY3A61Nu$gA+RRPiSI(8pa{jWfJ;a=}GbdZin%Q@i z?tJ);wC=~m?rk4qGDRrK-K5fc2!ZK7SSWrx3{LvepG}b8v+;D{EwTM`&W}t>ukYKt zzs$DSg-K<10Dn3Unsm2G9%B3)Z8IGaD>OM{FXS*Pi2g)>1J+`h*l~_I)8=vehPDQSGJ%2yE1|rftBs zif+WYr+gkdRRWj>Ku9JJ89HR^>bddA(z2|8#8OE@@!OX#dbd87o_{hxehz`!2z5|C z;w%C-3m1fRr_M~|-MwlIH)yOfc24_F_j~_g?sAKIQ1+-Kz-MG^45D|D=1uX`>6uiRZ?Akj z6~O#>I$`JUHAAn=8gK50%M?H4Nvsn(jON^HsYQ7Bqi&2P-u;r0`R@!Q;S4aA5B+A; zXYi1zd2UvC?=y2;<*-1CH%7@5?o+(b1Y3+g)^YaQ9d1uLl96}z!1GI$LPG(`BouvC z4xfi6UsJuV=rPc}-MF()e8mIuy<44~(kIzOfJYFbVJxK5iDs)YI6pf(OKdtI)~#bF z!6XsQOl)352qDn8W!Q?^h)7xR&t^Bat|Cbff>A^|8WduG@y+Ao-nVfx1(~{vsD5bV zG`>=+E7-ai<&pnKis609S@FGmD()t)YxeqfT5#9+=~w*-X-L4n>e5q zd&ZhgMY0cMb-HTQ*SbpPGcIykEI%UsJ@_oP=|je$n{*@qxL_XWSwOLpO|X&rt$xNh zD<qy#;qYgX|)dw0cP#+6kaK0ZDWQx3Bt=F4#H*p=i2M(oZ2yGZrbUmp5 zdGU?dh~|58WmZzkl5<&`vv>ENsHUE&by{iT{_7(Wo!BH)DJa52ax6i|E;dIHYysv~ z02A0eVAs}j5KN~8ty3n+uHcE{M2Tt*rj0?lw&jU+r_iRTn)o=9T)hv$x2Em(`JQcl z;PAYF_RHIe6$i;d%L->$0lI;KPRK5FYF2ywZ))I!=w;RWWT+66ri_5Se07GYf#oU$ zcc}!m3q%IpKMh%O>UoX>J=~WPas&;S8cbNP7K#!hNVPG*VeA8w5iZ48=9TFm@P>x7KhRsJ~iA}LWywdI$%?k z_4?-DGI+Y%p%wwq)A0At?}pWP=ZSaIF2g?w^R#ZjGX2h7suVjXOUx%OR4;}Gj2W|N z%F`HyytKbJquz8?R=reFuV7C2^e5f>>8ED4BPxcpK=*19=zCbTqVqv6e7u??v;vshd zUjRxOv4IE^2$(D6%B1ak`|-(+n}X{+Q#VzGBMjrWezOx@Fg$%E;B+H~=D8C!^!4@S zPaGhe5T{OQLvV#gX=B6JSyBMtA%-Io0!Hv{1iS|oXcycps#vC*si(F_Oh!yByu3uK z`$P8e%dZ=^*G~7?>o8@FNiB%i9?)ZGdh^h^yS~7GHoKP>1pt5kl6Xooc!3nHqLgt~ zR@Q%d=z%h%#!8tT>^BW- zgr;8dO$M5YKQ(Qs>hzyzqY{!^7tT3+&Nad#`EnP96hnH2x=Ox8~-CHas0zn-|5fs+G0WV4lFc3 z0&*^peP%;mlVvoZKZ1GjYCf(AL8`T&WaG6YkVE_dh?w=hukstHI!*S$GaW!Dkoe?&UEM9vYr}Mtrv%7a}(yqAwY-vxrO6zFpBX729 zqdjfcZqOy;^Qc(UTfV!n?1=oO+{n6@1z<5XH!I;?2ik-g5;tAIEaC2rBRvawJpf=> z@YGLvzz%?Lpht(YrT@8m7@tu&0hNMC32GOR3=CAbMu-F}OxiGSLz4>4i+IedHlAHg z-CkU~Nk3;qE0S!j8zh9fi1qvadj(7{Tta(63RqiPvvA8x_Hc$bm4j$l!;i<%H7pbm zOcs1sv_zPf@UCMXMo1{a%a;g;e2NeZPDq(DZT%c=ZD+@QRh5!%B5rKplSuF7YHfM{ zY_kQQTgA<1j`Hr53f;lUa1TcWZ{jZ>y0H36R7@xifRE;|+$nSHT)NC5Rd`e}8Y@uj z2Sp-2DgA!((Wjz!)i~Rve)-OLK#}FUzmIwoBEocyYPz;5NJwi+!xj0AWwE|Rl)`X- zmX3Ewm+HT%v6b)#??;x&z|S(iXd+<&J08}{9uV`+ETSoT9NT^i0mmO z&%tc0xtY6!Hc_ZF=HV;}%*=?Gn4goAP>$b&=H-NlNM>&&biZ@x zdFOwp)|?kR!kVIb0;FHUF>qk*{Sq=|Dpr^_e~4_1ZTg01Jrt`QY0;~4w@0R&!JkU% z(yNrAf?B*k9+A?@Q%H`yXg|)j!;)jCg5Rp{-|F5unQp2#lePgxZq?-D@0p%0*$B~s zIE@by7yopB)f?pVoki0^gb&oEM@S&jj)fvbP)LX%U;~wgu{0n#BBuo$eyDOtvOYJ} z)ouIFc?-mMui>ck+FFH>31D@IU96opn^mvhH>u!x#$zfjAG+D3G3%g_MW2Qk4bSQR zi}*f}v9RnqeQdL}_3p2ex*8hynk-H4QpVHYLjA{AVg3G(%6f`FA*3_KJq#Du_(wLoQrrASYwSySdDI-|9{7gerZ7A? z0Df+3=*Ud^6M0ZN(toV@N{Bd*5eXZQ%)J#VX>T=eFxNnLGt4 zQfc^NnZDo8rzoTw6Sw0$sV4iI!LG9%e{&T%we}u}0JT#94Ey_h))XP9YFC(vR838n|E^wJ z{hw;X5^n} z^Ca4g_hr~@18o@^El^d6)g4fCVr@iBD+uO->pw+_2(e@;h&8K~{h}qI4taO(5x*zhM1BWH(_g^{W@{H7z|o z9B9J<6(X7()$9!@MxsejVeGou`1Wm}&jH>50jkd|Q&%r)G_%+W@AYAd7_k~=;&JN_ zzT3;*A_U+PbR&35Vv>1lQT$R|+TI|5?6P!B6FVS6Vyy&n4@`{FPUhY&R5uCwWz@3D z(;@`j5zMmxb1<|^vFFSC_yq|Ll16fwXG984Nc84k zKiEF##BfiRRT9`-ln4!Qxn!ahuc2aB)RdvDznt}XMQF$O^p8Wvrm z+J{~gP13mo>n9nVvYi?`Dt^{oEQ?V=&X;O?_sOTWMSQuR&S?l={zZ9^<~_rw#JwSw zH)UC+A-DWr>Lsx(2G{}A0~7~r{++>B_~!Lv9}y07ZPjPegWlte??PVN(}2w@zb5Qq zHZe5WbH)Ep`pn$G<|-4BZooA<`Gr&(0bpD6I^V%NP7G7H-6oTEovy;o0Lf2sXVvv{ z?#etmx0SJ1u-Fj81@^?BySmGE(wF@^0h;crWOB>ubxWFXSr z@FPOpyc4bB~0}G zWx4(yyu(Bh(V&yGfkwM-aMr?1k}+iT=!M>u0>N|RZv4+XQ4FzM1or~|)bRYZv9lvn zjK+=*%0sl!@Z`W>%%Md8k7|!?KPqqX*=zA2vSLRG9WZ)#xPcHv$giFQRxpuek5MH4 zFGq(^9Rod^fp^ZN1YqRAh?^GUw1l{-*WTb-|B;|T)cm6E=SOxsQf#yGNbox z^};Ky7vCl|s`Pf>N@}vapPJf$Zx4T4Mn>HuGgRLlv@6KR+pJ0r&`;KyM?wHp?ETvs z{0_n<83G{lMCQ6|i7Dsw)27)bXn-IoL9Pn{g%VC`py7h3`NM70KB?PcBZsDv((t6j z<@XA;OU+V^Fi*+R4%Oz4%NkVg&AD1yuGY+;y*LnYaUXeO&{zR*-3xdrB(Fu*Dg9~s zN9n4#ZBhJ%55X*NFe=Drks5^LsAPS%>v)hHe@Rg$o%dd`esU<;8P%*tREybFh~k1& zblIaChn98*%d+LhYD8}h3098;B{)(c1Cr6Sm;HC!Z0g2-!#h!tJsMs9yNa6iO`KIz^vEU229stVI+Q8- z@CU6`t_igCNwtGd`RMP&iJq)}XPJ4yr{MKP4r`?WYBnRkDQAv5*P{YKvV(a5ktPc6 z0-T1F-9Mr-lG4VMDGBP)?@X7V*)9>9qqmASGKEOe>cPks1j3xi`PR+9W}9L7TXd0% za5jX}x6y?^^fL|(!8*b50Z)donZxve2ZQMW{?vHs;7s9)V~jX3{Mt~ZnhWuf>U!x* z2kZWLeBY?*D?bVwB7mgh2T|?`ZVpI&{~RO;HV5-A;9crq>%f#4D@(u)hzP-?4||0~?=iqUo-#7>+@za2y^r;!p9Bo*wxPxAu~ zr3h=1g;1WYE}#N1RbV7=f!clhRAlXa$`dwm9=KnCh&K{&9PTzaBoO)Zz&P>Zf|SIs z^z@?J6^?fSnX3}}x#hhwm?SwAf}#xK+Iyb_?C+iFtzPnXt+mZ7(dRWnnUtgmG4_qT zsq|+~i{OA&gnkGr*RgVdlmOE;Fc! zZLru!(Ls@9Q>4J*+Su5z`ZTh7F)e&c(nj*DdouKY41e*sRkw_Q>j4HQ;bccFz`fyH z_b*U%G|>jI;gh1G18~;-`7`@LpkSPm^TwJtdWd?AH}LoZ-w&PRInkudva+}a#%n4U za-kQ;++)~LN#zl{k+0Ckz$3GRQ~^_L0_r9Nt3bCfxFRTmP>0Zd4GB?%KP@zCaOK1; zh*E?V2aX(EG*jE|pi@C}d_ZCu7TGwO9MoYsoC;-S?l=JujP!t+f^ZYXXbcNj!D4rc ztr~Juh-Ey8|B%L7miFju-B4=HU940q@^ArK}!H9>$)0Z zDGxEUaK8Auad?Nt+4LZl<2@KEGRn$;!RGNl?akJ|Y5vZ#gf$e&-G`wgy}S3oq2vS6 zrh5fw!y0IrjvN(cVx`_^E_n_*UH`iOX5?FoDCldzzkG&<0sW|@5aI8sqZ9YV!9(gIb9|E4^`Y7Qe0<>w z(X9}F1!x)=T+VLd0(6$>a`-rtebfiK6aiTu<_rhbdWY$okzxG!*N8!66s5o~6EU<2 zH5*Py?v%&zyZwegrEka|AF)@Ylp`8`cyWVJOVHMcyj;TQ=c@njB!|B83!Q5rX$n`b z7X3Q(8EbhcY++WMPd9oR+<0)9aK3Q-u^7U%3z{;zVuEM==g+gpQ>!-b6)u-qmGI_S zpSc<7%6=8T#noqbF4EJ{fj%o8Z-qr4uu42k9fc^v))t~oX@Fp>X?|mM<}-kR*4Dj1 zW6)B-1|NlJgutWWf&`B3+qWd>Ah3i3g=)ENbL{{xb>4%9qtJoRc^y7-Bomr90Ml?O zXn|=hSnl2*-W%Tb7MZ%?@o-d?%KG)f-AdlEqfc-L+3Z-Gz-FI?l3Y)8=*&#g!32_MU=n!aggc3BO0km^$x~N_v*qiUR zc{#CgCAfZ>ns$|gWvwA?b{qLmg2+jvO-Y#QSXo+Jq@pu!IEeP8sAdgZ$oia6+A|sM zAbMt-EUENCSq(Ry?(L0L2~vW&=kp49yQ<6v_7Plf>xw?lJ2H=%no5#irT+h7d=HNP z9I0(fq}V&$xj~(Aa63#lw%Xda9REv(UO^wd1gKw{Il^z=u)$YE==5o6?vx$06gljd z*e*F#+~;flKQ6#zf8)tlbNe3p&MWrz^(H=e$Qq|YvH#BLmCe$n(OPGdrIeYm#aAbv z7mF+g=__7mSI{tiW*}sh7%zNx@}tq@+rlqD*afsi;z0fF=xELOmPc2U@Ss_Fw7&R6 zkEMZucnGCYRGE4SyK=v5D64|g*5VndOXGe6)2r#u2cFY^)#o}DQ!-m1^LX`JA0%wk z)njX~Y8GOSu5{zJ-#+_w#y>&wZ~A8KnVIA_Be`iWUIek77yCKcU+Qy3H!Q?TAxlev z!b@C&HHypQMcl7n+#vaL$5H4T-t`(*9SzNtIuDrT>dQGs|A1X7sz%Ff#~Fk6SRH4{ zy#G{-EK|5>Wt-+@yuPh2jtVqxA7P2y8))GoA{s*-NK8XBf1l!!6+BfOs=1VYON*#HP2?Gx^{!iMBU3E|@{ z*0;4D{?Kg8;Jqqdh~FIF3Fi5Vh|0PEX^%o}ekD71;kjac(Q;e_fQ!`7ccJ@3-!(%1 z$70Fq#4uxx39GBX7+0BDH2dj96(wlYqOE#j6xdD4cHG+RnOWL2yCL=c!1f!j&2GOL zOu*D48T4k52`^d=tR(_y!{s;m86#@ATITUV3*~9&+Fj;5TFt8%t=+oKjN8;UFM*^- zY22>Nhl7&LtsL2@O?%a`(Tn)*|1UN7AG;(%6=P7Kch?l>}} zh9jyJ>I%Xd3=d?ks?F~n!i*2%4-5-nPYTB&F1tY-AOcG?Eo#7lLE!E#N&hm#_vl&S z+=ZiG&}F_wNjrbTn|1YWv!#$d345FpmLAxb?mBYh2%r#n;{w?_6to>ip%}TKk%oW< zciFpl`7d;s51L=Ovj4?b{+rDUK4@MM`4x^ACpg?DA4JEB>|&c(|Wf8 zU1jK3xZ^@$0EBz#%Efhpf$8Ml{9$YTA@NwBrSdafRWrJU-%||Ae1Q8BC%nC{?}cH8 z4u$kPXn+mkF|`k3Z4I%D7Nr(RkW?csMq+I4o5H>mDh^oy&~{~`DUz%Hd9w5OCi@dE z@DyaoSLpLLx`-+dA|U`E2msdnuKZ56ir4mfdMDA|!~R1f*!{)LYyT}K2zOgZ!=X9C z97C>qV8jqD8;ZxXROMfk-A{4<2mAN8`1L8)*Ly^|@_R3sDq?P@###14bKJe|znO}U zyVgx?s_%6jT&RR@SPGrS!14|6L;z$k10A-)*5UG{dS#-I_pnA^^RFkJV^rLAJ)_;0 zZq0wQ^o4F@0PTOr9KX*Iw9tHFDbwG7J;`4-x#>Gh)(uBE(47Z;grJy%(&6yo!>=b6 z9&0LQYugRY9gd07S{uE(!CA8&uqJv`HJO<%OvuYKQd@{1ibB;w_#_b0FI+?*kAP3# z;Gp{(d+UMaA)0`Yd6%7uD!S&)WcK#!njhf*hErT`D;%XPF3QO?!P3$*;b510lrDTO zCN;T!&}n#5;Ni%zn(zqSR)Oxn8ow&)pZyKJ9!)<{Y;qAs{OFOfWCYi5cD_XbQ-Dvk zf6Id(Q$wbtK~rn|dQyC%NYD*OH11vb^x!=P#>T@4aTyHQXxnUpC(`n#gja!v1qe*p zCV28>13FkxlF`|qlOh<_IB@_dFmnM5!`}e-U+&0~kOMga3kq0L@ly9ab^6w}ooudg z|BaUqzH*1~+Gu5ZxVZ&;zJLe=H5E49j1fCwWE))2@PnK><=#Ej!T6QWsT+i_69pII z7(xjWR?pgB0HR-{6%=Q*xH@ut17Ld$Z*3SyLkolS-{7T6_X$yCIa^~dfu$}wy}*M7 zkM1u#g_<3mea@rKs*|Zn`+^Xf|K0TL>=GSqOXmX7fNRQHZaiqVCKU#VK*zz zY?0q#CxZVkPed!ZwY4>vdCK_H8@t|l1$GtAm_amuHo%@i1Op%CzZ?TbT#QI+g9Ra6 zPg_O|FPP=;C~4Y;H7|ZhBFRIYE7m5FhvD2Y`^Bac99f#jfU6Q~1t@={;!8tt^lF~= z4nIliv@5%>^5muP8@#F5Jwgtc{abr-!*R^iarnb?tuN*hv1p2{D*Dz{m=Ai1rl_t? z&r!MvB_@*v$!ta{WqyNS{(HN!=cJL875Q}&EtW!ZG1LwtE?cy@buxKdwqps>b#~F4 z=1j23wvsS2{kK2n{FB}|e*}CHUm(B^gu} zXa|sK{IrYPBRAXB>2iez*9tb@@$vE4_@x=TJRYz4;_f(-EP0^iojlhFca~J9X2?)r zXyyMYREV5GD?6W5K_} z`+Bg<1x5Bs#Tm88S2R4IJfc#?WjGnzo=>7r0+k(41w${i4!S=`Rj`i5@-Nbg7F9TO zyN@^{+<>4sfg$?=oNAIL{Iqy2fW2kGHK5W6#HnvS6MP_%tK!6g4378>fHK&wjSvBb z=s4gR%GOe{%PaN41B#mk6i_AKKOj`TS0(o_r3R?C%KT5u%&#ASuc2|iwj{@dz(?Cj(a zx^%2AQ%E#C`~ride==}L@`=osMM`T55d47$O(07V4Fvp{%bgUiH13K11KH+8xNwn> z&){LID_ZY3Q&d00-|U}gI8~jC-Ohxor*g|+bi92IdVd(4&ZF`W5~KF4x>eoDwV=LG z1FbzK`X}qE_4UabWTM%R#VLhDRW1p)w|AnBPGJh1F)W z#k1tX7xX1J(y7St>PSD<=vYvIUET)y1(E){vNk5E27MGDRTy$25huPh=kkxaQ^ekl zE_}YH%|HItt6Mlp0CM#TjW1eRk*2pdLZTp;co+Q&-j-8{A4hv{kWk*a^Q9AmCxv}m z^8;#=c4H<9-}_iT3|`4x{*K|Uz_mh%E*wV?l@+5U!TfL&gIzw%v60h((+Mg&{wRnl zr@UO3T?Cf_S`^%2FwjX8^1zva=O=>ikwhMX<_MZx>|WB^ZB3^h^xNQK!2QZU9)@;0*$qv0WS;HBwI*cqR?&P9aa zRB3ZBAbVjmTPf3}ao(^zU#7m}Z0jb)b@}wmfPy8Fn4)#2d%>iCkH_vte*ecX&z5}F z>{x1gd$zs`8R>RBQTSnCyTD2hPt4)!rEfoy2G%$U7X@qsM(To; zRn!j59SxXweCYp|ea9_-kq_zm>aH6B>Ltb5t~cM$1YOS`D0C@}x(1eo%zB})* zO_1p}e}c3Cd`bd3##E1orMmUG!)lPs2l;8kq{|y*q)#Do!Y4;WM1itWXR~e^bf@bq8t%0UN z8{Pyb5HB>tr`>;1q8(DuEVssvbr%jO=p*pRBe?gnOKd!=M?Tc!^b=F zV#=~6>+>-oS_2YpPY*Y9qcR6xe*RF(r&T0fKjwn(nxkt@8(Jm8zd^V~A;!tYfQZo# zBO}manM;?_gXy7%nEd)80eH%6I@9_tcx1q#FPjC7^DRGTW^8b7(Pcoo7~VFu{BaE_8$dw-6Bjr>eNs157%1^;>U3ly=7p}1F#n-sL-{K%iVA3W(p^hQLzx3M5q#<8Wz+En1(nL zmT7Hgml%Lh#~f92LFquI*Ttt{%AtpHh8x?VwpVxIN6dwjQ z?gR>;2JK5hzKM4kz86mM$9bI8JJs^FBJMulNVT?cSL`rlXkVP>Drf*oB#AbW3h8Ma zRdvTV&veKIY|D<~*xsp2wK^pfup~`!OGBpm?+5!bLvR!^OMz9UuAy-QL0Z_+!y*Cm z4;9}^>$c1eGR+c`xP*jDLWxLp7%uBJJy+DNWn>hF31nu;b#6$`)MuOnmmH)eKdX-= zZx4%N8CjlcJuBIE`m#Ik8e_!RQcTlu^LdGO!Zbt~Bnztab}yv@-2|<=py#nKhIT}5 z>9BKG7N%QYwG{S`W+AoRUe<{dNh;5NeiLS^Z`adrHxuZcvTXb_R)}|55NBz{|uXfL2D!dzJ;hgh-w5% z38DeSk;8t5SQkV@#57sLbMObg{tHdZ0&nmO435zwHco}pYB=<7d% zjTWT2>=d;#ON2X+@A6ZH;YaPZ_&VtV-QNiQcK-R1MWbUDLc6+L-Fz|6jkAXIM@R0z zC;41=Y0pwY1daZ_t~T;efFxKSVQ~tKm^l`e0?r+Xsl^n@9zs@{JnZCj-R~8RpcQAM z!hTC_F1=5hg^zoAe@Coe=Cyw70gypc3^9ckf`w_8$#Vaw`!yGINw3xMnG=(xiGTl@4=(w9$WqLS`v{=ew z#^><^Dx9Aawid7}dN0UGDDegZrvs{3fo9`t%JdR{`M(}G0y~Z`cSMt>esjm=I-KBX zw6>n@Uq=hy-mZbc87(|#%Ds!l89243`MUIxtC%M#Wjb$f z^9cwL0wWZJ&53|@0a&{?UdgO10S_Ka5iE8v2NQ-&Eao(&Bym1wO1o1tEq1-FzVmW` z>X2L91((|6p-&`Fss}hbM`5qcnU$53Q#ka9znQ#^Ui-Y+IZfIo^TtFq-7#J&H*H&m zjL$Dc9=x-THP>;zh=U1B7xb*)BK-@#*s%k2C)^B1@%p!$9>Dw2`OLmb2YCgi+ zwl6o#?4OxvEIOJs{{U0I2X)0fl)v^gJnazW;9JGyYgcBdU2TSXi8#x~Cri7IOk)t-W!(nK4lMAb2|kTtwe|2fF$ zs|Sl>bgWY5G|8>n)G2K<&tktxibxY*UP#ZNnSmq$PkMOQN^pq9$tb`6QQh)XaH6UuokvCV7oznQ2O#EZ(wHKHLYbv%Fm57rRENQ7^u&j zKPIE8a(L0Fx-L#Ny;X5s*`7Lb0HARD`-6V5x(IRwf z>Rp|fvk_^6D4(O~QPGD4pGr0tRDjI^N|A~@HMMF?6O#LOhJ}S;lmwIMl<%@2E(id2 z#QhG5_HSd(lN3*s!$-h*{&UUWpRu%uut5Y#9;|?8y$YDQ#!y~R}NLL3{7u{+4-tcej zsc+Z;6zqAY-Pv3fONT3*jpwk4ZfXRT1O3Ju&sV=4{TK8CXc1ZSp#IzkgS*|SoMxi2 z^Y`8#Ww9qMD5*2La;?7c{Ge6b^S5>NBDY#}E|{3?WAZ4rUC{3p+}GogM^wn3k!2lx^Sh3s-qV+;%X?hg8Se zJ*-J$PmU7I>n`lRQUP^n+iZ}4?+rkXp^8uhtw(ITs3_-}!S{qg0Fo4=Yj7ZHrH2<(WO9oa6aHj2?o@0hP_ zy^Jk(K5t9Tk;z~D{gFaJtvgN%&2CW_e$Bm zCoQ&Kb2qp9DF%qUP~hHf7)!4A+c!=~lMm_}Xj9T;Uuw9Ay9CG=3u7DiS5W@I#U2Et zz?P`;sjpA@6a#few*IwD=9Zq=RLr&rr#CZW`k#Cb&_Rp}XK7~L#WT`$9-&^b^Ueb9 zh4{3=;JB_JfH-dA^bM?jTY_CMu`)|*G{-OoYQ)!K!*;oego?L~Mw7ZYFtJcp~>d0M~E?+n*<~wywu--lDeC%90y^?&t1~TZ4n0 z7mOZMu`AZi9Dqk)Eyxo*Ydxv!TT@s2KV!Rk!%a20Vbrl;rFN{m#)C1_D9G`c+`(?o zYo#&N(*ot!3#u&Q;u2w%rOX}^BCdQ#MkaQPW02diae?hOq;4qd44&?y;cBfJEyFEu z9B+kyUsH`DM30{k6qLdP0SAo<6JuIq@=&M__kLDSXON)KziIR_Gwg?spGc>@Qel)_ zp?)c`uiGMZhKfn9#bo(KxNq~Gpl5Dk;ktQn*m~4G0s8ijm9f;Z_a_I2T~k*X)Xpvt z`YB+nEGV z$881@eJ@tc3NS_#ygQsDyQYCV4y6w_H6|!!W#yY0db+w6!gQ#hY4^WFr4A58Hm`FC zX>>TeU|j<{K#{~d0{RNFQVDGFXL~wU45+pk=KnKvs$Htt^dmfuE?fxD4hJ=duJ+Ve85^6dl&@7(~LcbOfscph>{MMyN&< znhx(?5|qF7Flo=RTt13$D>{9@ffI?Hi|o5;OQ>Tye+!@P5PtA-?M>M!k89;$en5bK z%6mQ|xJP}u7Q6|ssj_YWHs7(Z$LKc5eG*Lp8c5)CDXMyZj_@sR(6|Qhh(C#qW>4_i zB6FO$Wq`s1HAG^Dx}IJGR2Jxh(nee5)qC}X!reVR@f^Dhb}KJbXkY8Ax2|cTHF9T- zTJG7rr!*AJzH)){a}hVczEY|vn*;qb8|YmH&ZoDxr%X@qm*4(ZK#$-A@5I!DK2)cP zvrr$jc%@7r!JsVOneiRl9EIG|9td#}*;M9`xKjCjSBF=f7H3x)X@*MoXim!}t*%aa z#X3H_-lVM?e`wcom8%UyUgzB=OZF7i(vp%o5E!t2Cwxfeyed5kQqkM(tmrd&`#xjY z!jy|S*6@!GHx+pMfIm>r2$ujN`4^WZAq)dk83ZL+U-?rE@bTMy@~%Z#ZnUmG3vA<* z^j%^*>XfQ)X&QEf3uj0k_~cYHMYU?mb^Tapb=H$7_hHlkZZ|QpKY^_yvfL*aBz*Nd zZVDdWd-tAow;jqPel~DjN0Cv0qp&l*T><7M*hbe05!4%OvM_+dECVb^oN@1^O7%vq zjo8%=cum7T1xz}4Cy{*uiIywWg1hr=r=19JM*v^IoMqC{=!lWlt)5e3nBq- zWn#{yS_1fvE(0nraQ7giqRpeXoXS^3UQQ^-(7vidEN^_+b@=lS1GZjnje5 z`paunhYGC>I1#@}76i*H47cKsc?ayasrQOKdY14)fO2oN3P%oC(W6!aY2gQfv#f^U z59og@F6!8Goy>W=H{)4?fsS?_yOe5L)V5Q<7%$0;4ZYb&lDd8Lq1R3LuZ51i`4`*? zg}e=z89@5MyOe>^7v4u0rUWS`@S~9FxFm-~O}^I*prId=ak;;GkGla@wID#DcgKhh zxX-yYc$=Txz(BdgAl7k5H7ld@E90F0K!mY!<2!ctJii$AoQ@&S700U$WSWy- zj9KI^_*IA1)*hz_aTt6KND78{s8r{(J`?_IfRcePPv>q)eeXmWF5kUkF}6p_$o06! z;<2r%xa;x^{-syb3`h!5@vIBQ00-03w&is;gYO}^ z+SB&GER83S;{g5qRR{V=3^)hGaFUb5!We;+L>Qpm1yF zs%*0kG&)!i;DFxL=VBM?{+gSfelA108aDtI^!SlAbagp355Uoez>3;?dUjiGA4U1a zY>ZPe566a&xJ9wVfTIK^DCE$Vm&e0O=fp|LHuRhSi3@k1tgmx^&#}9nm%eH>jH-#p zy^Rvr4fy9-swqQr4NO^Jvg3zF4-D_Alxs?lJ1^yJvuBPh(?8wZ(q#K5@aqZNO!i{R zyWX0UMeP?qDYAAJ%69#|!Jgi{teBI$*T_F)Vq{6nz^JWxo)t?z)P16_$<3wMwu;Yb zb2(xY?ui7?7@A$ff>9Xl6Ve4t+3sCIb>2_Dd~qBxJV`eb-i!S{;p48Q^#)5mAOeUc z4+)*Be@o(J_7`P|c@&SZUM0n$*(q##gR`etBG-6(TIa zjW3naL1%p}q^Zdni-f1L_zj4go{Lf@>ocn&H$LYQUe`ZAHIPFKh9&p0gOqlcx)<2T zPKFkhfyUaJcmj%r$DMYd1mQwsKV}q%7;0GO;X0-1UFw&^7CB^#2Zui?;Q<4pIr>3> z=om$!n=-f#W|5?DuWR;l39r(S-R(0tc#?v%+-Fj^Pasn+F2liC4ZJ8KRnt}&7xWg) z-$0)67@7&)H(?_I@02%q{h2iph(=DVurNLVK?2sfpWzgN8Zhi9)IrgzS%AQivMzYI z^|R_5!^o=n1O;~dUqohTu|ClP#9PTcj;y?+2s*#y{YD1%~~%rzF@dXbJ#L zpa6pcj}7k#n!>y?*$%+&AG^BX_(II`=~!5!7=!k5I13hVgyTLv{Ut;|iVO7E>mSnG zW0Du^Sl_s$TXC!{owo(6P*}EqAiTaMz*r2n@Ffg~A!!4<1i0*T*LaGLVG9P$r;7$= z*eJ<{_L0o_yu7dD{EYkl9_wIEp+8+eKjwBR1Scy#ioWHwH}!k&j}!gJMI)nXEt(r9adzquFI1e>{LwoRWG@&$F2HU&VC*>+7n1 zL01v@cxr@ZhQcn%iNSPy-|iYMZtL8a3F7lgp+mWn%M$ z1G8t}`tWdu0%>lt896sRTe6QhICG>CRyFfZ&2L8%V1&#w+{=QC5kVg)uOr z9w7q>hjmww3~N&2yl>X$p4jI~b7!ujVMW141GuGxng>25LW#2RrCXb@v~qy`67G4p zZ_Cm3po8C2P(qrz7}YHA`KF_%ArM77f=>uK%71}u_n-_x8ON?3 zR3#;AXPyn?eE$y~Qod>&hrHqw=B}Of`a%2bx+2@9j@-)X*xK9}+q{pgEa}mH866^f zdmav!tP4t%?RMu3@)1!ui!~eeQt*sI)qOeN%mcTXd&JHJ3k36uzWUXyj(tt;-8}NA zTr@&I7D#$r>h6@WmpMM6z#oON1Vjn&B$a`1V8;qa*y9Hf+5}R;`Fjk5$ZE@gv5Ub6 z-Q;d`CpX>@UhBAZz{JziG@LX=G@(YDob!dXY}e>dFCmD6U+T(0l(bS_r|tulCuUI) zZaxgZ_Uw8ivXQ~%Z3EE1+?HPS;tRvS;%tNqf~r85XJX-RLz6)e^3*_eLEU1x$1r}0 zuWZ`-ii%PFUym;8&dKt%&7QXAKqK+}vMb3{hr1+b9(uZ#uqqlXLDq8){BhjX-XL+J zCP2UE(wQlR?Awc?MqV(y^M-utHd`Pv>NNIvF$C8OWAl@ zP;W3-qXiqo0xund4!{QZnA9Ou)rm=oonlMf$yXT3A=c86bq2E=q%^mvc=ixn%xJE# znj$a*Oh3_BTpvEnWk-5!?WIX9g`23DKhGD1-}~(2p1NK#2kCGHEMg;qo%RaxL_{|O zZZ*(dY+DHPFbpQvrL;)Qfgvdo0E}g0&93EFFi`}LHKr-B{eJk-`PFr7TQvqadCar) zN=>W^?m}A*XBN=JP_tRD*nmj`*%4bl6_5pZbKqZKU~2kq+-=BB3|{~wX&#m`rC4%n z=EUw&)w8>^_Vc_XsQXD+f8s&|g(c~|JWd5Z4Vv-PxWlv@FS`G(mKhp|+q~Q}7H*+S zUS`My?R5 za{9%L1RXuST=82?>8ZXz5_B4QI^3Pwrx-S7(?u(fplakbS^jmG%DlUDwqxto$bS)= z8{WLsNxg$trY*w$v2gX_A7Ko+Q!1c~vf=DE7?%e&HwK*l{yBtj;%$lI%CgjF6lG%T ziz-Lhl*!6vq{{n>G@tlxp)KvX{rU39i-Gk$$o_E(f%camet-?APnoH;trEi<)MM4A zZD6+I(j|3FP_0Sg**k3Kh;2Nqn=;_0`rpG~eOn+8VR&zAt6+P? z%HRnOG!QUM**B!NRP^x$KGc-Hi)Is#bfdH8uO3jH?P!uQyru1sE=(NMcDpk#6S!#&?PXZd zrR>JS`oNyLHoG#P&P;{U2d_j247VBBn_&Emkoe1mN>A)|{Z>n;2I8F6A3A4#Opg|R zZ7GC44o+?TPwHUJ>Fr@Om(R5>x8qpqTk9=m!XX!8WU_S9HS7;ROgY!-aa+23_ZrJhS-kIGQ<7h7C&PF$>Ajg%r!R9$ zNrq;QzQOKj)uSuJMz1M^8KZiO0lho^@|u%qZ9W6 zhj_X4?HbH_=U|re075irO>BJ7^nz7!8<~}m(t)y>_B7pMWedqx$SaA4=yl;PFPKAP z!-a>3HQ&expu!Vq3~_@D>Mo(eeERh1CVuQG4}vQqpN<3q;<=z#k-eyl`h?#Xt1pD` zB;nY@ijXT`1nVcl#^5a-pZc z5j)pXoocU}QAV;CiztXN&?VfdHRn=H4z1slUm={oVKepq!qG#27$uatqtp&A{$-wK zyPL99r~818PH^0vRk;Hd=G3)C!cPm_;0QSO01!Kmes{{FsML#6BBpP})XOomFz;hs z^qKue-k!?q@+_R7QxN&>u(>%th5JPH~LV%n|6YSQN0K+ zxY8cD<)m@>=d_*&7Dkl5IC;I4DAb zj!cj8m;d9DN1R1ta=*zk7o6QY%=SrfR*B6@M{U|(y&rtD6Nz|I(erMBqy?0#{4|q& zt$f_6UxMWVj_f|htDrx*M!(>gKD8oqhxe9YL3&wPRKoP$XFuq+Y%Jvhv?W-aI$@LKjBf9FWYw)b}|{4Q>#(Yt0WnFi(1a8%F`yM7TWU z{aG;j_>bs~!P~nt^yHZ$cB>z1(5+&MI~*>L|+R~H>kedpwe6+EciAHZJ)A&s21%qOvi4jSda#VscL+E)&kR`lhB&u5VGSXAvPLO z(O4ED@ly>lf7q~)q4LAFYb#WrvaFEM5ORw<0n0nvD`2=oY$$d-d2f8pyqeie<=jIf zT9aeFJ6Eoz$uLuvJkockJoymWFv4_HB3CI}b~5h@HZ1~F?TGS73Ou$VN!OPA3nO= z+x@EU@wrvtwSxyXz6X4FvEnNY4FlwkmKMPM<;$0)AyU1o-+ZF)^XE5&?Jsse#9M>` z;Huw*k?-%Mfw$vs^I6#Mti8Lswgc3BfUZdBmc={|S{{t#3rm%*?#%1vE{MKPo!+jG z#lLCQ*p7;=w`!d};z;j~#D4vcMm`e;4iAWj4tyGS^BVK144X2?I>drTN}RCq|HDs-h0fkk6G${)`PKeWYp%|SvhvdI z2enr`KeiX&X=>tlW+(z%Pu}RKoFpUs9ij1_;K0?_*SoLo3Hn{IYdo6$v2Nb@&!3O- z^7a_S2i<<2pRdyKfFN(eU zQ?3eji1VFfSM1^X?!_~vmh~Bg?yxOaz#zuhVbk_-L||h`fUpBaP}yU=HehF=OMnj? z=pV|qOTf8+D`WK99WZ5llD^(bVMS|^Cnq}T!2?to>_jmhknColr{9i+oF*lec7Fjd zF_ctvIi>g+@h<@j7mz=+M^)|<)R1%PS)&&9k85-kv{>b z;Wk4RJ_k4uv4`j&8qwx+Km-MTK~!^PBxRh>?XcY&K}z?c-{!tO92;0x^CRSc*QpDJAK56vO( z;x-KZunPeq1uhhL-g07d@QuR*Tb_#uXhjkr5Hh0F6GdF`F!=f}o#MXcW@eED^2E2> zf^2=GThwuqt?o)iz`49m36SG53MhSew<3|?7QQdE(*a0>zjM&H@lTo0G`+{L%w^Rfng39V;MAhE0|;`9A=^T$aZ*-9!_ z?PS?wg=Py2A}VTauxL7ET}od4jd?8s=OQY@LCN@5Ent^J51cZu_xs#P`$%)mk12HJ zqrEWk+aM4N&DAc?2Ut)MxEW;jO3;kp(*?`^N`EB_*|?)lp2056t3%X8P85dWW5$=s zNFQ6={HeRUOEs;dN|d721tjmw(2~M|iD0VSx#JDfQbaK9AW~om&M(}t^tph;9kUR@ zn2pAwPR)cRwQBBckgV)VzGXQGv<=d}Ar}!_KCMTAlZn zcj56UI`ZP-Q|edSL(8uC_|TR1$e{DxbLAxDM4(Ijx2YZj)seL{iCqztZ6Y&VI^*t# z>Y||d8=BjM=O64lY1A&>chbQ7s@_;#PSftiXJs0uMr~;g*uu+XY7Tn5(8$pyaI%jd znQy-D7W$bfH>iNCtfNC)qeR=b;Mk~;?p+4T9SJn0kq(r;rfw>sz5?>{CGmNJzkj^mHn0a}sO86HoA3n>&vzC|3GNQ`_P%{985d^|Xc-cll5IzM$TznV(W%Vej{W zzso?6HzDul#>Sbtpe7*UtT%vz0dE3Pn6M5;pNF~@<8*49W$6lKsYE_sKRu1zzANhg z#|2o_3e;+RatUG#0L;iGC6bPbRVTJU5S7CIfshfYs)A-KoDjNLb$?4KEv2-(mzVxq zCN9JNe)})kGn>i7>4%ke8&%yjm@bAI9eX$ID{u&it`lbA1bhrH7CGiunk3LKQDEJH z?HH;MYnkmubLYqLM&6t*5gK`&V5DK02WcXC&r?(n99rC}Xm=41k%dqR{V&?wRQRO; zF%cm2`qF?J4DnzAWGhVAh+{#r)@im*1v&)=Yp}y)_bOc63=P*{8E>Sz>l$PjB<$ zDreW7Ns+%G%<%5VZ>(96GHMADqZG3g-f2co&6nN`|zz! zFdW!#Nm0^>*e&W?!c+n3x-7Uu++cuS_ zyt8vxH#2+l{kz~6pXwVR_OdJ16WXnfrBo{q4{B(gd2M*U@le-mb3@h+#$yD~CTxQU z^Cm|qGpisYhrc5F2|7fkett7iDbx2%XN`#i6M??H(7%=3WI6o+J3qG7 zD~;FLTcA$8(`h%hJh%O)+utK4H!05)9?ogxUTW`#xAb8jkjRWCZ z425~g23L(%;3c4oDr%fDkd0pB+#b!o+p%0zi@l--d6gM|b;_@1SZ$2Gli%i)<45q* z7bdYYMySY0<^c?MkgyWgkMNd)7DXnQSNFx^FXeUX*AGSmX~pIblM7l#sIdYBV$khK(+PulK@~XZ)7}VE+@M zlXu=H&TDvKn_}~KxA;q?iHRvD8RcE|?de}nrHE~;*K7)~Q$X~QcmJxyLXO%ToP%Hd zYdu$&X2ytw0PL=YAdn~WNXrc0Gp)BXVaVbwX*a2K+6wy#tm8pBsy40R52-!>?1NH% z=g!OJh6QFFw!#|<>@K&CJiA?KT)2rKX9kU3ZD&1okr+=g23&rlCgoQj|Mb3pr>;?2 zoH6zI;k{Nq)f=Y}I0KA$2t;4hm^<(Z>FCxgG*Xz~{C_lk2RN5~-~Nv%vye@al`>KZ ziR`ixDqFT>Q=}nV*&|Y9YY5qd5E7CotIVuaA|oNi|Ge(!|Gr1Zdpys5KlB^d^}Rly zbF$qWp`oE}8Mt7Vd4{TU;L5po3(bGd{NU!=RqBzRxYXBkmYDy=&A&e`C`iOP1F@p8 zIz$~pX8Z6^#TWhe!-0QHz_7tD!pCyv(6YnhVdoKCd?~O8%ISNgLEDf?P^#@ zaNLA%wRCOSpH-HZ^X08U*l$84jidOy?zQ5X)uiBp-=OG#1S=!jf`Ly^qj6^06EbP6 z(k*}%-3!UWO{8eb-)<^g|GA61%_}|Pro4RSUaLd?N?Td27+F7Z7tz(^T)BTZchY@d z1kGJL^V;jB;uh;w=iBNkZxouBh}G^jiHmPa)YgBbs+FZa7jNb|qBf*vWNRsL zk4$J;yHk5*-R2ATFUjg{TYiXlrxem02}+y0q?5jVdgWi18AJS?omaJ~sD*z1_@N51 zJIG1QhGH_SXzT{8%Y{)EwG{)x9iR17P=d$oY1EUa<(yjT~ zBYNWdz|wMt$6dPykDJl4iijZ1&2Tmx@|w|fT{*`{6Tr<)O% ztA;BUCv0GVABFkpu=IN!j!Kdpx&8?b8l3V==jE-}wbx1NZbjk9=8zjb?5R5?2b2TpJ`Q1NJg zg?!S%0}48_(od1F>x=_#I)R5BeIL*6-3J&(5|u;mJ~G}HE1@kO^{hlU$;=0RX-^6Z zTX0pQv=E1TZeDaXm(fMu<3ARBxJBE?5ggD0F-Zu(aWLQzT)Mi~y#MgJu3uP4J1^iZ zJ);r6QS3dKe%(QYK2Y#OML?F~*O4F9xr~hEP7M-Aof_c;#T^Q!JU5TI#RHnKX6zQA z!Q4N;B*Wxm67vXn$N56G(La5aT|GS%(GySFKY#par1V?(NLHrzc28;1sT)jrEvMG| zy6bv}C-L{uOYX*F2o-2SK62Y5n)Tf+c2+hxOVI*H!JD%RN9D+GN?2P-qcvj8*Ub|s| z<=D^V(EZ=je$^Z^w)ed4t{^fUfxNyWTfm)rzP8jK*h27uo78uN&A>BiKwz>d$ z{pgN}W{kjryN)?7KJuz6I`=e0spCUtg~eEfa)}C6tG#L#b5{27bf_2|>Gr(O3kmki ztB8O$y{#GupInwf0K|>}6hEVM0@HFZkR2KBM`Y#LSRmG>blqMRa&1XeUbEwgzQeid z^RaLG17o#l2R?qhjW(M2?s><6*vHUI5P9-42=-idOUg0($5I!_iG~ZB7EQiAD?gJ=t9ovq+z>9x zuX|bh74J^4z9lR%Bu9!M@1hRxSyKCwOmVfcygakAk`2EQiM%Qpev$F3XK1*M1QTYs z0ArWWGm`qu;7bWfRtlq-JIN0osDjhL;s;ue-G10B&UQu?_T!F22KfvQ2gwUhkhjUu zOzX*y1igwYN8&jk7l@WJ%I$EU!S|ROs1)%8)VUHviO*Pw+r*0BChe2_vnKMBZ+Mrb zCIwzuelDtD4NWNI9vvBh@F~!5bH(B_<^ZDd6Um+k@(ja?i+dC3HyH`|%SIsUx`23y zXVO`mEZ66%wh>edB3CStER3hk(|4b|d222_IYM!iPrt)s=wQw829e$Cqo&qe%Np@; z*!Ivlu)~hg6Pz9Pm+m0meA2Tj?U#>S`pUIhKP15~_+c3IrE9uZq$B70h0KOM6!HHX zK~R=j4EMC%_0ZB4;ebePo7I;;~LhB zh>NwhRdlkL{Vl~5t3T3V!g|k|mFwY`1C<|pde7P1_{({7t-T*n0WX)RF|UrH_o5kd z|HT42{V;BlS3A`$6(dvAJCqN;{NdM1O6GmcA|uA8-g;%6bqaoHh#C-P@qsx>Hg!8z zBCZl^7Z$nB35W*p4JeATs>r2j?fvOl^-_WkyOFfR$5FSLZ5%P;GATC1KP2@WHd1BnUp5z&iO^)`CEB4vQ%OqEQHBixtIB@HOvJ!=p9y1Y&fZPoP zo&ik2{4AmUZhxx;9cW2hEyx<|n13X4_LCd;nUN`);2Z|N_|5K_Wq`b|2L?DzOigoZ zSV)|OUWn10m#Ysb$~7_iT17S~pCe%VriyP#puWPB!P*#74sd?NON573=nggRW+$gS zn8)!R5R&!i(_3|ToVVkQq@`V2tsPyLtK0lH?Ezr6!IHO_hbvL7gyU?w;fX*2GTBs~ ztwGf99oX?Z@SEi2cOe6N^^U@tmZ<34@pg-iLs*qJzQ$}&LBB#A0T}%8NiWR0`EkJu zns6ijC|>*tj66^xM}X(#Jp2o772G7(wtsnxt~R!Vf}vKwMBD#Fov@K^@mN7`ZOo_H z-R2U;Pic?yNTGoQD%U=M7RS3A3fUtUBxt+#kTZ{!#)AkI?|T-9FdZbEHjnN z<5@#{S5C58-)RfKd-vMk;Zb?SuY?kZA}%AKNEo8==j?Ui&YR~@lMBlVgke;Hyrx5H z1IIrlJt$1BI3JM{`{oBm7)YK4ynlRDIsgpDQR^|$mAK^nd$LQV)&E1(so83WIQoZO+7z`G4a z0%!(e{6Y%LbS1QqNWUP|k&r-bhav$22%u))L-n=0b-u*BO|5=?eV7I!RAP7xeCtL- z)6S!-{#HOEYc2*0K5;1n9|wDbZwtQ{U!i;`#n7O$6u<$q`n2}OSFO`~cW3ZcK8?NE zf92DvnJ4$jVNrm%Xks`hBXb*(v{rBxRG(ty&-9$!==WwjTal?_O&fy=#s|=F5ju{Z zCLrNe$ShWX8YxY17lEkmVWDj`mWN9CywBLN)gXmczNb$eV@t0&>|@uwli8Met(K7# z(c5dba2lsz>M>KK!(K(O@YtpF>)YFGX#!pz0(mZ>pb!Hzjuub`D0#|*imx2k4E>f3 zSASekh=6v?8lxWN^LFzs0lfMr{Zut~`{fE8H-~-Wv+By**2L^&wl~pfH>wqH!3rQ8Io53O&cvC6` zE`0yaX}FtTV@J1bNE={@?hR%s_a#`OA0GpV7#R$`&<14pg&~LD9AN>6L9yhr*dB{` zrt?@un3=r21g{3YCXdy635?W4-t3ejc?Ik0GpW6v4pHXj_e>Q|)TKIv3Tk8-Un%<# zp)E&QbBae~tYEa0xMnuP#hDIKJua1sU+}@nt)Q7ZGxEAq(|tJ{&#AN$-U z-j{L@+Y0dr4kbhVpi8=)vF7&|=Xaox8=n-f#!JwU1OfT^mcn20xw>^|&3E=3HfvKF z>6olxT3i?HkACm)&eTJNL5b@$g|<=y8L1a~!^4$&W!aZfx>h zDg~%QATsW8x%khljBRg~|C5JG6IXd4);$Rm@p9tyRURDWkSk$Eg;>yD(Zt;RVKZ~Y za=}(52B@rXF&DXw9#@YK2E#dl`Yy;1^#dd_1bJP`PYX)zTx~nPc(dnAG=<3EtT*w< zfb%y@l{_ymk22)PWS8u=@&#eaQw5vl14(WZGTRANeqLU78!tF{NLB!FdmxSuqFPw} zlE*YP4kf6nh#QHl^RM5L30-;fy*P6Ry+{Tx6-eCI=2wQ%JE}o@lqpN~H$R2yz86b! zF_2P2q2qAA#k${c=Gx5iH4xJ%Zgv)yGyZX-mnt(kVmC*9-zBwZMhY^VsblV4J&AVk3>_ZZKWqK#B zd*RM1W9g@@Y18m;-nMcn*j?j28{B;{^n4-ixd!Oo+(0XC&>-UK*HOXn;PUb#H@+NB zZz%0NP8&TzWPxqLE+MUFVG#qNVs=FZE0A$zv_&9JJ(7@=;9CHlAZVyz`0o0_%8x6_ zmnZieq-%mz;eAzA)hLVF!L^%oS#)0ijq}U_0vhB^5{H2uo@p&)LLVH=Fj6VI0u-rc zXUpND+HVkBK>Isn{b^iiW9NfqwaPX=BTb7po6?n!Ce?3K+-W0!+#M)ADo2~to@hZO z7_4jsHxi)7CVWP`Jy7)%`ybp3l*^KRgTulZ`~CX=yqy}40U|@zYDf2BW*I?fI09hh zQxawdeM}&+K#Oq3R|=f9FEz%ULKR5jz2J3_GfD;nFHuG5wEGG5*A$mQ8mWj0;l2tp ziO*Mg=$eSG3IN@K$H&z0qnK9QHhY zYMgBx2NwP?s4-%|046Je0;!gkM%o@lGzHRJt!#{!@=R&N->ALM_ zL(Sql#FO9b)^%WvtM3-f7rDZ2RIr^&nMpPk-vTN7JzZ!q$+Ds31i&){rLj-HGY{=` zd<~hm;HbdHBlraYu7eR+g>Gnj^aSw?MYt4T9Ky2*r$tErOf$$?m`RK5L~akr^KZ`n z?__8e#hEX0>=-Q) z5x_X&P{qABj_f3SsM+PauzF;@R}Zl8u^Jq3HP#G>f0YcyGA0B#!Euefw3Ogwjd&m4 zh-fc3v&!y`ynU-3P#&nb&r%~k7{O1p1B?w1&ib7(vxPu3bWP zFT;ne1b&Ls5;_hdJ5gCgq^m7W!A?GU`58LX!;M!GCT$LT=Bt@#`QG$@5D)kPi|7P8 z=aKQW4VMt6CG4%lp(^>sOhLm#E3cO(?KJOwZ7bAU;ReQ(vqR3EDg94R%jcDydE0XB zpLqq8@uo`)a_sx7qkdbbC2%5N{qa>?Jw^Gr1J-T}Xt>MDf2^(HI#BzIDDoXg)`w); z)h`@KwWXqK`b5-#?8{@U#9V>Q`_L2`6E#VraL|p#; z`+|~EU&>-^J@hLB9T*wbR`h@GNw?i&Xez4d`^~LcGh0Z4$z@kWa-TH8mjBX2Y^BNkCJ*%19+9ZJ;;N4@XzGqvMkM~k|Eh@B^ z7@3$Tqb3g5c!xji>xk}(?XWMdsDPI1)UYFtp|i9xaZ;F!e9|79d^o!wv2?eQl*|Q4 zIRN;~`1p8eG270Po{Ge3Be#$zPpF4*`{DqOkz1sidp@!K`#aU4%jz_z;Xf{CT*VZPR-f#jTmwvM!*QNJs6TW>;KM z9iG5ToL5=G;{)YR_mYzXQK!on_Y!Xts~X%Ec+D5bx-2EA^jJ@mI}4C$>hB$Wq`EIy zZKJkly{_l_@kGrA`*y)*P@rl!UD<^$Fe2*%O9e^}vhHW;=fZr?ef2Oq9sG$9@HPA_ zY&5J}6vVeL?6%y>cOg@^)FC0z`sYd%Yur%Hk)$v8C!D)xI!KcXp^D<$3!$-uyYdQ8 zi%pDtIP&0;i$Kg};GS0d{r(vO&m#WeuU{k*Vxj4Anq-cI2q!i;IgN2g5pY?SQP9&CLI18ZsDu^805FbGHmX?*7KE#PD)S&e8F& zrSTR6!~UX67j|Bjy_?*5N%(}KX1O}E+XY{xvm58%kXH>KY-3}Ozc50R)E?UXxHCI< zpW!BaCe#=q?%i*r%pv#Z%^{oIzru6O`+?&Z5cNyS*6*HX+x_F67G=}zZEc0551%rI zDBUx6@&?i8g*`<;Be20TgX|j$crg8Qg>!~yQKe0PJD4SG?d8RS+NPJlkC4(BfwV)& z25=FQLX6X>kcS}38U)py$x_C>9p!yhZ~V@zTU`9d%aKWBdt`yVv@b)5GEQmA`wi-2 z4ft7;ol3M18N@Y&zP@S6d$3bXtePpuM7Hg%Ae%!3Ws_r-8CgcoFYlbb+C*XA$yPgR zTJZzuf%uFl6ga1X1vIcZ;NtQhoF%qjyb+WxN5f)ndGTWIlbJ{Zr0sd;#d(fI$k)G- z>Ny?}XMBWKxO0ifm*MgKr3a3x!MYfStRe#i_6YTOid#)&P|`-Q9SEF|Daz-;11pgC z<-`L1J^b(dtAD4{gGMcGDd%n5Lp#WrQ+ac!S}@p1o@$MEnoc4zI5hMG(1yQ1E^G!E zp1(?oiy!efGMB$H0KeUUeTQliW)(N!1jeYSS*f$HXIr+d)0>{)*v*S@p(R*qgW;{=C;PVjBqbbz634jwhh1^A z)8F3x^MpvNK>>a9?+Zn9TX_q&c^(eVW?tO0+c1+g)=HqKck10{dH=}k#YHB2`$vpn zs=OLiA%bzYk<-S}5;Gc9S2z4wW;-O!k4~kgr{8KQ;?Xt^XAp=v9ZS0j2{U>|TL6O* z2T66cCT$P&weTL!%f$dG#o}WrVZ{3jai91HXsF4nNzoP>y3{EzH}J7ZNppTC*)(%NIzHQsLqQ*)9hY{Y|7a1ywG9X|EOV(dHlN-Z)WBf z#>_igzrtzUUn~R82p)lbY-e>2nH7ZSbGhW02R@kD$pcZJe*oDChHBr;`J-(8>dw0j+i1aLO*dgIZJ1P}Z>vQP1Jz92M!Py*7v*lF*h<50P z`B)=@?0RQXBqFa}J9}vB+7$pJfNB7vqZ_N6PR77#?hg!~dpM&SXT6(#t^`@JBjPo{ z&Ujw#^ciaO8RkEGW<6Tx`=1+&e{bT;Gr7$4^OSudUw{STJi%FdV|-`&O9bTLg%Inv z?AEF0y&FkxXS#(&rd9Uk?@ZbszbowRGOi^!7f|H&?clXq9!wvv5-#XsHzY_EfkC`8ZNHneoh9+^m& zho-sl=SsJanCIq&QsZRmw=>Ip_qE4iMZSH)X7#o7#&*B?Z5D4$;zU!}c$ z_lWALPuUe)TUiudX=a_gaDfZZH^PT^R^f+ zbpH0Si<^Xy(*wwyJI)hz!lLFJeUiuee8cs@yLzv;u?O;M-vDS7q!yh2`6=KRa*!KPVQ-F$_5~mgY=jM2Z z@a=;ydej%}EVae5wkQ=Lp|Iu#lvL4Kd^eyhaM2t)$v}~xpHB!P@xd#KM;P-m;21gy z&rv|edikti*McLAl>hL~|D zv&HX?2KR@H2GBre@5~gdjK-T@Uvx=)ti3M1eV1%7Sht-xw*v=fUxV386%mx;@6_~s zexD^c^1?7viR-7cJX{gY@YH)it`C(O5$HEE4XYV}BjF6&pGZzJ@sDHP-ys-Jf~=lM zPopIQTV>wGS6*Xwm!*GFJ31vCV(Z{?;M~Q8_4KzpTZ|EN5fm5abi3I{?)S%R%u*O% znSi(Yn~B|NBrj?%y`M-fHWk=c>POplE5R*>k;2N+%4#gmM{eU?fy492!I(p2`?4d& za2=jU3CnKCzPC?y)QP6#Wtduw2AbClSV>*tG>DyLVkod_o3^LOVP?vC^lgx{&o|yF zvwvoxJH0NPC`}-!I;A!P-JW8pa5&;yTQXH{;npTDY^WPJW5o(x6kh}UF)%dr z=r_MI1}Aq5e(#fYLoCdYQL-igX$<5PSiE$0y*`0`#~}p)Ew+7tsN6(AxIWto;uzdDX^C#gl=jjczbdlQgJBX8@ z?3yzR*BnRc_BMg^y**1;rPagY?K~p|G%zaSA$VHhpCkmCN|5(ufUt$yA6QpbCq?lu zmlOMYDn!IM9b4K8s|F6A9>5@ipCQ0`f-QwO96Sp#&tlkF`_*WSr4R5ECG=tj0TxKG z!rltpkz!BOHXfOP1HRuPKzpdY`@TonO1JucURLp`4#xufZ@Nw=H*nu^Q#0!6jS)(0 zk5zXCq8=2Th+_nc|0Ga}=T-$r+sFMHx;5S@zN7nXSE4A;_jb}Y#$6wQXV z`*bdh`7PmexK5|XY$MwK%!7O7o`42j?DfoWYu1U0ZoIJ*PENa)_1@KrxKWbr^Zq+q zve^+WndsVPBX0N)BafP#m{RGXqor$ERw9Vaw`XC@%FIDo_U*6UBUcOIDh|< z;T-p2g!}yd@hJ#t<)CeiL?NxE)?>aXA%qph$Vd@_4T5chP#xYr6g;v3Dd;)GyZ5B3 zB9f&5d^J5jzPyik5+W|m$;kI@a{^O_Uy`YO z*#JDQ*p5O+e-csWQ5-0R0HaX$n)+gked(UWHxKtEK0YOWg0GC?l-+}qa~w=ZLfFN| z&dvhbB)_q^Hjpnfa*O)cU)#;c-7^C>kFJpvhm#08rDeAtH%Ls$?GBiI0or8=XH`{k zK$(o#6#NCr|K4mSwb?XC76a>cmLhkj}>trkt%!d!2?krHiwRXp^Pl&NKbxR{4jSHQEa^> zprM_1<3(*z(Y(X{#A**MS>XwJmHYk)datEkF8x)@>m4ZUpSi+YzaNNlWQ+xdcQrRR z>7hBA`$7e0^R|4d*cJ8B{=lj=#l)AkZSsc-ACwHH77dE6P8~Q6-ROIgMQSu)Ei8(B zEPv>?Zo$I_0E<7E3m1m-y{rdHG<3-O{04=en-&-lHCTO=dyESK)cniQugW z1PJ3DTj3gjK^z$HJ3Ace?Imz=!(I=uZ_n2DoPo!E5Aue0ns}ILO3Q(e$D5Ozf4N2S zx+zjNDe57>!RsOH5i-&3E&d%OOJav|kPLN~2|n%j=gR#3PPvHCQ2YFrYpqTqxh&KP zox-0^Uab8nUY2mi`<2`#a@;TMGKS9`fRC#(~RPk zmFO1{9R~Tl%~Wmn>n;y{dhBNtmF>$|o4gG3k@kS8Z4U!ggYBERNG|C|&}u4~UjuRQ z>lZT`WW8Ws4;4SFno?*!Xf>g{pUrWqr9?CWQ$Em5EJX0{5PMFl4*n~gfsBM#hCo{& z;lSLDG745;1d>K)(!L}*yhCn2{@udlozvss`0?1w)TP30hd1ff#p;I}GAYLa6^t$@&8)(FIbCPv?}ZI7=J32CxI^z$w(bVxD~ zuzGYarfPA3W!*f_cj`v$&&5lEeJmtO1HQGNyD7<)i*y!A{+S_Elu9q-_)m5r7Y%0_ zU@8o=^Kv^#J>{{nbW#>}wGd1M@_vR~73|CJ%o|c+GwI1wTBo?4sqrSdP$|=(wt<*u zJ}>wP7eoC?c))aGMt|OV?|@B+q%9<#?rcT6A9;IZga<(#ZWEJjqyEj-DpsK)QuS@BHO&T*bbBR_|xWbzS1hW6T)hPmFL@%?4st^eNns|aWCEC)yI!sNMFH+ zf?iR$&?jKf1b%%=l~3;d;0=@l_BWjR?hq zl${Kui_cV|;XG7Z%7y*JW)IuR^PB%<`Qp^cKIzirf`P4H;HnQGPGQ(#t4-q^zX4pt zZ$`$nr8Y1l{J?*?S6g@MPZpk?6<{n%N=hQM&oRC~Y=|;w_{*hw4((HWF3lN*XH^g| zc+98R$cX_Inh(61Kr41aGm9@0+OkZt)u)E_wiPFZYKnyZeNZmS+FUlTX{|hN zIN95wP%RKFtl+sa0zfEqZqC*58#07@$WMMrw+-ie7B3L(0GR>+nB;vqQ~kOfoPxXA z`~!oj9bIoD&@kHcaX0c!iD3Y50#mBw35`$DcxXXwGd@mEPy-$I3sVO+kE2cN!uy`G zE#Enwl`$)r=<@G!3_CeF*vl;CXb@v%FW2aqH{aTfAf#U zCYSf@cfvsL72^X{zWc;$fw%UwESAvv6kq7%A=)Uw;PCS|QTpaJZ|~B3Vnmy8HxBav za<4(}{Fi!<$0bIg-roprF%i74`0SftBZ3qNFb{1^6iP$@4K@j!--ENj+$hCO@%;k_ zhWuUX|H~GW1NNoru)TW}?k=XV2}zt115u1MMu2oR!}u8>=S1XTfrDszp|vV3;^@SJ zObYFUpV6e=(CN2v>BmSd0a_=Cn>WHg0mHUx#G$9u>y8tNZid~FBEvs=-WkqtiVWV} z&A%B%m5T=s3W_Bc{5f;iitfZl_1l?e6c!YO49-4klno1rzr$c1rS-TQH#}Z7c4-{5 zl?RUi4+UP(g!~-W#V2P2Ojdp`FdKxFwD+Fe@}EXi zI^f0HmG{nHj=z?mQ<>z6o{*4{34ixa{PJbVKszsN3k6IJB{7~2`b(zbcA5G!SMnxR z!j{#JPRG!JvG_upIVDPgy$8V%BwiTd5Y`J_CplE=AIqKC%46Zz$S+WnIDELYVa4p* zGcsp!I`ELx8fGMFkTLei&{VBkY%k}V<2|qSwT;e2*y-_$I!?s8 zX$de95Ej9Y6BbW}f8S0M3^o={-KMD~9YxaArC2s8vZ3c5TcD^$$X1!Swj2*o8A*O4 z+}YTGL2cj^Wtid33V)9GDugW>BfOpaz}DM}ixP1J@Z& zNj&=iyg_W`59#3kM1Zr3QYl1$hSA*)w(hr|tEO+V`K{ivXnvPEY{^bN!0{|$&T#R{ z#bQ}4lZ)OFnIEqkv=Jt zcZ93Zr+0=7nsTYuxf~>-YTJ}N6?R*1a_N(y=m zGC*9RZM|Pep2}mGA}N$e?O#OYOvtM}^~B7638*tU3^QI;lD~RPGj{d1S@WdV6;TXU zm@G&c4ZrYt!F(K@V#N-`X$-o9BR7ASrUzKD8;OQQD0uAUFBW>Uv}aVK>o4|6;wg@c zgQ(`fX1D!T5Np)ZwOWjvqOE^(u0C9>N8cANMA+F(oDVWkSt7)-y7&oonrD094cD^2 zn-Rvx%cA2tr|e&yyqW(XgZw47oVgcEI)w5T(+Dm&XggmaMCEPA4&Igila!vGV&TSE zaUem1771=MJYrPh1@ND7_CR?_1uz&aI0FTlTkSF{0RVEkWxhCX`>fZxyyvx2bfO>m z(JK;=A{AUiA_|lTAaoI6nA6O6!QP%%gOBJfi&Fw-1+5T15Q0U!lYV0>(ZuX5wat^` zS-7!$Pw*8nN=D}Ti^hWC<;LG-H2gB0e zHFLIS>?WNmOzE&kBjm<4P+OH}a(hNBdO_NZ{0!#96rZ_?KcZ`X+b zy!@x=(zFgtsbFNbws@R<~$tY_MeN}n`OJ@4DpoUPJ#=UWG+MtsH4iuoW< z98X9_x~;UqLU-+87lvXN9Ul-$G?a*nk*<9EAoyZ+JOV0Z5%)IzAmQ+{U53#iIV$pq ze}a(;Lnq9Zx1g_qj0x((ur!#epS zCBmfWAPKerLbC>;ABKrR2E$CLO~?B7&T}2)s*1nQndC@q@erfA)g<|jU=|!C8(|zO zb~65O{D&p`RwhL;?wpMdQ1TFXQGqIgvlnzPK7wozV4z!wNe17ik^2tef)K@AFH@;N zxprLUAh4VHW8|RMy7IvTMprQQfp*433)K&UEn5tszk>@a21gqbNnTldfK!)7gKaki zXlIJAJ&Cf*GoUM9$u9vzqRVqe+ruJq-kI`^2Seb!_Q>9@uHd>la{{B>ZF28igs5xF zVy0K5=k>VjD)Ecoyt=>rx-886rw69uQ9L@F2d;ALmi)m9asf6Lv(2_TEp zx~`4~7q?vJnFglT4hx|>0nLcT2!X{e&{_X-Fb!Xp-5$L`1?jqFN>-U)o?|dZ zH^{FH1tG@gsV|Iyl#K^+AH$z*}&E*oTTQ7F9xx~DC4XaBy5t7(ru9D#Df_7HY_V#5P>AK*mC zaT2eOmkKk*f6(CW<7S_?R#aD;Sc<*p+wIt|vsPuyPZoGonrn>ktYtDm~gt!4oI4qB!h*%NONl3T9qnv zi1V|%4E}EDBd`aX#4=r}jZq%g``);J+j}}RYSR(<5`=0Gw<|7gSla<8fo-rYHNHki z{blMZ4{#Xl07Nq^271_er6M1*8{HL?ar5N9p9HM~{`dGn*^@b*FQDi9$3?f5@IXS# zzI7p9s{5NH%e?xd;>)u1&^P%qhZ>(grfq#1Pie!;dfh7zxlHO1{*fV1Uvys^eLg);-ns9|cX^i5XJ*hfp0yA#({ig{LrY9LPox8fZ=u~)l zkniq0f|iF83yp4{ucp0Lfr64snG+K${uu#j$ngNXdDYm+_byF70$_qMu}>nXgWuxs zxwBBuzAXGpzrWsv&C@P+z|CY(s{QV{A99-PEGlUy<*RFsVI^D`k2ugYy)@-F`oQ0L zFI8=@jlf0u+Bp*$?wjHaRDU&K5x+a6$FW=UfA_wut$;=~DwS?(Vc&eCp%B?@4f|$N z@udrUWsjv~_Lr*V^F9k;T8Iec`?Nf>OR2#oN zco*^pIDoOI*Gi24b}%5iWcW$BUEP`l$0#X6;zt@et4oQA@J#qn@9z$O6AtN$#0v7Jr|%)&%+oy zuQgt0sPHI2!Xp88pOe;b{BNt**O=%Ib<%mwqO*hW&*T4)Lq&49Q|KT`0|>k6){g9_ zPiaKk5n#y{%aWnHD$uWzmX-9@Wq+bFHY04ZVmCEDoZE7=9lRz=p9qU8L|1rT!9}A4 z*I4HS(maBDO~`mfj?pvy3&fKva8BkoV#5IIip=`iw`9ID>+kjLf4N9Xr;>x4gu(2Ms$8 zgGJ?f#`g|%h+sp-Zi^p6^1EcVJj^?Z=5Ni0Lrh_Kh>n9bYHGW)_u?)xCQJC1VMs$L zJ)l#kad#_crqD=5BLPAB9Ci~Rzj$7Q#!f17hi~_-hKv?Gqo6ULOg17@(^JJ&Ae)-0G@seEpD+iGJ6WvPzaOkQ zX}_EiW3#Vx4_DH_x?Aa$?*+X3CsEJ_hL%VZilT1ty6Jb<>N7aWekQVyvo_2+k>=7 zRgR|x>@+gBAPt1$3v|=Lg9pQK`RxKmj?36z_?goNZBXcv{1c;N>{}U{qn^pCE?rw) z?XR)>KP|w#l}QGDtDTmn&>g%1tol`#E3&Al6;C{F*`C7lPL-kl9(6;svZ1Il4cIEo zNLcf7_kVP&xOb<5>L97FdkxW;=o3JJ2Onn?E5$j&KLlwfI7cgXVqTAm8iP=eP%gjk z?k0>X7$NkmOf@`Pk06BxTLjiK%>5wwlBlDOHma13P;j>p4+?MZyRVa42NV1boa@qS z_ZM_K`N(`83?3;AR1{J} zON-NIb(k&*sF1hZKX~YnGOZO&prS@AmeIyB2K+e2W|ZKJHtjvW;3329O5(VGWX(XO zqq^q!m6=Vqy}Jra(oH=g4ZJQ#v9dGroMypIGhgYq?)A~xo1N}j$AvR98>8PhVkwhp ziP-b4#J)JXh1YSH?(35~|3ech*+1n!e_bNl=`j?fy&)!)YMiDZsbX;ohtX)7O&s$ zEQPRQf)$3I8qa+Q(_Z>M`8XoJd z;T+jM)tDV~JRC9EIHCA4A;hzWseZkQxIesx)S9U%cqWsPVk5QcZdv<(xwkU z^fYlzeo#2P%7`IIDJCq;gPo4`*RmHtAKnYRWK!`Vv&pN8$<@{^Y?qX}WaqxH4J_k#IQfR)nOAB1ID?)MA!y{v^cICX>+T@+H5jr%I(2|2^!Fqs0 z0zPiOlnxl*p<)B`VxkqoTzmG>^*VEb$yy<)kXJ6g#{>u0E_dUZh!wE`eFMeFNQDbX zw_Q~TCZX+<{e7^$dwMeAGJg8$dxDMbx*z@<0)8RUfSrXQ_yO%*;YD>JL+ECro<8N2 zi1eW?*!^au(Bwt)Hp+(-&)q_TC4j!GfiNRX`0q0=FWYGPZJqqdJWh@Mov0 zSMz?F@d^8Lv17#lZ^w|2Rn_A@k|MSVy(H@zc?fWi$2zre^SNHW^0U=2Z{#gaiTO_7 zT-L|}qw}sE%GzcJ-`aD1pK-$S#1^N$2u$ZyYpVoF=%;6bvbniD@nkixxrPS-9Ex7` z$!TeiI9=^5J)fm3HyCUTL%ao<()88jtGCXc=nUuk5V`%qz2>@CM}9=Tpu7HuN#GH= zB^^n%XF%0Ge@Eflr6R3w4~%$AgJWO*K=ddc347wynV*ZaQ8qw8n>OtMH`ISB7og%s zcM*144Mk|EQASq)$i$c7KTwyEbR;+uKT zh@kU@k6S9s%DSYmQve5-P2JjFf&j#`KH%M2*fsg^(qw$0^vkCpLn&UzR7v=IT*A zueL=`D2`CNR?_=J5b8t_ifSQT{yq^@RJ*99>UNahR?lVqVoLpRhHXuJv*2><3Sulz zg110-O^n}Pw`75wgzFX|W|%iOW*~ZOVG4UyCAOm?GKTwqz#|Ozzfk(Ih~y#_628Uk z?t`ti6cj;D@Giq*ckU)5??9_Q!U9&i|M(teo|*n#!yyq#QD4uLsmrkWuYU8igtpH7 zP6{&C2o_)|O}OIU4-L`5c7L6T@iMwIF^VoVy3IY9YMi;I5E7Us9F9$kc&z^R=cT%r zdOx7@DQCRStuJRuC;8kmqBr-EsF`dYUg8ZPdwe=`#J*9zF)Y`e;za(oQKmd4%ZtDdC5mQaS0J5hUV zyClPnhPSPqOJy#CjQfP{vF_~B@P5|9bDb`I_0?V?$VQbf0IIb;tPu@k?yci=o~-!k zARI<`jQ8~RVur!LvI0g48Ve4?5x+?u{t4ac8!nV4tlR}l;>(r#e}?lFtf}|78sd>g zfFW4S{?mM6B;9{IYR{)vw~z7c;R8JyB|Y*{v7-F70ee#XpuNObKzHaohFB`IyV%m0 zk?u~wc{ft$-lC!+h|XN^X@9xFHJHXX^@KUyv7U@8EPP;e_GN)vN-RTAfQrSaI8N1x z^8TCVipo+o(?^Di1V{q4t^(ZK{fI494_oTchn>O`DiQyC%G^G?-)qFNT&_t%Hc4R0 zdDl^~F_!1UyXH{m&a<(4mbj4dzr{~pvZDEfzRcDp#RW8^cY#=i9Sc?_)4`oVs<&`YL`A z-PSFTk(G1DlRp6b2TK>hkz*Lzf+-)56DY zrh4dp2wK(I1_rq< zGCZkfQH}CvUeXeO)O=HTw?dZk!2#6pbR9i!OgppSN7*%@;bX>K>axckMhI z*=0Ii8x3BrQ)6uXhuw`XAN7p?dF%O8xWkZ9PEE*cu#C>P^2Z=7BU>?rZt??Tx~vxs zC;?T#)PzhC$QX)2=xwdw-2t$N?SxpWkz50Fwvn!X?1SrI89(TYcMCFhB{pXKHA@`T zNWBYu%;X3csX#uy)Xdny{|{VJm;xP!!b)lbYn1n7u=1;do5CE9YT9*x41nAn=H=Q; z@J5IzkhzO^1+R#FZpb-sVFH~bo@O8cdmQ<uuwn`YDF)kySpIFuRJ+wO5dggeuqEU&o%dZnr>Q!% zk{EB~NSVE5a+h#`)n&x#@^NxGz4W-2)6Egf7bLXvR#=$c$Jygjp^ES*bE#2k!uYZ%4C+6|z)M^guHdA@^jH^Njhqi!dE*;6nw8`5N z7dB1*2YJ}T4u*ovHU9=nhi$x5X2nKtJ5H&@8zJl}qvV62sho6aU_$lhA-apt30ZBO zCm&yCT^*~J*Rr|*1=3aM6YownuTj0VU)pRLNqPPH>gd(9^y#bLk8800Okvj0V-_?n z-qoh#+_I4RQRnoJS2_dg*RH+)$YFWCc<^3>rG+G?gQz#xvEkaoHOIa-{N`)55~KX}YiYg0lQ9OW*^Y*rER! zk1Qg&U?~A{wu(g%97lgx%fuh~ay6O?r|62?)S)(&R3nXzoGB?}8y)p){i`?5lLuJ- zzM2TmtR5LNZ@zw|M`&>F)2C_-XX)Q;=P#Z4I4pmBhv%ij9P7QFrI(DKQWsI(gL3fm z@RiYtH;H5UJ9H|3na>$2F_h&5LMHLz+seA%^SZi?OPXU|TEc-$WcxCM50HJk{3p3- zY;~U{BSr6?;VDm#G3DI_1*yM&dqd^1$o;|U%ApdjxnT7nF|w-4`_ILcEwdgz4A|HZ zfu;JZ&JYIh4qMIkKLyl{IMdKcGe0j8pvb$oyF`yR?!c>yjnTs4xb5*I!Ks7!<&@6S zX4Gq+F0QQ1w-0RQGe}tu44)`sS)N?hl$0IYtc`7)8t`P64y|yxcrg>zXi5z5$i(uT z(p<9BD`oO~^Xr!+)D^H4eC23C2pzDJd)h)kMlp{a^@Y|3PH1_7XMLv&=8)rv?f4B* z!iP*CoFROPnjSNKVn4jEzgt*qAE@>i0?0uKO#AyUAr$)N#!~tj3yafuo&smGLI)Y5 z^5Ml&+B>Oy_-RN5%V7@9hx+gcdLpO^2?aW5%RL1&KC~%gn1}io13d8c_WAiDSCfR% zQFQ_3GiP=ZYBtzH@Dgo}5!#0$8)FlbHw(0%v|2yZG^ECF=a(F1k21Sx=P-LD*@imM z!>sbP`E_xCG!Pr16>O`LuCFRg2&t*5xU3H0N`ldsrxQhR^% z>4~2K+qN&DGLH=uXSZ;8QiAFv^7lPs_kuBK$LN^8%?|$PnMl%;gcsX z1vKtyGd1xq$@K_~mAT&Mz5Qu!e|VrUm3r2*rpzj{mrq3(N4%($+HDyYDTXgJ179gO zsq$T~&=Hn&X#kgs1IPwJhlIPpT?W&1HLpwMAWC7;-5Y{;#XYN*sr|)&?%qgmZ}Y-L z3vv;=_^p5*5i308rou9gGp`Ryy0+UMBB~4W3k#RvKbW{I%K`gfeSJFWk@qJKESOC8 zSEh8i2q@xVh!c}|8!5rPePh`{LN zABQ}0VWJ>fbAb|hHg5l^7NM7az=9&u#x~NsB1!%1>nl;b8Pi25ILF(VvAUX)lA^~P zg4k%HKV^7FPM23-A7#^}?B2}td&MlMT0KKip0|WtZH2{YzYRB(3J7pU#id@qgC`GEt6y zzFb|mS3|%2OROut7q1y1oeLbdcC36}u5P23uTGJ&J@7G1k=b-qglz3^#wT}aslMW> zsQpNb{ro5C0b`VHbr9v#SF3I@)f z^~CtYk@{FmiB^0X+7j%O(3IkcMnDkyVXoQkKQ)0W1$=u@sRGxzOm_GRUGL4d61b

V6p^DMWRt?Qn~%=^1p_ba47aj-YV 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

@4+M6#s9fD<~tTubG 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%0AG_)y0N7h^HE8_|3OoF;*=&=iaDSrPr^O)ngWW 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 diff --git a/ground/openpilotgcs/src/plugins/uploader/images/pipx.png b/ground/openpilotgcs/src/plugins/uploader/images/pipx.png deleted file mode 100644 index 47c8bb4e1885c159e5387238a2fc2ea8d9c84fcd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 184786 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 XL|AOM`2t4p)y2D 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�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 zjv=`3Aqav1D-eET2s*lu5(devicePicture->scene()->clear(); switch (id) { - case 0x0101: - case 0x0201: - devicePic.load(""); - break; case 0x0301: devicePic.load(":/uploader/images/gcs-board-oplink.png"); break; - case 0x0401: - devicePic.load(":/uploader/images/gcs-board-cc.png"); - break; - case 0x0402: - devicePic.load(":/uploader/images/gcs-board-cc3d.png"); - break; case 0x0903: devicePic.load(":/uploader/images/gcs-board-revo.png"); break; diff --git a/ground/openpilotgcs/src/plugins/uploader/uploader.qrc b/ground/openpilotgcs/src/plugins/uploader/uploader.qrc index d2cd82ca6..938a7c806 100644 --- a/ground/openpilotgcs/src/plugins/uploader/uploader.qrc +++ b/ground/openpilotgcs/src/plugins/uploader/uploader.qrc @@ -5,17 +5,9 @@ images/process-stop.svg images/dialog-apply.svg images/gtk-info.svg - images/deviceID-0401.svg - images/deviceID-0301.svg - images/deviceID-0201.svg - images/deviceID-0101.svg images/application-certificate.svg images/warning.svg images/error.svg - images/deviceID-0402.svg - images/gcs-board-cc.png - images/gcs-board-cc3d.png - images/pipx.png images/gcs-board-oplink.png images/gcs-board-revo.png diff --git a/ground/openpilotgcs/src/plugins/uploader/uploadergadgetwidget.cpp b/ground/openpilotgcs/src/plugins/uploader/uploadergadgetwidget.cpp index 35023fd78..3c2494d33 100644 --- a/ground/openpilotgcs/src/plugins/uploader/uploadergadgetwidget.cpp +++ b/ground/openpilotgcs/src/plugins/uploader/uploadergadgetwidget.cpp @@ -752,10 +752,6 @@ bool UploaderGadgetWidget::autoUpdate(bool erase) case 0x301: filename = "fw_oplinkmini"; break; - case 0x401: - case 0x402: - filename = "fw_coptercontrol"; - break; case 0x501: filename = "fw_osd"; break; @@ -814,7 +810,6 @@ bool UploaderGadgetWidget::autoUpdate(bool erase) commonSystemBoot(false, erase); // Wait for board to connect to GCS again after boot and erase - // For older board like CC3D this can take some time // Theres a special case with OPLink if (!telemetryManager->isConnected() && !m_oplinkwatchdog.isConnected()) { progressUpdate(erase ? BOOTING_AND_ERASING : BOOTING, QVariant()); diff --git a/ground/openpilotgcs/src/plugins/usagetracker/usagetrackerplugin.cpp b/ground/openpilotgcs/src/plugins/usagetracker/usagetrackerplugin.cpp index 10a1cb294..5cebee5af 100644 --- a/ground/openpilotgcs/src/plugins/usagetracker/usagetrackerplugin.cpp +++ b/ground/openpilotgcs/src/plugins/usagetracker/usagetrackerplugin.cpp @@ -178,18 +178,11 @@ void UsageTrackerPlugin::collectUsageParameters(QMap ¶mete parameters["conf_receiver"] = getUAVFieldValue(objManager, "ManualControlSettings", "ChannelGroups", 0); parameters["conf_vehicle"] = getUAVFieldValue(objManager, "SystemSettings", "AirframeType"); - if ((boardModel & 0xff00) == 0x0400) { - // CopterControl family - parameters["conf_rport"] = getUAVFieldValue(objManager, "HwSettings", "CC_RcvrPort"); - parameters["conf_mport"] = getUAVFieldValue(objManager, "HwSettings", "CC_MainPort"); - parameters["conf_fport"] = getUAVFieldValue(objManager, "HwSettings", "CC_FlexiPort"); - } else if ((boardModel & 0xff00) == 0x0900) { - // Revolution family - parameters["conf_rport"] = getUAVFieldValue(objManager, "HwSettings", "RM_RcvrPort"); - parameters["conf_mport"] = getUAVFieldValue(objManager, "HwSettings", "RM_MainPort"); - parameters["conf_fport"] = getUAVFieldValue(objManager, "HwSettings", "RM_FlexiPort"); - parameters["conf_fusion"] = getUAVFieldValue(objManager, "RevoSettings", "FusionAlgorithm"); - } + // Revolution family + parameters["conf_rport"] = getUAVFieldValue(objManager, "HwSettings", "RM_RcvrPort"); + parameters["conf_mport"] = getUAVFieldValue(objManager, "HwSettings", "RM_MainPort"); + parameters["conf_fport"] = getUAVFieldValue(objManager, "HwSettings", "RM_FlexiPort"); + parameters["conf_fusion"] = getUAVFieldValue(objManager, "RevoSettings", "FusionAlgorithm"); parameters["conf_uport"] = getUAVFieldValue(objManager, "HwSettings", "USB_HIDPort"); parameters["conf_vport"] = getUAVFieldValue(objManager, "HwSettings", "USB_VCPPort"); From 525aabe54c99be7bc9ade66c30cdb76f95083706 Mon Sep 17 00:00:00 2001 From: abeck70 Date: Wed, 13 May 2015 17:36:52 +1000 Subject: [PATCH 72/75] uncrustify flight gps updates --- flight/modules/GPS/GPS.c | 125 ++++++----- flight/modules/GPS/UBX.c | 2 +- flight/modules/GPS/inc/UBX.h | 67 +++--- flight/modules/GPS/inc/ubx_autoconfig.h | 38 ++-- flight/modules/GPS/ubx_autoconfig.c | 276 ++++++++++++------------ 5 files changed, 255 insertions(+), 253 deletions(-) diff --git a/flight/modules/GPS/GPS.c b/flight/modules/GPS/GPS.c index a0a12b4c3..28c586b1e 100644 --- a/flight/modules/GPS/GPS.c +++ b/flight/modules/GPS/GPS.c @@ -50,7 +50,7 @@ #include "UBX.h" #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) #include "inc/ubx_autoconfig.h" -//#include "../../libraries/inc/fifo_buffer.h" +// #include "../../libraries/inc/fifo_buffer.h" #endif #include @@ -196,7 +196,7 @@ int32_t GPSInitialize(void) GPSSettingsGet(&gpsSettings); // must updateHwSettings() before updateGpsSettings() so baud rate is set before GPS serial code starts running updateHwSettings(0); -#else +#else /* if defined(REVOLUTION) */ if (gpsPort && gpsEnabled) { GPSPositionSensorInitialize(); GPSVelocitySensorInitialize(); @@ -294,9 +294,9 @@ static void gpsTask(__attribute__((unused)) void *parameters) // need to do this whether there is received data or not, or the status (e.g. gcs) is not always correct int32_t ac_status = ubx_autoconfig_get_status(); static uint8_t lastStatus = GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DISABLED - + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_RUNNING - + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DONE - + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_ERROR; + + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_RUNNING + + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DONE + + GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_ERROR; gpspositionsensor.AutoConfigStatus = ac_status == UBX_AUTOCONFIG_STATUS_DISABLED ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DISABLED : ac_status == UBX_AUTOCONFIG_STATUS_DONE ? GPSPOSITIONSENSOR_AUTOCONFIGSTATUS_DONE : @@ -306,7 +306,7 @@ static void gpsTask(__attribute__((unused)) void *parameters) GPSPositionSensorAutoConfigStatusSet(&gpspositionsensor.AutoConfigStatus); lastStatus = gpspositionsensor.AutoConfigStatus; } -#endif +#endif /* if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) */ // This blocks the task until there is something on the buffer (or 100ms? passes) uint16_t cnt; @@ -509,72 +509,71 @@ static void updateHwSettings(UAVObjEvent __attribute__((unused)) *ev) // since 9600 baud and lower are not usable, and are best left at NEMA, I could have coded it to do a factory reset // - if set to 9600 baud (or lower) - if (gpsPort) { + if (gpsPort) { HwSettingsGPSSpeedOptions speed; - + #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) - // use 9600 baud during startup if autoconfig is enabled - // that is the flag that the code should assumes a factory default baud rate - if (ev == NULL && gpsSettings.UbxAutoConfig != GPSSETTINGS_UBXAUTOCONFIG_DISABLED) { - speed = HWSETTINGS_GPSSPEED_9600; - } - else + // use 9600 baud during startup if autoconfig is enabled + // that is the flag that the code should assumes a factory default baud rate + if (ev == NULL && gpsSettings.UbxAutoConfig != GPSSETTINGS_UBXAUTOCONFIG_DISABLED) { + speed = HWSETTINGS_GPSSPEED_9600; + } else #endif - { - // Retrieve settings - HwSettingsGPSSpeedGet(&speed); - } - - // must always set the baud here, even if it looks like it is the same - // e.g. startup sets 9600 here, ubx_autoconfig sets 57600 there, then the user selects a change back to 9600 here - - // on startup (ev == NULL) we must set the Revo port baud rate - // after startup (ev != NULL) we must set the Revo port baud rate only if autoconfig is disabled - // always we must set the Revo port baud rate if not using UBX + { + // Retrieve settings + HwSettingsGPSSpeedGet(&speed); + } + + // must always set the baud here, even if it looks like it is the same + // e.g. startup sets 9600 here, ubx_autoconfig sets 57600 there, then the user selects a change back to 9600 here + + // on startup (ev == NULL) we must set the Revo port baud rate + // after startup (ev != NULL) we must set the Revo port baud rate only if autoconfig is disabled + // always we must set the Revo port baud rate if not using UBX #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) - if (ev == NULL || gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED || gpsSettings.DataProtocol != GPSSETTINGS_DATAPROTOCOL_UBX) + if (ev == NULL || gpsSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_DISABLED || gpsSettings.DataProtocol != GPSSETTINGS_DATAPROTOCOL_UBX) #endif - { - // Set Revo port speed - switch (speed) { - case HWSETTINGS_GPSSPEED_2400: - PIOS_COM_ChangeBaud(gpsPort, 2400); - break; - case HWSETTINGS_GPSSPEED_4800: - PIOS_COM_ChangeBaud(gpsPort, 4800); - break; - case HWSETTINGS_GPSSPEED_9600: - PIOS_COM_ChangeBaud(gpsPort, 9600); - break; - case HWSETTINGS_GPSSPEED_19200: - PIOS_COM_ChangeBaud(gpsPort, 19200); - break; - case HWSETTINGS_GPSSPEED_38400: - PIOS_COM_ChangeBaud(gpsPort, 38400); - break; - case HWSETTINGS_GPSSPEED_57600: - PIOS_COM_ChangeBaud(gpsPort, 57600); - break; - case HWSETTINGS_GPSSPEED_115200: - PIOS_COM_ChangeBaud(gpsPort, 115200); - break; - case HWSETTINGS_GPSSPEED_230400: - PIOS_COM_ChangeBaud(gpsPort, 230400); - break; - } + { + // Set Revo port speed + switch (speed) { + case HWSETTINGS_GPSSPEED_2400: + PIOS_COM_ChangeBaud(gpsPort, 2400); + break; + case HWSETTINGS_GPSSPEED_4800: + PIOS_COM_ChangeBaud(gpsPort, 4800); + break; + case HWSETTINGS_GPSSPEED_9600: + PIOS_COM_ChangeBaud(gpsPort, 9600); + break; + case HWSETTINGS_GPSSPEED_19200: + PIOS_COM_ChangeBaud(gpsPort, 19200); + break; + case HWSETTINGS_GPSSPEED_38400: + PIOS_COM_ChangeBaud(gpsPort, 38400); + break; + case HWSETTINGS_GPSSPEED_57600: + PIOS_COM_ChangeBaud(gpsPort, 57600); + break; + case HWSETTINGS_GPSSPEED_115200: + PIOS_COM_ChangeBaud(gpsPort, 115200); + break; + case HWSETTINGS_GPSSPEED_230400: + PIOS_COM_ChangeBaud(gpsPort, 230400); + break; + } #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) - // even changing the baud rate will make it re-verify the sensor type - // that way the user can just try some baud rates and it when the sensor type is valid, the baud rate is correct - ubx_reset_sensor_type(); + // even changing the baud rate will make it re-verify the sensor type + // that way the user can just try some baud rates and it when the sensor type is valid, the baud rate is correct + ubx_reset_sensor_type(); #endif - } + } #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) - else { - // it will never do this during startup because ev == NULL - ubx_autoconfig_set(NULL); - } + else { + // it will never do this during startup because ev == NULL + ubx_autoconfig_set(NULL); + } #endif - } + } } #if defined(PIOS_INCLUDE_GPS_UBX_PARSER) && !defined(PIOS_GPS_MINIMAL) diff --git a/flight/modules/GPS/UBX.c b/flight/modules/GPS/UBX.c index 74ebc78e8..2fc61a283 100644 --- a/flight/modules/GPS/UBX.c +++ b/flight/modules/GPS/UBX.c @@ -470,7 +470,7 @@ static void parse_ubx_mon_ver(struct UBXPacket *ubx, __attribute__((unused)) GPS ((ubxHwVersion >= 70000) ? GPSPOSITIONSENSOR_SENSORTYPE_UBX7 : GPSPOSITIONSENSOR_SENSORTYPE_UBX); // send sensor type right now because on UBX NEMA we don't get a full set of messages // and we want to be able to see sensor type even on UBX NEMA GPS's - GPSPositionSensorSensorTypeSet((uint8_t *) &sensorType); + GPSPositionSensorSensorTypeSet((uint8_t *)&sensorType); } static void parse_ubx_op_sys(struct UBXPacket *ubx, __attribute__((unused)) GPSPositionSensorData *GpsPosition) diff --git a/flight/modules/GPS/inc/UBX.h b/flight/modules/GPS/inc/UBX.h index 51c8552fa..c4ea60357 100644 --- a/flight/modules/GPS/inc/UBX.h +++ b/flight/modules/GPS/inc/UBX.h @@ -366,36 +366,36 @@ struct UBX_ACK_NAK { // 0008 00 00 D0 08 00 00 80 25 // 0010 00 00 07 00 03 00 00 00 // 0018 00 00-A2 B5 -#define UBX_CFG_PRT_PORTID_DDC 0 -#define UBX_CFG_PRT_PORTID_UART1 1 -#define UBX_CFG_PRT_PORTID_UART2 2 -#define UBX_CFG_PRT_PORTID_USB 3 -#define UBX_CFG_PRT_PORTID_SPI 4 -#define UBX_CFG_PRT_MODE_DATABITS5 0x00 -#define UBX_CFG_PRT_MODE_DATABITS6 0x40 -#define UBX_CFG_PRT_MODE_DATABITS7 0x80 -#define UBX_CFG_PRT_MODE_DATABITS8 0xC0 -#define UBX_CFG_PRT_MODE_EVENPARITY 0x000 -#define UBX_CFG_PRT_MODE_ODDPARITY 0x200 -#define UBX_CFG_PRT_MODE_NOPARITY 0x800 +#define UBX_CFG_PRT_PORTID_DDC 0 +#define UBX_CFG_PRT_PORTID_UART1 1 +#define UBX_CFG_PRT_PORTID_UART2 2 +#define UBX_CFG_PRT_PORTID_USB 3 +#define UBX_CFG_PRT_PORTID_SPI 4 +#define UBX_CFG_PRT_MODE_DATABITS5 0x00 +#define UBX_CFG_PRT_MODE_DATABITS6 0x40 +#define UBX_CFG_PRT_MODE_DATABITS7 0x80 +#define UBX_CFG_PRT_MODE_DATABITS8 0xC0 +#define UBX_CFG_PRT_MODE_EVENPARITY 0x000 +#define UBX_CFG_PRT_MODE_ODDPARITY 0x200 +#define UBX_CFG_PRT_MODE_NOPARITY 0x800 #define UBX_CFG_PRT_MODE_STOPBITS1_0 0x0000 #define UBX_CFG_PRT_MODE_STOPBITS1_5 0x1000 #define UBX_CFG_PRT_MODE_STOPBITS2_0 0x2000 #define UBX_CFG_PRT_MODE_STOPBITS0_5 0x3000 -#define UBX_CFG_PRT_MODE_RESERVED 0x10 +#define UBX_CFG_PRT_MODE_RESERVED 0x10 -#define UBX_CFG_PRT_MODE_DEFAULT (UBX_CFG_PRT_MODE_DATABITS8 | UBX_CFG_PRT_MODE_NOPARITY | UBX_CFG_PRT_MODE_STOPBITS1_0 | UBX_CFG_PRT_MODE_RESERVED) +#define UBX_CFG_PRT_MODE_DEFAULT (UBX_CFG_PRT_MODE_DATABITS8 | UBX_CFG_PRT_MODE_NOPARITY | UBX_CFG_PRT_MODE_STOPBITS1_0 | UBX_CFG_PRT_MODE_RESERVED) struct UBX_CFG_PRT { uint8_t portID; // 1 or 2 for UART ports uint8_t res0; // reserved - uint16_t res1; // reserved - uint32_t mode; // bit masks for databits, stopbits, parity, and non-zero reserved - uint32_t baudRate; // bits per second, 9600 means 9600 - uint16_t inProtoMask; // bit 0 on = UBX, bit 1 on = NEMA + uint16_t res1; // reserved + uint32_t mode; // bit masks for databits, stopbits, parity, and non-zero reserved + uint32_t baudRate; // bits per second, 9600 means 9600 + uint16_t inProtoMask; // bit 0 on = UBX, bit 1 on = NEMA uint16_t outProtoMask; // bit 0 on = UBX, bit 1 on = NEMA - uint16_t flags; // reserved - uint16_t pad; // reserved + uint16_t flags; // reserved + uint16_t pad; // reserved } __attribute__((packed)); struct UBX_CFG_MSG { @@ -411,11 +411,11 @@ struct UBX_CFG_RATE { } __attribute__((packed)); // Mask for "all supported devices": battery backed RAM, Flash, EEPROM, SPI Flash -#define UBX_CFG_CFG_DEVICE_BBR 0x01 -#define UBX_CFG_CFG_DEVICE_FLASH 0x02 -#define UBX_CFG_CFG_DEVICE_EEPROM 0x04 -#define UBX_CFG_CFG_DEVICE_SPIFLASH 0x10 -#define UBX_CFG_CFG_DEVICE_ALL (UBX_CFG_CFG_DEVICE_BBR | UBX_CFG_CFG_DEVICE_FLASH | UBX_CFG_CFG_DEVICE_EEPROM | UBX_CFG_CFG_DEVICE_SPIFLASH) +#define UBX_CFG_CFG_DEVICE_BBR 0x01 +#define UBX_CFG_CFG_DEVICE_FLASH 0x02 +#define UBX_CFG_CFG_DEVICE_EEPROM 0x04 +#define UBX_CFG_CFG_DEVICE_SPIFLASH 0x10 +#define UBX_CFG_CFG_DEVICE_ALL (UBX_CFG_CFG_DEVICE_BBR | UBX_CFG_CFG_DEVICE_FLASH | UBX_CFG_CFG_DEVICE_EEPROM | UBX_CFG_CFG_DEVICE_SPIFLASH) #define UBX_CFG_CFG_SETTINGS_NONE 0x000 #define UBX_CFG_CFG_SETTINGS_IOPORT 0x001 #define UBX_CFG_CFG_SETTINGS_MSGCONF 0x002 @@ -426,14 +426,15 @@ struct UBX_CFG_RATE { #define UBX_CFG_CFG_SETTINGS_RINVCONF 0x200 #define UBX_CFG_CFG_SETTINGS_ANTCONF 0x400 -#define UBX_CFG_CFG_SETTINGS_ALL (UBX_CFG_CFG_SETTINGS_IOPORT | \ - UBX_CFG_CFG_SETTINGS_MSGCONF | \ - UBX_CFG_CFG_SETTINGS_INFMSG | \ - UBX_CFG_CFG_SETTINGS_NAVCONF | \ - UBX_CFG_CFG_SETTINGS_TPCONF | \ - UBX_CFG_CFG_SETTINGS_SFDRCONF | \ - UBX_CFG_CFG_SETTINGS_RINVCONF | \ - UBX_CFG_CFG_SETTINGS_ANTCONF) +#define UBX_CFG_CFG_SETTINGS_ALL \ + (UBX_CFG_CFG_SETTINGS_IOPORT | \ + UBX_CFG_CFG_SETTINGS_MSGCONF | \ + UBX_CFG_CFG_SETTINGS_INFMSG | \ + UBX_CFG_CFG_SETTINGS_NAVCONF | \ + UBX_CFG_CFG_SETTINGS_TPCONF | \ + UBX_CFG_CFG_SETTINGS_SFDRCONF | \ + UBX_CFG_CFG_SETTINGS_RINVCONF | \ + UBX_CFG_CFG_SETTINGS_ANTCONF) // Sent messages for configuration support struct UBX_CFG_CFG { diff --git a/flight/modules/GPS/inc/ubx_autoconfig.h b/flight/modules/GPS/inc/ubx_autoconfig.h index 343b755d8..eb3412385 100644 --- a/flight/modules/GPS/inc/ubx_autoconfig.h +++ b/flight/modules/GPS/inc/ubx_autoconfig.h @@ -33,9 +33,9 @@ // defines // TODO: NEO8 max rate is for Rom version, flash is limited to 10Hz, need to handle that. -#define UBX_MAX_RATE_VER8 18 -#define UBX_MAX_RATE_VER7 10 -#define UBX_MAX_RATE 5 +#define UBX_MAX_RATE_VER8 18 +#define UBX_MAX_RATE_VER7 10 +#define UBX_MAX_RATE 5 // reset to factory (and 9600 baud), and baud changes are not acked // it could be 31 (full PIOS buffer) + 60 (gnss) + overhead bytes at 240 bytes per second @@ -50,28 +50,30 @@ // rather than have long timeouts, we will let timeouts * retries handle that if it happens // timeout for ack reception -#define UBX_REPLY_TIMEOUT (500 * 1000) +#define UBX_REPLY_TIMEOUT (500 * 1000) // timeout for a settings save, in case it has to erase flash -#define UBX_REPLY_TO_SAVE_TIMEOUT (3000 * 1000) +#define UBX_REPLY_TO_SAVE_TIMEOUT (3000 * 1000) // max retries in case of timeout -#define UBX_MAX_RETRIES 5 +#define UBX_MAX_RETRIES 5 // pause between each verifiably correct configuration step -#define UBX_VERIFIED_STEP_WAIT_TIME (50 * 1000) +#define UBX_VERIFIED_STEP_WAIT_TIME (50 * 1000) // pause between each unverifiably correct configuration step -#define UBX_UNVERIFIED_STEP_WAIT_TIME (500 * 1000) +#define UBX_UNVERIFIED_STEP_WAIT_TIME (500 * 1000) -#define UBX_CFG_CFG_OP_STORE_SETTINGS (UBX_CFG_CFG_SETTINGS_IOPORT | \ - UBX_CFG_CFG_SETTINGS_MSGCONF | \ - UBX_CFG_CFG_SETTINGS_NAVCONF) +#define UBX_CFG_CFG_OP_STORE_SETTINGS \ + (UBX_CFG_CFG_SETTINGS_IOPORT | \ + UBX_CFG_CFG_SETTINGS_MSGCONF | \ + UBX_CFG_CFG_SETTINGS_NAVCONF) #define UBX_CFG_CFG_OP_CLEAR_SETTINGS ((~UBX_CFG_CFG_OP_STORE_SETTINGS) & UBX_CFG_CFG_SETTINGS_ALL) // don't clear rinv as that is just text as configured by the owner -#define UBX_CFG_CFG_OP_RESET_SETTINGS (UBX_CFG_CFG_SETTINGS_IOPORT | \ - UBX_CFG_CFG_SETTINGS_MSGCONF | \ - UBX_CFG_CFG_SETTINGS_INFMSG | \ - UBX_CFG_CFG_SETTINGS_NAVCONF | \ - UBX_CFG_CFG_SETTINGS_TPCONF | \ - UBX_CFG_CFG_SETTINGS_SFDRCONF | \ - UBX_CFG_CFG_SETTINGS_ANTCONF) +#define UBX_CFG_CFG_OP_RESET_SETTINGS \ + (UBX_CFG_CFG_SETTINGS_IOPORT | \ + UBX_CFG_CFG_SETTINGS_MSGCONF | \ + UBX_CFG_CFG_SETTINGS_INFMSG | \ + UBX_CFG_CFG_SETTINGS_NAVCONF | \ + UBX_CFG_CFG_SETTINGS_TPCONF | \ + UBX_CFG_CFG_SETTINGS_SFDRCONF | \ + UBX_CFG_CFG_SETTINGS_ANTCONF) // types typedef enum { diff --git a/flight/modules/GPS/ubx_autoconfig.c b/flight/modules/GPS/ubx_autoconfig.c index d27d87617..a38c7b52b 100644 --- a/flight/modules/GPS/ubx_autoconfig.c +++ b/flight/modules/GPS/ubx_autoconfig.c @@ -53,22 +53,22 @@ typedef enum { } initSteps_t; typedef struct { - initSteps_t currentStep; // Current configuration "fsm" status - initSteps_t currentStepSave; // Current configuration "fsm" status - uint32_t lastStepTimestampRaw; // timestamp of last operation - uint32_t lastConnectedRaw; // timestamp of last time gps was connected + initSteps_t currentStep; // Current configuration "fsm" status + initSteps_t currentStepSave; // Current configuration "fsm" status + uint32_t lastStepTimestampRaw; // timestamp of last operation + uint32_t lastConnectedRaw; // timestamp of last time gps was connected struct { - UBXSentPacket_t working_packet; // outbound "buffer" + UBXSentPacket_t working_packet; // outbound "buffer" // bufferPaddingForPiosBugAt2400Baud must exist for baud rate change to work at 2400 or 4800 // failure mode otherwise: // - send message with baud rate change // - wait 1 second (even at 2400, the baud rate change command should clear even an initially full 31 byte PIOS buffer much more quickly) // - change Revo port baud rate // sometimes fails (much worse for lowest baud rates) - uint8_t bufferPaddingForPiosBugAt2400Baud[2]; // must be at least 2 for 2400 to work, probably 1 for 4800 and 0 for 9600+ + uint8_t bufferPaddingForPiosBugAt2400Baud[2]; // must be at least 2 for 2400 to work, probably 1 for 4800 and 0 for 9600+ } __attribute__((packed)); volatile ubx_autoconfig_settings_t currentSettings; - int8_t lastConfigSent; // index of last configuration string sent + int8_t lastConfigSent; // index of last configuration string sent struct UBX_ACK_ACK requiredAck; // Class and id of the message we are waiting for an ACK from GPS uint8_t retryCount; } status_t; @@ -140,7 +140,7 @@ ubx_cfg_msg_t msg_config_ubx7[] = { // that is required to do a 100% correct configuration // but is unexpected because it changes the stored configuration when doing autoconfig.nostore // note that a reset is always done with autoconfig.store -//#define ALWAYS_RESET +// #define ALWAYS_RESET // private variables @@ -148,7 +148,7 @@ ubx_cfg_msg_t msg_config_ubx7[] = { static volatile bool enabled = false; static volatile bool current_step_touched = false; // both the pointer and what it points to are volatile. Yuk. -static volatile status_t * volatile status = 0; +static volatile status_t *volatile status = 0; static uint8_t hwsettings_baud; @@ -183,10 +183,10 @@ static uint16_t prepare_packet(UBXSentPacket_t *packet, uint8_t classID, uint8_t packet->message.header.len = len; append_checksum(packet); - status->requiredAck.clsID = classID; - status->requiredAck.msgID = messageID; + status->requiredAck.clsID = classID; + status->requiredAck.msgID = messageID; - return (len + sizeof(UBXSentHeader_t) + 2 + sizeof(status->bufferPaddingForPiosBugAt2400Baud)); // payload + header + checksum + extra bytes + return len + sizeof(UBXSentHeader_t) + 2 + sizeof(status->bufferPaddingForPiosBugAt2400Baud); // payload + header + checksum + extra bytes } @@ -213,8 +213,8 @@ static void set_current_step_if_untouched(initSteps_t new_steps) void ubx_reset_sensor_type() { ubxHwVersion = -1; - sensorType = GPSPOSITIONSENSOR_SENSORTYPE_UNKNOWN; - GPSPositionSensorSensorTypeSet((uint8_t *) &sensorType); + sensorType = GPSPOSITIONSENSOR_SENSORTYPE_UNKNOWN; + GPSPositionSensorSensorTypeSet((uint8_t *)&sensorType); } @@ -241,8 +241,8 @@ static void config_reset(uint16_t *bytes_to_send) static void config_gps_baud(uint16_t *bytes_to_send) { memset((uint8_t *)status->working_packet.buffer, 0, sizeof(UBXSentHeader_t) + sizeof(ubx_cfg_prt_t)); - status->working_packet.message.payload.cfg_prt.mode = UBX_CFG_PRT_MODE_DEFAULT; // 8databits, 1stopbit, noparity, and non-zero reserved - status->working_packet.message.payload.cfg_prt.portID = 1; // 1 = UART1, 2 = UART2 + status->working_packet.message.payload.cfg_prt.mode = UBX_CFG_PRT_MODE_DEFAULT; // 8databits, 1stopbit, noparity, and non-zero reserved + status->working_packet.message.payload.cfg_prt.portID = 1; // 1 = UART1, 2 = UART2 status->working_packet.message.payload.cfg_prt.inProtoMask = 1; // 1 = UBX only (bit 0) status->working_packet.message.payload.cfg_prt.outProtoMask = 1; // 1 = UBX only (bit 0) // Ask GPS to change it's speed @@ -455,7 +455,7 @@ static void configure(uint16_t *bytes_to_send) // Skip and fall through to next step status->lastConfigSent++; } - // in the else case we must fall through because we must send something each time because successful send is tested externally + // in the else case we must fall through because we must send something each time because successful send is tested externally case LAST_CONFIG_SENT_START + 3: config_sbas(bytes_to_send); @@ -488,138 +488,138 @@ static void enable_sentences(__attribute__((unused)) uint16_t *bytes_to_send) // End User Documentation // There are two baud rates of interest -// The baud rate the GPS is talking at -// The baud rate Revo is talking at -// These two must match for the GPS to work -// You only have direct control of the Revo baud rate -// The two baud rates must be the same for the Revo to send a command to the GPS -// to tell the GPS to change it's baud rate -// So you start out by changing Revo's baud rate to match the GPS's -// and then enable UbxAutoConfig to tell Revo to change the GPS baud every time, just before it changes the Revo baud -// That is the basis of these instructions +// The baud rate the GPS is talking at +// The baud rate Revo is talking at +// These two must match for the GPS to work +// You only have direct control of the Revo baud rate +// The two baud rates must be the same for the Revo to send a command to the GPS +// to tell the GPS to change it's baud rate +// So you start out by changing Revo's baud rate to match the GPS's +// and then enable UbxAutoConfig to tell Revo to change the GPS baud every time, just before it changes the Revo baud +// That is the basis of these instructions // There are microprocessors and they each have internal settings -// Revo -// GPS -// and each of these settings can be temporary or permanent +// Revo +// GPS +// and each of these settings can be temporary or permanent // To change a Revo setting -// Use the System tab in the GCS for all the following -// Example: in Settings->GPSSettings click on the VALUE for UbxAutoConfig and change it to Disabled -// Click on UbxAutoConfig itself and the line will turn green and blue -// To change this setting permanently, press the red up arrow (Save) at the top of the screen -// Permanently means that it uses this setting, even if you reboot Revo, e.g. power off and on -// To change this setting temporarily, press the green up arrow (Send) at the top of the screen -// Temporarily means that it overrides the permanent setting, but it goes back to the permanent setting when you reboot Revo, e.g. power off and on +// Use the System tab in the GCS for all the following +// Example: in Settings->GPSSettings click on the VALUE for UbxAutoConfig and change it to Disabled +// Click on UbxAutoConfig itself and the line will turn green and blue +// To change this setting permanently, press the red up arrow (Save) at the top of the screen +// Permanently means that it uses this setting, even if you reboot Revo, e.g. power off and on +// To change this setting temporarily, press the green up arrow (Send) at the top of the screen +// Temporarily means that it overrides the permanent setting, but it goes back to the permanent setting when you reboot Revo, e.g. power off and on // To change an internal GPS setting you use the OP GCS System tab to tell Revo to make the GPS changes -// This only works correctly after you have matching baud rates so Revo and GPS can talk together -// "Settings->GPSSettings->UbxAutoConfig = Configure" sets the internal GPS setting temporarily -// "Settings->GPSSettings->UbxAutoConfig = ConfigureAndStore" sets the internal GPS setting permanently +// This only works correctly after you have matching baud rates so Revo and GPS can talk together +// "Settings->GPSSettings->UbxAutoConfig = Configure" sets the internal GPS setting temporarily +// "Settings->GPSSettings->UbxAutoConfig = ConfigureAndStore" sets the internal GPS setting permanently // You want to wind up with a set of permanent settings that work together // There are two different sets of permanent settings that work together -// GPS at 9600 baud and factory defaults -// Revo configured to start out at 9600 baud, but then completely configure the GPS and switch both to 57600 baud -// (takes 6 seconds at boot up while you are waiting for it to acquire satellites anyway) -// This is the preferred way so that if we change the settings in the future, the new release will automatically use the correct settings -// GPS at 57600 baud with all the settings for the current release stored in the GPS -// Revo configured to disable UbxAutoConfig since all the GPS settings are permanently stored correctly -// May require reconfiguring in a future release +// GPS at 9600 baud and factory defaults +// Revo configured to start out at 9600 baud, but then completely configure the GPS and switch both to 57600 baud +// (takes 6 seconds at boot up while you are waiting for it to acquire satellites anyway) +// This is the preferred way so that if we change the settings in the future, the new release will automatically use the correct settings +// GPS at 57600 baud with all the settings for the current release stored in the GPS +// Revo configured to disable UbxAutoConfig since all the GPS settings are permanently stored correctly +// May require reconfiguring in a future release // Changable settings of interest -// AutoConfig mode -// Settings->GPSSettings->UbxAutoConfig (Disabled, Configure, ConfigureAndStore, default=Configure) -// Disabled means that changes to the GPS baud setting only affect the Revo port -// It doesn't try to change the GPS's internal baud rate setting -// Configure means change the GPS's internal baud setting temporarily (GPS settings revert to the permanent values when GPS is powered off/on) -// ConfigureAndStore means change the GPS's internal baud setting permanently (even after the GPS is powered off/on) -// GPS baud rate -// Settings->HwSettings->GPSSpeed -// If the baud rates are the same and an AutoConfig mode is enabled this will change both the GPS baud rate and the Revo baud rate -// If the baud rates are not the same and an AutoConfig mode is enabled it will fail -// If AutoConfig mode is disabled this will only change the Revo baud rate +// AutoConfig mode +// Settings->GPSSettings->UbxAutoConfig (Disabled, Configure, ConfigureAndStore, default=Configure) +// Disabled means that changes to the GPS baud setting only affect the Revo port +// It doesn't try to change the GPS's internal baud rate setting +// Configure means change the GPS's internal baud setting temporarily (GPS settings revert to the permanent values when GPS is powered off/on) +// ConfigureAndStore means change the GPS's internal baud setting permanently (even after the GPS is powered off/on) +// GPS baud rate +// Settings->HwSettings->GPSSpeed +// If the baud rates are the same and an AutoConfig mode is enabled this will change both the GPS baud rate and the Revo baud rate +// If the baud rates are not the same and an AutoConfig mode is enabled it will fail +// If AutoConfig mode is disabled this will only change the Revo baud rate // View only settings of interest -// Detected GPS type -// Data Objects -> GPSPositionSensor -> SensorType (Unknown, NMEA, UBX, UBX7, UBX8) -// When it says something other than Unknown, the GPS and Revo baud rates are synced and talking -// Real time progress of the GPS detection process -// Data Objects -> GPSPositionSensor -> AutoConfigStatus (DISABLED, RUNNING, DONE, ERROR) +// Detected GPS type +// Data Objects -> GPSPositionSensor -> SensorType (Unknown, NMEA, UBX, UBX7, UBX8) +// When it says something other than Unknown, the GPS and Revo baud rates are synced and talking +// Real time progress of the GPS detection process +// Data Objects -> GPSPositionSensor -> AutoConfigStatus (DISABLED, RUNNING, DONE, ERROR) // Syncing the baud rates means that the GPS's internal baud rate setting is the same as the Revo port setting -// This is necessary for the GPS to work with Revo +// This is necessary for the GPS to work with Revo // To sync to and find out an unknown GPS baud rate (or sync to and use a known GPS baud rate) -// Temporarily change the AutoConfig mode to Disabled -// Temporarily change the GPS baud rate to a value you think it might be (or go up the list) -// See if that baud rate is correct (Data Objects->GPSPositionSensor->SensorType will be something besides Unknown) -// Repeat, changing the GPS baud rate, until found +// Temporarily change the AutoConfig mode to Disabled +// Temporarily change the GPS baud rate to a value you think it might be (or go up the list) +// See if that baud rate is correct (Data Objects->GPSPositionSensor->SensorType will be something besides Unknown) +// Repeat, changing the GPS baud rate, until found // Some very important facts: -// For 9600 baud or lower, the autoconfig will configure it to factory default settings -// For 19200 baud or higher, the autoconfig will configure it to OP required settings -// If autoconfig is enabled permanently in Revo, it will assume that the GPS is configured to power up at 9600 baud -// 57600 baud is recommended for the current release -// That can be achieved either by -// autoconfiging the GPS from a permanent 9600 baud (and factory settings) to a temporary 57600 (with OP settings) on each power up -// or by configuring the GPS with a permanent 57600 (with OP settings) and then permanently disabling autoconfig -// Some previous releases used 38400 and had some other settings differences +// For 9600 baud or lower, the autoconfig will configure it to factory default settings +// For 19200 baud or higher, the autoconfig will configure it to OP required settings +// If autoconfig is enabled permanently in Revo, it will assume that the GPS is configured to power up at 9600 baud +// 57600 baud is recommended for the current release +// That can be achieved either by +// autoconfiging the GPS from a permanent 9600 baud (and factory settings) to a temporary 57600 (with OP settings) on each power up +// or by configuring the GPS with a permanent 57600 (with OP settings) and then permanently disabling autoconfig +// Some previous releases used 38400 and had some other settings differences // The user should either: // Permanently configure their GPS to 9600 baud factory settings and tell the Revo configuration to load volatile settings at each startup by: -// (Recommended method because new versions could require new settings and this handles future changes automatically) -// Syncing the baud rates -// Setting it to autoconfig.nostore and waiting for it to complete -// Setting HwSettings.GPSSpeed to 9600 and waiting for it to complete -// Setting it to autoconfig.store and waiting for it to complete (this tells the GPS to store the 9600 permanently) -// Permanently setting it to autoconfig.nostore and waiting for it to complete -// Permanently setting HwSettings.GPSSpeed to 57600 and waiting for it to complete +// (Recommended method because new versions could require new settings and this handles future changes automatically) +// Syncing the baud rates +// Setting it to autoconfig.nostore and waiting for it to complete +// Setting HwSettings.GPSSpeed to 9600 and waiting for it to complete +// Setting it to autoconfig.store and waiting for it to complete (this tells the GPS to store the 9600 permanently) +// Permanently setting it to autoconfig.nostore and waiting for it to complete +// Permanently setting HwSettings.GPSSpeed to 57600 and waiting for it to complete // Permanently configure their GPS to 57600 baud, including OpenPilot settings and telling the Revo configuration to just set the baud to 57600 at each startup by: -// (Less recommended method because new versions could require new settings so you would have to do this again) -// Syncing the baud rates -// Setting it to autoconfig.nostore and waiting for it to complete -// Permanently setting HwSettings.GPSSpeed to 57600 and waiting for it to complete -// Setting it to autoconfig.store -// Permanently setting it to autoconfig.disabled +// (Less recommended method because new versions could require new settings so you would have to do this again) +// Syncing the baud rates +// Setting it to autoconfig.nostore and waiting for it to complete +// Permanently setting HwSettings.GPSSpeed to 57600 and waiting for it to complete +// Setting it to autoconfig.store +// Permanently setting it to autoconfig.disabled // The algorithm is: // If autoconfig is enabled at all -// It will assume that the GPS boot up baud rate is 9600 and the user wants that changed to HwSettings.GPSSpeed -// and that change can be either volatile (must be done each boot up) or non-volatile (stored in GPS's non-volatile settings storage) -// according to whether CONFIGURE is used or CONFIGUREANDSTORE is used -// The only user who should need CONFIGUREANDSTORE stored permanently in Revo is Dave, who configures many OP GPS's before shipping -// plug a factory default GPS in to a Revo, power up, wait for it to configure and permanently store in the GPS, power down, ship +// It will assume that the GPS boot up baud rate is 9600 and the user wants that changed to HwSettings.GPSSpeed +// and that change can be either volatile (must be done each boot up) or non-volatile (stored in GPS's non-volatile settings storage) +// according to whether CONFIGURE is used or CONFIGUREANDSTORE is used +// The only user who should need CONFIGUREANDSTORE stored permanently in Revo is Dave, who configures many OP GPS's before shipping +// plug a factory default GPS in to a Revo, power up, wait for it to configure and permanently store in the GPS, power down, ship // If autoconfig is not enabled -// it will use HwSettings.GPSSpeed for the baud rate and not do any configuration changes +// it will use HwSettings.GPSSpeed for the baud rate and not do any configuration changes // If GPSSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_CONFIGUREANDSTORE it will -// 1 Reset the permanent configuration back to factory default -// 2 Disable NEMA message settings -// 3 Add some volatile UBX settings to the copies of the non-volatile ones that are currently running -// 4 Save the current volatile settings to non-volatile storage +// 1 Reset the permanent configuration back to factory default +// 2 Disable NEMA message settings +// 3 Add some volatile UBX settings to the copies of the non-volatile ones that are currently running +// 4 Save the current volatile settings to non-volatile storage // If GPSSettings.UbxAutoConfig == GPSSETTINGS_UBXAUTOCONFIG_CONFIGURE it will -// 2 Disable NEMA message settings -// 3 Add some volatile UBX settings to the copies of the non-volatile ones that are currently running +// 2 Disable NEMA message settings +// 3 Add some volatile UBX settings to the copies of the non-volatile ones that are currently running // If the requested baud rate is 9600 or less it skips the step (3) of adding some volatile UBX settings // Talking points to point out: -// U-center is no longer needed for any use case with this code -// 9600 is factory default for GPS's -// Some GPS can't even permanently store settings and must start at 9600 baud? -// I have a GPS that sometimes looses settings and reverts to 9600 and this is a fix for that too :) -// This code handles a GPS configured either way (9600 with factory default settings or e.g. 57600 with OP settings) -// Autoconfig.nostore at each boot for 9600, autoconfig.disabled for the 57600 with OP settings (or custom settings and baud) -// This code can permanently configure a GPS to be e.g. 9600 with factory default settings or 57600 with OP settings -// GPS's with 9600 baud and factory default settings would be a good default for future OP releases -// Changing the GPS internal settings multiple times in the future is handled automatically -// This code is written to do a configure from 9600 to 57600 -// (actually 9600 to whatever is stored in HwSettings.GPSSpeed) -// if autoconfig is enabled at boot up -// When autoconfiging to 9600 baud or lower, the autoconfig will configure it to factory default settings, not OP settings -// That is because 9600 baud drops many of the OP messages and because 9600 baud is factory default -// For 19200 baud or higher, the autoconfig will configure it to OP required settings -// If autoconfig is enabled permanently in Revo, it will assume that the GPS is configured to power up at 9600 baud -// This is good for factory default GPS's -// This is good in case we change some settings in a future release +// U-center is no longer needed for any use case with this code +// 9600 is factory default for GPS's +// Some GPS can't even permanently store settings and must start at 9600 baud? +// I have a GPS that sometimes looses settings and reverts to 9600 and this is a fix for that too :) +// This code handles a GPS configured either way (9600 with factory default settings or e.g. 57600 with OP settings) +// Autoconfig.nostore at each boot for 9600, autoconfig.disabled for the 57600 with OP settings (or custom settings and baud) +// This code can permanently configure a GPS to be e.g. 9600 with factory default settings or 57600 with OP settings +// GPS's with 9600 baud and factory default settings would be a good default for future OP releases +// Changing the GPS internal settings multiple times in the future is handled automatically +// This code is written to do a configure from 9600 to 57600 +// (actually 9600 to whatever is stored in HwSettings.GPSSpeed) +// if autoconfig is enabled at boot up +// When autoconfiging to 9600 baud or lower, the autoconfig will configure it to factory default settings, not OP settings +// That is because 9600 baud drops many of the OP messages and because 9600 baud is factory default +// For 19200 baud or higher, the autoconfig will configure it to OP required settings +// If autoconfig is enabled permanently in Revo, it will assume that the GPS is configured to power up at 9600 baud +// This is good for factory default GPS's +// This is good in case we change some settings in a future release void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) @@ -685,20 +685,20 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) case INIT_STEP_RESET_GPS: // make sure we don't change the baud rate too soon and garble the packet being sent // even after pios says the buffer is empty, the serial port buffer still has data in it - // and changing the baud will screw it up + // and changing the baud will screw it up // when the GPS is configured to send a lot of data, but has a low baud rate - // it has way too many messages to send and has to drop most of them + // it has way too many messages to send and has to drop most of them // Retrieve desired GPS baud rate once for use throughout this module HwSettingsGPSSpeedGet(&hwsettings_baud); #if !defined(ALWAYS_RESET) // ALWAYS_RESET is undefined because it causes stored settings to change even with autoconfig.nostore - // but with it off, some settings may be enabled that should really be disabled (but aren't) after autoconfig.nostore + // but with it off, some settings may be enabled that should really be disabled (but aren't) after autoconfig.nostore // if user requests a low baud rate then we just reset and leave it set to NEMA - // because low baud and high OP data rate doesn't play nice + // because low baud and high OP data rate doesn't play nice // if user requests that settings be saved, we will reset here too // that makes sure that all strange settings are reset to factory default - // else these strange settings may persist because we don't reset all settings by table + // else these strange settings may persist because we don't reset all settings by table if (status->currentSettings.storeSettings) #endif { @@ -715,10 +715,10 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) case INIT_STEP_REVO_9600_BAUD: #if !defined(ALWAYS_RESET) // if user requests a low baud rate then we just reset and leave it set to NEMA - // because low baud and high OP data rate doesn't play nice + // because low baud and high OP data rate doesn't play nice // if user requests that settings be saved, we will reset here too // that makes sure that all strange settings are reset to factory default - // else these strange settings may persist because we don't reset all settings by hand + // else these strange settings may persist because we don't reset all settings by hand if (status->currentSettings.storeSettings) #endif { @@ -729,12 +729,12 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) // set the Revo GPS port to 9600 baud to match the reset to factory default that has already been done config_baud(HWSETTINGS_GPSSPEED_9600); } - // at most, we just set Revo baud and that doesn't send any data - // fall through to next state - // we can do that if we choose because we haven't sent any data in this state - // set_current_step_if_untouched(INIT_STEP_GPS_BAUD); - // allow it enter the next state immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); - // break; + // at most, we just set Revo baud and that doesn't send any data + // fall through to next state + // we can do that if we choose because we haven't sent any data in this state + // set_current_step_if_untouched(INIT_STEP_GPS_BAUD); + // allow it enter the next state immmediately by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); + // break; case INIT_STEP_GPS_BAUD: // https://www.u-blox.com/images/downloads/Product_Docs/u-bloxM8_ReceiverDescriptionProtocolSpec_%28UBX-13003221%29_Public.pdf @@ -765,7 +765,7 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) // set the Revo GPS port baud rate to the (same) user configured value config_baud(hwsettings_baud); status->lastConfigSent = LAST_CONFIG_SENT_START; - status->retryCount = 0; + status->retryCount = 0; // skip enabling UBX sentences for low baud rates // low baud rates are not usable, and higher data rates just makes it harder for this code to change the configuration if (hwsettings_baud <= HWSETTINGS_GPSSPEED_9600) { @@ -814,7 +814,7 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) status->retryCount = 0; status->lastConfigSent++; } else if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_REPLY_TIMEOUT && - (ubxLastNak.clsID != status->requiredAck.clsID || ubxLastNak.msgID != status->requiredAck.msgID)) { + (ubxLastNak.clsID != status->requiredAck.clsID || ubxLastNak.msgID != status->requiredAck.msgID)) { // allow timeouts to count up by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); break; } else { @@ -853,15 +853,15 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) if (ubxLastAck.clsID == status->requiredAck.clsID && ubxLastAck.msgID == status->requiredAck.msgID) { // Continue with next configuration option set_current_step_if_untouched(INIT_STEP_DONE); - // note that we increase the reply timeout in case the GPS must do a flash erase + // note that we increase the reply timeout in case the GPS must do a flash erase } else if (PIOS_DELAY_DiffuS(status->lastStepTimestampRaw) < UBX_REPLY_TO_SAVE_TIMEOUT && - (ubxLastNak.clsID != status->requiredAck.clsID || ubxLastNak.msgID != status->requiredAck.msgID)) { + (ubxLastNak.clsID != status->requiredAck.clsID || ubxLastNak.msgID != status->requiredAck.msgID)) { // allow timeouts to count up by not setting status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); break; } else { // timeout or NAK, resend the message or abort status->retryCount++; - if (status->retryCount > UBX_MAX_RETRIES/2) { + if (status->retryCount > UBX_MAX_RETRIES / 2) { // give up on the retries set_current_step_if_untouched(INIT_STEP_ERROR); status->lastStepTimestampRaw = PIOS_DELAY_GetRaw(); @@ -875,7 +875,7 @@ void ubx_autoconfig_run(char * *buffer, uint16_t *bytes_to_send) case INIT_STEP_ERROR: // on error we should get the GPS version immediately ubx_reset_sensor_type(); - // fall through + // fall through case INIT_STEP_DISABLED: case INIT_STEP_DONE: break; @@ -901,7 +901,7 @@ void ubx_autoconfig_set(ubx_autoconfig_settings_t *config) } if (status->currentSettings.autoconfigEnabled) { new_step = INIT_STEP_START; - } else { + } else { new_step = INIT_STEP_DISABLED; } From 8e8d08c4a1979534298b825f950a4aab8576eb88 Mon Sep 17 00:00:00 2001 From: Laurent Lalanne Date: Wed, 13 May 2015 21:55:18 +0200 Subject: [PATCH 73/75] OP-1869 "scale" lower case --- flight/modules/Airspeed/baro_airspeed_mpxv.c | 2 +- flight/pios/common/pios_mpxv.c | 2 +- flight/pios/inc/pios_mpxv.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/flight/modules/Airspeed/baro_airspeed_mpxv.c b/flight/modules/Airspeed/baro_airspeed_mpxv.c index 2869a5d12..5c7ead777 100644 --- a/flight/modules/Airspeed/baro_airspeed_mpxv.c +++ b/flight/modules/Airspeed/baro_airspeed_mpxv.c @@ -104,7 +104,7 @@ void baro_airspeedGetMPXV(AirspeedSensorData *airspeedSensor, AirspeedSettingsDa } } sensor.zeroPoint = airspeedSettings->ZeroPoint; - sensor.Scale = airspeedSettings->Scale; + sensor.scale = airspeedSettings->Scale; // Filter CAS : airspeedSettings->SamplePeriod value is 0 - 255 range float alpha = 1 - (airspeedSettings->SamplePeriod / ANALOG_BARO_AIRSPEED_TIME_CONSTANT_MS); // Low pass filter. diff --git a/flight/pios/common/pios_mpxv.c b/flight/pios/common/pios_mpxv.c index 9c9c88aa1..dc08d6ed2 100644 --- a/flight/pios/common/pios_mpxv.c +++ b/flight/pios/common/pios_mpxv.c @@ -69,7 +69,7 @@ uint16_t PIOS_MPXV_Calibrate(PIOS_MPXV_descriptor *desc, uint16_t measurement) float PIOS_MPXV_CalcAirspeed(PIOS_MPXV_descriptor *desc, uint16_t measurement) { // Calculate dynamic pressure, as per docs - Apply scale factor (voltage divider) - float Qc = 3.3f / 4096.0f * (float)((measurement - desc->zeroPoint) * desc->Scale); + float Qc = 3.3f / 4096.0f * (float)((measurement - desc->zeroPoint) * desc->scale); // Saturate Qc on the lower bound, in order to make sure we don't have negative airspeeds. No need // to saturate on the upper bound, we'll handle that later with calibratedAirspeed. diff --git a/flight/pios/inc/pios_mpxv.h b/flight/pios/inc/pios_mpxv.h index f68b1f386..842e66335 100644 --- a/flight/pios/inc/pios_mpxv.h +++ b/flight/pios/inc/pios_mpxv.h @@ -38,7 +38,7 @@ typedef struct { uint16_t calibrationCount; uint32_t calibrationSum; uint16_t zeroPoint; - float Scale; + float scale; float maxSpeed; } PIOS_MPXV_descriptor; From 4c794ff9ab2fbe17e6aa0ba41e4ea2f0d096823f Mon Sep 17 00:00:00 2001 From: Cliff Geerdes Date: Thu, 14 May 2015 02:35:59 -0400 Subject: [PATCH 74/75] OP-1840 set ubx autoconfig default to disabled --- shared/uavobjectdefinition/gpssettings.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shared/uavobjectdefinition/gpssettings.xml b/shared/uavobjectdefinition/gpssettings.xml index ef69c8cb8..129faa688 100644 --- a/shared/uavobjectdefinition/gpssettings.xml +++ b/shared/uavobjectdefinition/gpssettings.xml @@ -6,7 +6,7 @@ - + From d6751172aed3334caf2abb9ffda8eeb4818b7cd5 Mon Sep 17 00:00:00 2001 From: Alex Beck Date: Thu, 14 May 2015 20:34:32 +1000 Subject: [PATCH 75/75] OP-1848 altvario fix simposix build --- flight/targets/boards/simposix/firmware/Makefile | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/flight/targets/boards/simposix/firmware/Makefile b/flight/targets/boards/simposix/firmware/Makefile index 70673a563..7d1f30ff4 100644 --- a/flight/targets/boards/simposix/firmware/Makefile +++ b/flight/targets/boards/simposix/firmware/Makefile @@ -63,6 +63,8 @@ FLIGHTLIB = ../../../../libraries FLIGHTLIBINC = $(FLIGHTLIB)/inc MATHLIB = $(FLIGHTLIB)/math MATHLIBINC = $(FLIGHTLIB)/math +PIDLIB = $(FLIGHTLIB)/pid +PIDLIBINC = $(FLIGHTLIB)/pid PIOSPOSIX = $(PIOS)/posix PIOSCOMMON = $(PIOS)/posix PIOSCORECOMMON = $(PIOS)/common @@ -111,6 +113,7 @@ SRC += $(MATHLIB)/sin_lookup.c SRC += $(MATHLIB)/pid.c SRC += $(MATHLIB)/mathmisc.c SRC += $(MATHLIB)/butterworth.c +CPPSRC += $(PIDLIB)/pidcontroldown.cpp SRC += $(PIOSCORECOMMON)/pios_task_monitor.c ifeq ($(USE_YAFFS),YES) @@ -145,6 +148,7 @@ EXTRAINCDIRS += $(OPUAVOBJINC) EXTRAINCDIRS += $(UAVOBJSYNTHDIR) EXTRAINCDIRS += $(FLIGHTLIBINC) EXTRAINCDIRS += $(MATHLIBINC) +EXTRAINCDIRS += $(PIDLIBINC) EXTRAINCDIRS += $(PIOSCOMMON) EXTRAINCDIRS += $(CMSISDIR) EXTRAINCDIRS += $(OPUAVSYNTHDIR)

Ru?x{Jg7Z?B9LgFq}8jhU|Ll8#eN_bU$NF zKCVeTeQOkGmyF>!!yP(oi}iI?2VgXhH}jYeP?G0b@P6)-Dzb*FBP>C&D_kk^gGIMq zunSKVCoztGN>{p4sJ0=xPtdjHGd0!WRVd~uDq1_KPE;Uqkf&^i%@b65ED@6Me)i%W zbXE$Cld^$M$DG}6kk?qQ;~Yi*qptZ>-93hxGK>MnOkZG{)#YJ@W2OupGcLXB-KcZE zZav$2(`LWP_GU5RdOWz@`(MmsHWQnHu-DN${IcyZ+3e5#)R4%O{uYmXxQ3E zi1W9n`Mu0}^E+ ztB_n1qAygJhpvoqrsj!q_8Mr4< zY~_m@PU9h(3j-D0pz9@=KUC!r8|Kv}p*vZcZW({RJ)%^o6YL(1W$g5fFMbz41|!wKym<&9IbKFoa7R?ormI-L%h$LlXtM1X*+zZ( z*!lW*E5>e?_`i7zW`H{pC+@s34zZR~BfH<<+XGeWazGyk(61x!)Al|3yatMGt!=eY z%>2n=HC$uKoO(nS@4&sBLA%7+JJ~Y<~t`jxYerzP|v~0QSJb`m<$4S{5SYDc>`W z6^}5U&G{}@GvY1OEgsa2o91Hbt6V%bTDV8dMJ2J3h=0$TAN}_Jz4DC+`+b>cEJ&J` z`yd#*?njrgLm~cGg0-=Ce>J4*h7nDbEPkZla;=T=5xl^7cvFB?Mhre2zB`;VrG($2 z7F79?nq|$;RKh}XeFJs3n36KpQs%wp$6yys;scjFJG9I&c6U`s-o&jw3(x0~XN4VLdk%r_y73F@4g~JT-{tndKZ>k$##uc4>eu>uM$R;Ty9M-j7TY6-QnB)0Ki99BX!1VhHI2|SDR#)#4|k# zSynDn9&Zd}Ix!-@@)ISvis0AHV zU)Nq}J%sl~GJ03^KdcPFWNKYsxl(d7!eqQJG)OsnBM0_5I;jB~rR zR~OfIF0>SKl0E0u@}#;x9TlIKg^G25M;t|!=7xTecY}#(I*}++&1`HiBI|CjfUN^p z7MhZpTI;btoA+lBDI59q%N976u?h+@X#_0FE(r+;HjthwBx?(-c55Jx{XzK*XTZQW z!_ivisy4yu-N4I)$w+OiIq3nLAy54D?$HSpqf?d;KW_A*&+uT~_V;J4olXo#;-M$5 z7~8HG)eji*qyGl3q)9m~_)CPpLN^Zig@G2LQh7NH=|Ct;D2$L%?ve9tqE?Rt|C>~j z*a|!<(hEWip{|K^rDMlF{Z^tPdx1gy{)2o{;qw7Eyz>`Les<;~=FW!cx5^hwTbVV9*y9ZCVL2V+lR8n;7 z&%@B4--r;j21nxX>g6=w)BEEGH8%&5_=_NB$kIVDu(D=s=ezNS5fnU2p8! zw2wuxZHTQhwm-YGxJIP5kHg+!88HFAS45Ty8s(RWDPz5KNc)usUElA`}@5%Qr8ARhlYG#I?rBp zhIC$4boNY4XiU6K3qY_$jM{H`)8lRU6TBZz{y;dZKu{VKa%7P?jS8jz*Hmgx^fMF6 zPHFMUfhNW3`KE-Bht_b`p-d*5Xa)Xw}{k@l#`8TU`EVEv z)FEn-D+IdsKUq#FQnQhK`@D9`+>YGRotc2FMUDfy3$x*A67in2ba8JuosshE&!0O*vFtna(nqFl zfyTj66|M|kBu`5Mq-h(<pKT>qtFF zwCA7v{`-d}%=>A$*K>&}Dr{qPs3tK_vlKY%KqNUF(FOiTYJJW}k-eqBE065&1;Z(Z zfF#Q=Vp(gyJ#e>xZYTt(dRlU7#Rqj<7rXvXDbUKm51%UFbRa0Dn#p;oT7GWivVrR#96tc9)Cg0Rj>TLysMi3Fn@^SdMyL%ANW>K^2}mK4+nK z)5x7_x(NxRI^VRosWd^YD;Fa{O(Kp~*S>REO8)hjMr=l6pnt3KxloMhlm?zQT1tv& zY}TjYOQq1mTlYWyUzUg9%kD;hfBB1H;yU1Ss{&F)xs zFNi)Ad-4Qr_*K(kgXP<^+&Kkrp0L4^bo7vIx2i^2w}U=AN6uam6-bh{dV9$R79`y$ zT8rBAT1d4Q)ac>+UQOi=fIbw|@zcHA$1xxVERa7GSz(iwn>%Rq?nelK4(Xzzq5@O- zXnm$55!32_t*p7p0;-3e@jYnJ?Vi82gQLR_qs?Ay zF?kZilg(oJ6doVewmgo*g>evp{j@>IT-9Ov@o6$|hv#IvNmUg%HGco^)G!5L z!#k(trsD|Tj-z+<-)jWAT;8jNzq*nRt!D@g&9if*n^e{pzd>KN!$9o*4n+ZD#=qXVkeIEvTZIOpWF5L*Xg%`3 zmzQZ*Ktam}(}PQ>Q^%z>h)IOPgQ%$~+!j|4ST4SVUqfq#y_X*2p&{Rgo*q;{Pg}i@ zcx1o4{8n(inbP>XlW%Gr4_7W7!&5=qa++W3KGaLLKRRH(&mNQmAuAYdL$t~e04PT$ zz+FUjUf_bZzufMvE#{45&rR=!pUjEFYd}AW++I*YM<9@-gOqjB89U*h7FEq$d;{w( z#-^4v2Wrjudr}qN6kp|Ju`xDjXUbVN#SJND7-ztyp7 z#Ie;InvTHYN3M<^NJd2Tv(qXJ1VbU!Bm90ca_ats8!l51oHloR&jRwD0v%p@`!w+q zzVOgVlWP1W8oM62oXbM&t}WRqW-IBt+;i9a$U#ARE-=xC%Or~nhoWN5V{UgPQS}#E z5^?u!P(+K`nm4IR^^;mUUEhBi+Mawp_7DC;q{+e^9{DVRI*86CfKBkqK6WAx+RUhg zeK|wRbYpO7Cp#_;e(mB}{ux5SXo9(PC2P`6LvD#jPhXsCP}0h{K=Et(W4pRq&x zWm-x9lm1UCf3sf8i65lpzGV|9T{2||H7FYJ?5=%64aG;pkf8EEcBa*X-_u_>j?71- z$q=1$`Cz5ubk%LsY8RcPdxh4Ye)t51?Cx4R zlZ&j@4k{xovmPC+9_{v7q0?N661(JSSvecVzErhZ|Co0tnU)pYWFDN7kARIaKVgi= zU@(ePjKgN>tGigf>y27}}&sv*z$Zq}Y24*ZiSMr{F!B?B7qsRaE#%J&WD9rb`> zEVCUkv^UaX*`d|@NXE&^fGe71{FLwU<1hda0x`iF$T`LD&fE{I-VeMfPgW=}YLo4~ zctvFfPgfOGnd$>Io#DQcaUfJoL;3id;5Z0S8Tnh1RP8Nxd%CuJ9B&wDBd@c$^4XR| zWY>?=psH%!r))gW@AsaC)1x|?rIb()rgewELkJ0Sv&$Kr8hyE%n3IQROz@btf;(@C z_-lYli1_@APCC0dlUf{aKl4df!3088IdyeHr?z8x~(Avyc`S|Hc)Aiy2L64%WsOhmsl>oVmb3T{_a&RZ@P^u~vu^iQPAgg!;F z#M&4$Pc#hduC~#lYN39mRImvXs>Fr}R_C`062!zGX#=?~e&NR%6{GDS;8O?_no0>RYnLyslH zaK$WLk3%I*eJB(k@x+v$eIUg6$fhZNLNZ@u9>0Y;h9m;rXUWNUs-~WzDf168dLvDHrrJ^Guu-icDd>80Ij!-T_ zg~*62a(StZG_*p^oonsg%FaV;tfE2JIxd(?<$#XU_HW~fKuC@4yPnRv)!EJ0XDWKt zOUiN@Vr+{>CaEn$t$_^Ig=Iz_ju#SeZBK-{#?9?VoWEcy$zUapD6Hg;8xXb^R^OJu zj!V^w1X0=I7i+=uAnxvw(=xL51No*ttbbhva(@g{l?a10&Ys9_YII&>p(iWj7i}XG zRxFI=q80RuOBZ!JOSF`jakDAu6&Z=n=R!srxrD({QDl{8F8o1U**3m53Nb5H43xdN zv?5>E`14*`C}#NmtC+}GjQv)}B7rSk#Ol0*s_+%htM%rLU{0h~!qgoyRA?C}GxiMj zrKc$)7f{A*A{*WX+JbE+j(Vo0VNB_3r3-aLV^)TdzlS*Yss~-nLM=}DLaM_o1L8TN zDunY3tr0GPOoPw;JNM8qKfQmx)7v87C4$&jHc0^rw&&7NA_PS6^dDiz{e>3txaY9NfcXa^f3HjIMLJV71h z3o;J^TOn>xYK>=;{80(&nl!H8XzxqWQD-W@gBAdVnZ_!-Qb=o$$x+d*^R! zs@~C7{8;6r$B+(QU;Vi4jH_{Gw6*>5*RAe*PBcG{o@YfXB@y$}xW3i{r(% z8z9|h9-JCrcK{j%aQI&`1RFm2obhBAHRI2rx(8RF2}A>I+1eEin3tCGr{C2iU;igp zCXPTaC+Pk?_X6*)7NSI#+spZfcYd$MCh8P!U#e-y06wwhFlxdIp)5KcU786oEUQ3J zflnY_T3kM#r;wCgPsCx6Ee)2IzI!q37ivkHZ)14=?}Ea-4D(2&ieB9s1WzTJ5K3=|f}sKt_Y7p{-S+F{UU7?LB&cOOx} zX3w_xg%o_{SpR+HsVGTW^_dPm>T5M-hcf<0_vb@c(dU04i-G6#~H*5(WW#Zh@$ zW$08vq`HDHlOI3p4@T7BV-1uiZbU_BzTTD5lwa@bLno)8sC|F^76fHG0rzP@IAU0_ z)k}!R)!yhnDo7wwVqC6@RhR+9zyJZ?MWl)pkgTkv>h^v5vApDE-1ECM(GDV$!nR#i zy2?gfok&mm=Zg{B=9$f(d)kvy_76*Tu`vx|u%Y+U5`DZ7$_~94Bciq=-_2tYFt#Hr zMgb_q!XNSqK1b|cBMf@N5i z@+IJgl7+|Ve}m4pe|e56;U<*>cz>VdZ>Y~S>P5*@EQy{HX^1wkE}L+X3Dwkv5CPpm z4h@<$1(dj$HMcfbGt!N!0&b;nk`rOuFJ$I`O2VxAt3mS`553et17(u| z-Sd~qC2nJ@w{o-5+}j&nakWHxlAcpURz1Wp6*Yb(&V1PG58E}lU(?GcVC74Jc}X)q zy}&4_sMwbPkyfWF$LM4RmgfI!0dV1n{T8rfv$cY7oIVolpXsRO_4RB27@-Ee zpA37+Q|?LP%$)X6SyQM6#ge%{%_vpURC2sh3K-itusv7*R+!(TNtmdu7GBrn;f`^!2y67 zkk_>Fav}2NtuKfEh^fhV!=A(drNa_I(4Meru$6(#k4S4TgNlX@?eVdGLkd>s(Uan% z3q;+X>?V02O8LvbHOF!L+wEtIl-&&o#L%vlR7t9wD;$+X>F1pmVY}r{IKlkt# zr$@pGfM{?AmF^Y*2odo-VxS$wuIs64G+sZ@CvNBP zmpcxi?asa#qaKOy=|h|rtKkRVK05?X)2uEsBd0vG}tJv$ab8I4@mgewS^ih+< za@E?~NRdW|^0_Uhq^?u+NWW-oh<KIRIBGCNI zQIj9dy@iUiqRr8zuB~YXMzSd3?6&<avIWY)!miRKPGjOSf;KvUaQ=?+j@)Bev1E?;!b()byz29o?m?D zrj{rltc_3i=I}a)S8D2Q0l*rm<^H27DG_c{6Ve0L&%qpW(1Ck5iOlMrjGUerQy#c zbHi*i0?+&T@R$>ooX6HhV*S4!2=xUc2EQxs%!rTaS{OOvzx*-PHd}RtA2$e+Dl2BX zU>JJ>Uru+&HvxPIc#6T36W0-8M^<|Z!LS`K!>>MOvYM%VLWT?OCgFKdB2SeqJqy~1 zJvN87uaZg{2Ws#2hzkaU_0!E%+bKL9WZ6#Fy-Mf63VICEz+iFWCs5#3J_0qAl;A4t z?r>=Pa=WNRNFi7Bve&hFLrJ{bwHFJVuUPT2i@XNOp%asPaVT?M&Kht6+ zVLo~agd{2Y`4e>O#5Wdi-^g0Z9ch#VB0 zCMFHWEtr4b@$>PRih9)Tc?CG)&J)NLaheWrwBUkWB)a$1l7>E!s)BS(-5^d<%38g~ zvlPDU`~HuypnMn=g^aMLG9*qDiXsD*DcZ|kc*n;nPPv|n``^9dZvl>T8l-ZZGj-$^ zsI4<^QhTw&VX~&SWe8vq1sXP#ba!fbPPBo|PsN16KZiZeOA2vQMx4!tyDvXReb`1p zUkeJ#umyrL0QG{!4@k)Xl7xII0FuXL&dgqfTrf68CWP>T2w~v%;p&1wyv+_We{SdS>QC zzdq_#or5`0#vhY#;ycuCnKd6^#1?Pb1T-^-RF7P~XrRA)cUdH$K2u~%kA_3Fruuj= zUdUG3S2{pBxz~bGvD4?Ott(+l;1wA|JC~hgvK<+2)U)|UTym~8z11XnF`d*kex5b2 z48E;)IgP3x)m7oDh9DHJZW&cDtLp zrfENU&37qwvKHwwtjS8xLG6U8&wl zXRfqz@ee<~;gC?r;9%Hur^NfcgIiGgX`qu0ejfC=tQdsVvjQHH5v>C zXUf5Eb-|aBSR>na`=}}qwPvWq99kGIxc-sF^MG3ioCv-!UQcK-jPWS8H1T44+X_UE z>0l$uJM)G1zrH3YAWMJ!sBhZmEA+9dV0;52<`vvB;1YmUYFQ$IfB+|9Q#1AQqC&=4 zV`5=xa+8BLM&Liynv~_hN8Qh~l3V8&qW)erSY~YRF>3dEuKL5PvZhRHtx{WR@W%nt z9MC(`h6YwGFzo)Pu9>OvBSXeRf)_Yr(dnVEo$+CV+Mb?q>q*YQS%nXMkE7xS<-d&? zuE6IXCcJO=S4bxLFhg2u3D_qK+Bmp!71H7ngX}^6GZJ;>O+rn*Tk`Gd9M4Ql9{g8N z43=Evdkw~~V-UszLPMGGpE8Qq=$_j1%r4yE_0)2MgQ?7tIHP)|<{10K8mgf)Otw2j z`VHHe1h(sq;m`%4Q7Tn6Ed@JI#otzDef;F)@{U<_2Gpc!uJKg+u7`SdifkO>tiC6x zCM|tkH<8;sBxz~p6J-uzS~z21D3)n9lxcVg#so}x@sNBcx`iZWJZcshJ7c{vF>DQP zepvbX)V*-jZ@q!XdlCZ{42Tob?r&nf)M)K}J2K^`-A#76D-zW#hi=B?3r z_Ui8P_V4GNMX7VR6TsAZzyJ+EN6|`RkBs6NPGMh|O;T{_*WtA1Bx%(y%P3?`pB7OP z6&$lP6y7fPj2ry^nsLeUsR1Jk&xRU|rq-h%@DC=n^x@J{YHQYw%WC_ZUzkch2YqrK z56X|Pe!M$u-n|)XuJKB+lp(9jO5IcFtEty+WQd4u7TQv1+l@J}3%{ids3&p&H3KWjaOJBX&dF%x|tcoSA z={Y&pPEN>znZ48eXCIQB;x?(hjN>C-2f&_*JaHQdp%$#rnH^y*wtDg;r13Ot<}Mk%E-r3P!d#9(L;L6`q{sT!LDIjT|9uix&-*t9n|y$jXQkP zef~6uArE{V9Z|O(ykpOs>f~XX^W+tYA6N9h*WLcKKtp7iiH*>M;iL^-f?dx%#t#2@ zGWv=5X|PZ_ue2gg4ZB_U{Gl=((A^r2pNj(>GyX2J)fsVf-Pm{na{r>9=d9iF}T7nnlI0OelzvafxGj#|H1RcXp z*C7vN1c-LF5-5G%Ui~~IDkK5FEp{!heYbUAy>a>^y;i8-+Uyze-vtEfWSPI#_(vVi zCBuwQ3y*$ou4KP7dNcN};-g4j{!2Fr8RyFumN6AYDtwMwQ@)D@P~XvJWzcM$Epcsm zeou^T@8b|5^pHb)hU!g2F=LUlUHCG`-LG^1wv)rd7Iv}81ocvPaR$0yL#qj;<qvlWR{l`Jn|8LjY?k)5PM|aJd$r=ObFk_2F+J&QWxEXK#T^0Jc*UhiD=#<4vHvX zcTcDO)SM1}Px;VL*KOV*U+pk^Ix=UGy8lbJ@+F2zQ`AE&sponvVOm8!fS37AbpjY> zY5Rj~>y-cy?*~MU014U*le&R}a$RYLwcpmQ@`;r+sdg za?(5tAo#O$a|^(Fst`wSUK3NF7HBTq?5TP^?7gZ@O)}@Rh^r>K%3Kx zfr%8y%S_)%G380U1%Ahl%f__dL}!DEM~8mgOos)_pC1CKi|<3J_D18^yF z^YEPPWWGUm!lgcCT#p%TXQjletE=mI*LiJ(>}Wv3r=P&zFVx#a$QL}!*BPC}D_riw z|80+wMg8QvB0`#P;`5`f5S!RU*)?6#gh}}O)p{~n8Mfu2l)U*5FIBy7aC++uMnq@& zg`drKHt+Ql?xznS9;c2y`O?zFNU9BAn5+>qMx)X0Ux1g*Fh@H7;cy(@h_oz%7{Qgw z^x>H!Vj*}hlu!c$C>E{eKQ)+W2-4BZch!iQ=AnlE>a+Mw8Cz?`@U#WD#XLxHXx)3h zacjOCwt8=rS>yL)Bn2K(t{CLk{fp~S24*js+QSbE&!X%fJF*s&cHDU3cdB;_v4q0+ z&0Z6%|HuwBAKp3fhLr)n4$Vmd()a6qc78ws|5u_I&-MI`o5-8^hCcpJ~1~R{rMOzcKqVWZ{fc zXUg^N==rZe!l_aQ&0h=6aSsc8WM(L79_)TgpCXN7=~?IVZhxd$rrp!X%~lXo?gW)_ zl?ioRI+(8we#+S0A4P$Uj!NIX^rN=OuiDDs@4tU_KIcw=jR&0o5HPYlcp24O$6Z5w z4XPT4g9#-S-@SV*t691jPjD%^!F!y#TSG*6ktr^VAFQoO3gj~lFGrb*C~z=9XM+eh z;=t#00bgADvRp*!>?(-yM(j{{Ej;NXR~9X0IfBC$fdeUK!c4 zH`yUGdyf#Z_g*1nXJqf0mF)Gq?$7t}`}3T~InsT<->=toJ!dshy40oH@E!9&ad7Xu ze$c;J(_aTl43s#yArheOH+6MQe9!k29<6gw`UaQmq?gR?h<+0t2wIbpVfk3^k*HZ| zH-94YjPA=*7xB81==c>E+s0lG8q_gDeBEi!^;MY&N}s5%E=hPv^l$zq@VozGOn9OX z6(iY&gX}JrX8*D6$}nl_>8($C?@pebXWY77d5hLqS3(;UNLdE@`Y^$VaCUw3;QGN` z|4)&TMw&!`;~N1dsMG8oXT`H4?BFsMXQD~*d-mA5J|nQxu%Ti3%q!euBFWeZr@(C4 z8{JlZ%=MZC05P(Sot|T))E;Dy)<{Ky;w{n!J0FYKb7Zuw?wBkH>}9E#t4@VtZDPMTt!tSKX%3SMc%AFA-*}*C3b~b0wW&#&X%;)4L)s> zyvR5x#$fLGmr+)+_77YNjTPBk;dGYXZ`w_HS5-$s9(eAosBrzXvjLvZYdeff1$a+ zdhK_qSDLP%i~Y&Z{{nC~8wNx08C(~A??I{)hzDGk)CPi@wKJ8*xL^=|D9*vp{~K?8 zCCI?Z$*J67L(zG68rm>kPC7xZ7#w9f_4c_Y@8-wD4N1|7MgVZIzO?jg{{R@C4Dpp`;~QdABQ$Be;ihM(9N36?3J4xi&Y_iU5^)SVd!#`|4x5u-TJOl zr0Fu`uD%3S5-)AP0jK!018<(T5jGHJPq9AzpZ%}PW^8ZIy|{tBnK7fEQmW~)IdI+ZUoO15rM z%s@^(A2cLd;&{j-}FHymxf2)hzs?*<#YP(L@GD)W)OC3jGWP(ihTW zBVAQtG3j&a3n@c`+5|^{~{`}Uv6{a@-s8(8%AUGlWE4rkSvrMki#KD%|cuWT| z#qfU=s@iwH7BZ6r`I+-Cc2zAl-={xf!E4>any;~jwiHcm?aK`Lu_gh|Z^w^BQ_pHe z6l6$(*sR_~zn#IXDWQqy-R`73^PfXQaJ&E!p+^!E8)L@Rhd7vnJ82slhF?7F%j-U7*|%pX zjVa<0=VH}X;Z7T7fc$`fNb-A;(VKf~>wg|SX?6GQyg+UJ7pHH$&^r_@OTQ&ctHd1+ zQ%omL#%h}{3ZgY!nzqhyOGWNNNnNLmQ&?ER$43-0F5Y>2r`y;62{eNv3?2@U+TEL* zn+p)9=2AH7NCgpPQfjKzQlvCfuW9Ai!aiu@?uU})5hwE3e&JL`-yHOBSOvqL;FYZ_ z5m3(HV>+V=Ytf5TYxI_8WK4*Dkxy)xpx}}c8wOW zB&=E*^;_53Cw)kUa_aq>E*rp757`Nj@(7-w!^({7PY{A12g;u`&~Vz!HFSZSQ}pIA z@_cULTGwWwMS+8)$#Q{*Y-X-|7Ei0Xmn7Gy*c$zX#V5Dd<5sJlR`x^PPkB*P=BQjQ znd#IpYB6J^R1Tg*7I_})g-LjlIkXUnPopAx2PlEw6y(92N#1V{p}X-Cd&JD~b!6nu z_)`Uc7>(dW(a_LX#JO3-f&F6%(oRh_2Fa&tjNwYqv#?AqtZBpxk#L3b&aM6Zjf165 zXd=_|xjv3}7Z_Olop$t6TGRi@+UY$dwOnQ6k?V!~t@az*zi@b4VhE_+Hls!teHi^L z2Iy02x0BK{m11;~3BDGJDaSQPeP#MCSB3malc5%c)tFA-QzD-smwQlBiFIZ*>`hue zeSM|UaxU-W)~*cheyCu9-;R;F9!^~H>XaV(z1$Vy@>F@%+|ch_XvxeZn@3Aygji$L z*$m61?G5U0-R4&RbzyGw6kcr}GuL1wZ`al7*d_^zgoq2#p3OcDe=pr$lXlY>H^jot zV5Ojp%3{eQ>ODiVSahV#ObAxqIN3FtAN!g&^S9Rp!EYDldA{zIOr*+dFILfwlvxK~ zMi2b=?xqvR^tMqp9H$^_K03nFJ{Ls{X8cy)fX*ckp!|IpqNT6MbSL)By=uBoz#LvUV=H%j%;CpnJiXt*+M}X4v zz?WESwBnK#wXl#ALjOVg1zpCk^A#VWqmq!5n?N~{qksYxZrjGuLo9*cjS%k&TZVTV z&`QwWZBZ?or39i{Fh(wK=2|2V6p!z>YJn@`K#$H}&lX@QE3Hshi5PSGA{H1W&so}LPHl<9BaC{*!jM4NVNE8JLmV~b?=fw zW>`IbliELJ{GFpB#uy$;pZ zfZR-SnU%C8Y6gEHKIX)vyH|s~+kI^T%`aBkoFXP13E`uJ4_vL?9JKGf%A?zgki-5Y z{YxO@h1%S^3F`1*KjtKg))jN*)IYlCev*7&IP7w|FNq6RLwSmJctqVMsWyrAq~qA; z7N2h9Ybf)1Ms~C)cL_?_{R%ZHB6<0uk(hy%ec?`q1<-ha@J`hzuoAII<{awFbp3nW zgEK;jEj|#Xq82#pq+BXgS|6uc$I)^#w9u*{RB1Tk^yP5|9!xF(xfp$1*r$X=^%gvD zx9LM0f}yX!9~q%U4oJ5SWbX)AT3W(m3Kp%kKz;bGpR{D$~qeObs>QLprx4)32 zt98V17^Yfo8GR*icuk2lba)bnO5i|a_S}f34Gz9SbtKPtDx*YSx3>R+YJ@x7jB6Ut zoi-P|8-N-Deq+O=v>94h2%QD610rTxxb)gqoH zxkoNwp1ld6W@4Y-VeN{0{1(aFgUbfWMNU?(s;K9{Bc4Ez5Zb@ju`YY2(}`W$vuHq={F zlvZ+y8vn49q-dwEa?UDXI(N%2^H^o#o-U*Wio)v*rqkKh8N3su#TUR9Ju@dQL zi|SBZKky<=yitd8$1irqkYg@x#E#Hy;};ot1(#mp^+;%j&fZ7%C8Ru@0^d3liP zDezv~)EKxe#B!sE)D;>eVk@a8qmwBL=-e}SW8pXAex}B_>8dI}MqM*$5pge{w-`Ut zVt!f~Rn;=ak{8Q#oi*US^a61S>8FKQMP0nckmQYGmghAzu7B&qUrj$4vCkm?N{Si3 zTcyU_S(J}8QDMTIi+t`mf2hQOH@bhy5USP@{PIiFyA%THVJ@HmR?r@bcUA-tAS<(K zzkbrhc}iBKdAXwQv@0zoVmOL~zR1;Hwy*po=~|y31|NBBzB_y?0$}P1ecrzVZg9dvG|9jg7_juf>z=p7!jY zI>56AZvsEewZ39^)YRZ9Lq$e{$Bp0Xf(uYf%t+xAlGdA@)YgR2f5KFi1l{ z@JET9CbxB==3Z2Bbc?*+q=eh#{Lcx}Xhn$u(dpE5S_DrXT5YK)mz`}@Dg0U}RIeQ> z@z&+M0N_c1CuI%h1%&sxbzxtv*tyd%S!Qd%+WKVr#_ec-AP{xN*UX_VZe|}|Q=tC< z!H4_|C?Hwx3d6z??8Ss*0$xgEJG+r0)BT8%xD&3P6r_Ryu^-*T`Qbe}*gh45wP~^=>3hO zZol;uUkTAA4KW~h{q;CH^?;RpPLIYUiS=&KS0-k00r!G&3;24FeeY-o2PY*be^F(w z-7Hm;%G?q8<-UtEQ{#3z=Th&mfemAyPJ?4K^ftx<`T!Z4JYPOKJ8c?$lXUw3T7aW- z(0mxXxg~jBo`Ck=2F{#1&~M14ku&AiQY2^af?$1Asz>k_sxg_%HxK+K7i`LonxqC3 z&f&)&CDZl;tmf@850YZeO?tyM$C=(RKUxS*!OcW#qES-4cU8Cfu9(*K-+STf5_LCS zzAcyggQxLI22Q$v*Y7zuU%2H66HnD0>6FMs?E1SB%!+@&V>m7`=U*+=m!EqrxfiWbyg+S+>j5;a9Eaz1qJMHsOuv`oA}V zo+jYn_~hh<7~TpWQp~_~H3B;O+MjQH@awf-LhE939{4IHVG?-%et5+Xa2CKXYHb(p zw#CF)h)69&H2<0P5p5BRx{p8Uc0GQ2Ha)?4yIsKE!a+(y_@;>ieP0AU;9E3@1M5Yt zva;i>=#q`0$mAUeW~RXlft=KOB2I^AB!}mo&`MtkJ2E_X!%k^dJpEf^`EF2~&F8p@ zyKr+-i)e#H6xiF?3?8k+3x&nBsX%{FJi8wFnv!E`Oo5SPF>Qyn?GoVXjx-NT`9v}pUapV4dF6o3k_JFKQ~#J;T8nHQV2 zwsAqJzhI|9RS2@);Y&+9nTTRxq8rx=*J1BL!4YahtTQ*)mrt?$VRhelgqo-HpF+?U z%i!O!8UC1-H>D~L-Ng^wV=L%>f(prW;^+?!+0|)}Q;S{O(0lRYuQ+eUGzgb)zvdpS z@G^w-akwB~qi1D~3%e|SX;-BG48DZFH<$Ut+~jr%7hEc`0n0&BNvSX|K>*q30aLft z=%M!j3*A!UXd7Xy;%91yzl!tKF z+=oan@V`2h+|4d$Sq^x|jeesd%QgNqY9qm_<{y9H-Hil`)xSLI`PS^O{3Pr!@g~9@ zWrVfg%;D4QBxN=IEkOX>GaM9ze@6>HDG}%<0kkq!<;#=m4Q)upyP# z)k)Xum>L+s)e)IzuDFY@yD?kuAg`bRgKEUw@jO<>S2j#5QPEl$bm}Xzp# zm)xM|m}7Gh{-e&SH_yNix`ZfG*T3FYN5tp3LOg0YYuHAHPde|ss}ah1tJk$ejxt33 zDbV6A-CXX!Gcfo7skuExHv8^K<|mv zlZLz~Ht~8^j5F(!Ij;Km58gO1Bee!85p0WK-249Pc)MI-`$KsazRWnmpKW!%hJ{}G zwNZX6GJ7k?eWryVSxW2%M1nRl%97%&J}VmyM-1Z#isQV=NPEW{+{i9;^K@D2mT zn9#uzaQ6fVEq<~LQ{Lj8?$oK#-)(0dFEE!39v_$Fym>yL)O5(ss&-zv z@fQo*89yXI=(=&2sL*d{mSIcrhroM$y@j+GOL0ubDLCHcumP$Ildqv!fJf)U|R^(D-fCHKeTc5X-b0TIk4{|X0i3> zZu6ci4}kU`@;tT_a`IY2D~(cmgWcq2MQXnN$E2yH z^`)pNOdr}YS9=*UAi4q`odVTV4rgsf>8!HqhM&<_9#%}vA1yXQ&YYZ`F}yj=l`H7H z+jaNHykCuRNYlo6Uhn9?+iyNK2x{bz8C55@eEKQPj!*QMlj{S%yK1E>z3uF3aKf8< zyG!hXFRzJTj;V4fKuAH9yueaWy-rEV0(}}y(?;)uc1{I+g)!(dh8OhkozKa;t2O-_ zI-r7IIPGoo!|4Li=4F7=Le+=}jHaUJy{|sL%zGkD_$Ev85$Y6(01^7ptwjE2WS^_L} zD3676KEkbx^E_v-I#5N@J(E_w% z;8nCFE%SX}d{0~-l1iTdt>PcmmWp}B0}^U#0IxPTu)u>waddR_h~GW{#$EtY;EA?AbH>l8Mwv%vo_b#$J~;r@PaJ3=L3|1zCZr~(8#4#`icd4Y z*I%N^38cj5vV9xI82|Y=c(2TW7V~zJTSm3V;YrI`~CJhhBOA z#a~}H9Z?;4rYP+7k^YsK*W~4|g46%GYz}imQYpS8FbYA-_z;}> zFz3+{U>^3dl!B1N_1}opZ-A=1-bUXiW`}Wa-R%ue3NNooO*S)|zE;O>af4?yIo=j%9Hwv!43N)*eTO zdw?-ps*!-Q%wzF8DpY1~4ypaai<>tAp9zapoSGPW*~8mKT>P`<`7zd*Rd<%u3z1*f z%IgW*;y>UScqeR9-e?++d9dn_=`|P5)mSmez^Q=t)nyYvR?E{{E0aZQ-O1Z7Ik7*NaT9@0L6z&jF!~U@gD`30#Hby zPh>KbsSV~{VlLdp%|_qAacHq{I8lsKXR!QPQu11DnLxQ*0bfl`1`tMMB)|4dscFdE zGO@6*cwrso{9=kN;&ejWmO9rM7TwwO6b3?!iUc)mQ~mtbD`reJtA|JgPXffzNfa#z zWZlwRm6zt({zGo3dRH=lH;(3U;raEr^+r7YVTJgFPomu6kOQ@l`151@gLA|*0KI$^ zQrYCFb$9onTM0z15HFY!OzE8{L4&lYW~8U3_4kutZJIO6@S0nl-kp7sGT&EJ0S3Si z-`sd3_&PvVp#BZobUo6f=Y^liVJS(4Py>z+X_?caN6Mj6=&4UV1 zg6Ec;{xVz#5YG?S9mFZX`8v;kEP~QY(i4YvVxmu@EEpb6NuB!d>wx8Z#**P2t*db- znS|DAoRX^iV{R;eS0TkLCD`Z$7d2#w{t+Z#px*s9npsaW@WJD$?-rq8OLz zKwWMz?Mt01j}?ID)JyeDhSG(hktPw|f($tSAw*HVL}v+N_JF;N(_pQku8f~aPoVx; zv%@V;+Lndwv)z+g%Kf_v`%!bfUS!_!cz`fL*01LpMx42^1afpl36qDHR_W(feoA8P z6~edZJN#j?<1eQ(cQ6x5<>DvE*+ctTEN&wTNz1BnoU!=vEwu1DW2b5|wfybJO*bZ} z%D=w!pgw>5n<)={&}m%wPBWR#sL=1^pJSUrOt5h*Z360=MU|ylv?QnK55Bma5CKS-dIHI~(H#RIjeetq-#f)CBs7bkI@dsn@<4D_ zcRd6b6duJWF@E3PW=2qUz)Za7lc&PX%+C*&&Fz396d(^tf)IiZz~EVHtUWH~vCORA zP*q%e?UaXS)aq}p%LZ86h$xlkQI8axP;! z56f7Jm6$Y}1m2CUS^8k7N)4|K0|<*KF#tvJ4^X7SkOpQ;&xRms!{3u~t(xC$ho}Q^ zbO{M8V_a!nZ5)aJd{r=%s_4}%B0R=XAi1V44m_Rgh0SjnoZy&Rf?lCAgvU7CabmK*` z=(uM&c^?8CpEsG8%>08c3d#PdhsR~lPPrnFmOS-}Cp5J6^EFrv@s>t%FtF!$UNDy2 z>qELz@3%I7!x*>pGwyCr$0daoN?R!Mc(Q^IFX|QcA-uP14X2&?EPtl(#3oZlaqe@- zGftk~QI#xad4G))0hyR{?f`~C%F@I}!x9jVhv-Yj0 zFJExi&?2WBjtyg^XBnaNM)gGmbWpZ9r>Ibe8ET;thNZ9&o?snE?|8?&9?6+K$yGu< z+iqNQ*_&M&&6WE(Fkq-j6ex~lc1%ze+yh$s09^Q+Af#Jbj*!vuwmk83K@r89H9ueA z)#`O@s1t3wk3mNd2nyu9Z@5V#z~4hYSP?)}q|@j;aKr(%4|8!F<-dieCslXsgd}ZE zn{49kCug47UdWGe!4#pXsR<17L(IT3>lBrO?>`4pj9KVqnR*8I?lfpEOdNlj43eh$ zit$nf)5w8{I4p*}n7i02SLOMbDmG=y!u>TCqA(D_LE{S$z{zaYi&`$d6^SdsHd4%`|=v zVKH)J$gMRGak)JrQvLjRj{1qb%%5{C9&j?NF~(cFs|dVEx+Bh2Clb2+UbHaiUz6y{ zXZro{842WH!W5(ZQ*;5J-_}~7d+!;>z5ju6q@w0)!f*XczDsVoyw2ii>@^Ry&(3KE zOAwvwsz{2G(p#-j%l?tzm4fnIV=I+V7T)OR83YY`f~%*O{(<64`G|*H<$n)3sRX2) z-m1`lJ|BC}ccmby+;G$S(`v0x3Mq2n6EW}onAp+YDOx%lp);yiLWii31yi7|;qBkv zP7TYybODz5lVn{8MmnFkDTUt*sew ziq3l;DTrs`f`sYCq!V2DFrI*wevz#N_c%&{oh~3hR^xoAP!XDc&?3PO` zhsXCJsY6aq4hGXwTafxQr7g$q9#tmsR=ZIEtMX~@rN&gZ+6ek@`^it2j|BF~%QQ`$ zoE~&?Naw$n$a$!$mirbx-BX&5NLg!Izh5gcUZVKjC}~Cv>o>o=>N)+o%%Q^;CS+AL zl@h*3F?(NLpbxEEuM=7C&HYFFpNmC!9jar0Oe}LaE#^i z`-H9as7|W*or1$0lK}}b(_HMxd+(pC7vw2o_fKa>-gQM;?fW-3(l*dH9WrAwh6b7Q zw^eEQxrmgNvr?-{N=J2U9AykUHLJ1`E#x7jowA_tS;c3A0sRmLb*XZVKfG#cyVsYr zi9WGbrt&toZn1M{>Y$RNDQ0c^MB9@PP5nX2Q%HPGm8ckJMeQ zF2KBxMkXn3k+)W5@;kBSf%~KCTdFMU%R{uzpR)~Jh;;~V{Lt*h)5{d+IkF^M`7zp* z0rwy;hw%f`$8Jtegq<8Dj~+=p^dqZXXIww}vvaian#|{5PMz03QX)Hyb7su2dlLE6 zkm<;kcZaTBMJ>Z{qkFIM#Sha;@YB0_;;7r^nd4ywZtm@wT3cI>sn!j&0zMB<++?Z# zJ7ePjFr#pAaNJq^Z`#HyYP~9Dz*>f>Idm1&&_GN@YGC0;_5ftn^lwy7ZwA6N*1!t) z%R?X3>`#(&$; zzNV&@ROcS2KB!0C+T@pQ!N|AMQ$fc<*dAUHnMzk@zlFylCuf!%k^MFOa2iX5fO@-$ zyma!og?A9eC5^Yq!e%qMXx&tphtlDbl?jTg^siy|fnHTm@ zR}Ec!u6x|leaVzbMZvgPwOqFcd|rbIbU1sJTMGQB?jda)CTXktQA5!jUNh@|xPw`i z9VMm3;LI6f3AG1xx|bLNhxv@aVHi~2mQRhqqrJa;cxG#!TyuQ;YOy@YQ@_VFyv`!vaeLyC#ontW5eq2sIr!q zi(!k4z7Ceg-hb<65_f-N$j;gmtC2!Hmn%2@xP!zyW7=a55jo@RM-mz zOf!O;`+?#BejCoj$f?syqjEdv9e1;G4TRDZq06rR^P1hfK|X0~ZaO~Ew)))=Xq|KV z79%Z%*XAu|AfTP4&LP@O0~M_B*5INeiib;aO4Ps9M-FtSR#v90FSh%`WCE0`iYyKZ zKujKXXS?(FJ^+tDQLNpJr4F)a1oRJ*_}#spw@-nF1(0;M$?Y=?R8Ok%{;R9rDgQle zef!gEp@pm^Ny@l#Xl8QRv}dN$ePCd~jp>tk7-xNo8rB zHEgWrpNk4+e-! zyZxhwwS#u?(X>tvYNjglAp#geG~#|B)^qiRwQ?)fihl6f(!ujz@!MNwIgeFq2g`A~ACwGA zKQZnzU%+TARApf;Ha@hJY&m$Js-z@YY#XEz|2-bL|ILmLVV(2XavDpFbmpPS+MxA7 z)E6TjsS^yTr3244`+-ejeK{S4$Ed zxRXUt>VEt7t*or@E;;Kz&dc=y!VrOU(JJ@wD42As~(G6x4$ws!IPw^iDYGw;i5X9F2f znMl(W{)3p0Ot70x*f-naAKnKdv;VIJc;{ZAS_s*97n#Hrm^t67xprdB}_6@<%K#Sfu!W|dHb;jW9aAcUY4oJI}eT@y3dE2 z?%m_^6~d9O>o!9P;M%D!@8)@vw2-Nu8+X65qUq;k>x~nzDV;;!C(jTJ6m#749kIRj zYI{-J0A_9vel10ts0}+IhAx$mwKz5Aapo<@P}int-~RCsiI~!koYSIzUr4*|5mNsk zX2YZ-n{gH|qqmjWW5sZ+R_0K7STg@;j(fiGh>g@CDANkld#Tbp#x56QYGUjU2IB)*J*yiig(!vi}vaZ{=+_RQbJa+ z-sly}dg}m~zJaY*i(MT>Aq|H-VL#E7iv2r1`*mhiUVG^PTp*WzDKY-5G9)Pl=fwi;q@SX%^2ct27xsN{-&x=KgTczml*`IF;b^6yd&oowz_I5^WroTAd^2dg8&~wwR zPrR4)GY#eo)eBY+<^~$=YL8FtoG0cE1k}_3o(}$8!cUNs$d(zquE~tSs$KCcHz$k} zBDNMgQ+M2BE!&@CQ6EgY5$x<}BKB1c4Un2tuR>j!y9i!R~(L-Ku_lWpgx+DWdDG@OqcTq8#Mn+tUK| zIuT}EvI1!x`==hK=6kiVxc}O7q`3T$YF~yP74+XK5%?Omt;sOPKOfsRuaLN$w(f8g zcNHxWv54;w_Gf0mzHB~V$=#Fr`iu5BISU=BcAZsE#ONW$qDeMOT)%N8KV~2Z-bnfr z*0=DHV(gY^55E#qsuK8`*BeH0)EXc4T@q1e6mh!TO*_2g;%iV}KJp#PcYj1P^&aK3)`g+zX;ScN_j59l(F-Y7zs$%!lYx6tCUh}CQgi%y$h5O&baVJbl8^-Qm$pw2Q zXzF2wgG0-M!f(BtDOB9qE3LX(jVK|$x3sui>uV-v%E&xPfBQ;mxM;`tB5q!G*8Qka zQ^18G)B*&zlDR5|-Y3{u(gCV2(>uW_3e2S8cwt@O40T#zQmEHiZ$6zzWFrGS1C8g) zBwW?gL2tbWD$2?bq6PS)Hyad%C^itxIlM&(0~wIz2oFc;RbMGWYl8SQ*b|JPOHFrj zgezQ(>Vx%6s-Q~*G-NZ!^##SY4T$buB{jM|nSS0A{IExRgODe&)rDJcrd{!M?sfz0 zi@Vyjn?uIZj!t$?Z~YF7@W02BQtQ6AoTFb)_zq6|rx*Mp=#fgQ{+m-@L&ZfhHu~aN z;13u)!mPKPTbqTk?O}+7&_?&Yva&o?z{CHz&jrCAlE$!{o9jDa@maP2J$ zLDSFG)F2?J4;0gG=W7XR2S4)uIHU}C?6})iNXpO_X7haV#0l^@|{ddKpAEOOrdFVc#Y5`95BwB1voI>IZ+V;+O0R@4SS=vKiqtL2hRh z$6FHLT6-mrZl_b}nFLUEu`K|HAhKbm2 zKHf6+d&zD2UYmKJ?|>oj5YBP40#*0Hif>nQihH0EU_z(_&WBV2aJAqu7acU_L}xQg?)F180nbBgOg4Tx=D{@j)oSu2WZ5(5@4CVBlsK zlG}y$H;*>2{c031H*4rw>l%sMQYS;|@F!4Nfm$9|4A5)v|8{0pn^0E=$?v~^C(*LG zLVAHaf$(I*fO4lqueq=PN$XD#1%l`oVRT(x3Z|q_lK%@-c#W!z?L9f0CHQU;f;6aS zJH130`d}S1oGj55I{x(cBYw|KjoIUT`fDn#)WQv_= z@?@Ko8-21#rBYp^n{;xI&*=$SPxCOP*tn{x&EWgpX;gK%2yCaQ2$x03B&T$=d6LL) zkaJh53S-SeJF8&}S%+;FUho`qQn-GePhWc~%woCR( zwj1s6sY1f2sKuA*@TeqJzOW``v)M}5be2=QS@Hjg`c~eo{{7G3;GaKJ6v4X~Gdt+v zYudqdukXo_(=&w`c(6B@%>|f9K z|6DkAnXur7QkTU^{ljj;$Q}^ggR4$HryD-}XP;N3`^C*jMZV%j5K1%%9nPkDBGnlF zbXsa?FC1wLZs^K3ERB7z;T9it;aTO{UC^jojhv_=DYzp+3Do{GOd^h?S$uIgk%K<8sT{Q>XDS6UU*+P=sLt`e8lr4{e6s! zE5`i*UeOP@c)qLCpJZ%nX&7gTDOgx7!%{oSlPvC zczgWsAK&xZ62dn8P(bhC4T8^SR9N`ix03hXjF-Q&vS3LJ1P@Fl_^)4{4X)cy#Rrympo!^`qH7^B8!|gBrnSMqXOiU|s`WJXZ zBA4GXnB9Pz0$vHEo*$^|u|;JT;>7Y-DOkNc@JNbna#(oe z`Hk+@y{$q%G!WUHF@PSGC5VcKHjSFhAJ>SV2jL zW%eQWQvJl4edf3O9qHwngQqVIXBYPGy&G%OANi~2%QKgPI&)u3<83*~km#)tAge~V zH`fRT3wnctA#yNYHelTivxIWS`9_T}FxjxIBH6^mDNce$(Z!|qbN9@S|3c7$9K*|5 z>!P=9{`)GMA6dNr)X|{!7tyPAx)Ev<=_KMBhh^43U#B>;yD;MYfRk}g{BVp%-J;Cl zb4TOp_NIlGNUq~I;&H9HuMWq_y<-b(G{)&*-{peQUJ*a6%Tw}WcAM8F)k6odu=R;7 zJIq$*7P9d!yRg?r$70UD2_;id-ixPZx9!c!D#xjd8^)wj^RfW>^K1GZDeE_w%+$JB zZVzUqvog)6yERyyE!iha;^*^Rc&d@4Q|5VMWpnocU_QHrC+il%CW04A+B$Pgkq!m| z#Hdjr%0Q(6N}!(f8jqgdQzt+J)<0JTAV?KP0zSJdK3g4El>YclUoDE_=?5`|g)nHG zKc9kc50G3+N7W)ieU{=v=0n#Mu3XikpA@!EU=NqqwV z0LznEppRDcUD6z>5_R*X-jBv?LQ2`_KtT%4hSv>zjCf$rZu;BDg19P-ot(z+iRi6e z>`a#O{yNfla`fgIiMdE^E*&L}pNqK`RO_H# z%Kyf#AX8%S`dO-rN&#~IlZHNg;$945Ha?=v>eAf{0SE6Vgo`&bYBko5vdNcMpJVLD zWxVbiknl+9_1hm$W1^>kCt0eZvmkKUxy1t0+3LgG4EauQLcN??+7!;1eO{|+8%w^m zEMZ7tor6NNUg%Mz(SM^{f%b%N-q3Ba|5!(37}8E{M#c+_%Bw-m+Gz@FP7|LzPRSYB zlx9!3yz3-1mB-VZ^Yww)^gp9lArfyVA#uP5`eZJ=bSG`y8&M!(gK+ra?1@TL_uHrW zd%<~zGd#VM~t2L@eZo&6zl|2Z;p&-gbA1FOpt z#x40E$A)`jT#yf73P%G_bUB602=G^X;erU1S_q8_LxyJzm^ab}Bd}?eUQjbXI3Xx4 zW4L_uc$uqHSLS9f+xPCKtdVuNfljzoVWCP9#4?Z}<`G9{XP$AHb{9&EhzA-t2B@dp zM@7Fmsl9y5*uU3Q=)vxuYh@H9?zuSpe6R6Tug2=PIG~`X3qGQ-j~ZK8geD~=1tsGb z2aF$2$mqV_#aucr0gkiIZIa!+=8rfjJzYTzTl|lbl8ZMaGc`{YK1W1g13&~`^2eVQ zK|~Dy`=Q(Bfhq^wOZ1-&K@W`Z5Q2z`DnM*f*rg~4`{Ft_-9m_jdRJ2-z_u?lJ-0CZ zyzswRNGl-vHTMl!q5kmIz!m1~*nXeZ@MP-q{zknqF4*QFh!x_E!$24c^wsyXvpW56 z&+GuyW!Z^34hBn)&`3rBFIpW^MB3X-p*Si<#3l>@gjnEXqdjBkYx(ut#%G zIj3_q!s`%l<#Z(fh(>sM{H}CRbYooa*-}1Ekc<282j9Nt);fAjZ2@hp9UwNIXmMKrPnRXYt_|Ui=FoOw3*c$p|0D12P`qLYNZz zn=ZD&a9pIn_IE1rzK|;KgZ$B``Qze$oevLEE#?Xf0f6Z5mt$pPhq|pHPd0WP(Hfvl-WRz6Kh4aOb~&|DbwWfs2$b zP8K#p@mwtvJ40X4!~&8v0ApZiHbT9T^&)tx!KrA4)YL!J*uyF4`gZ~et7xz|;p>-M zubBUQY$txnhLt}vNV zn5}VnQm{wyO(}H^h`~p-luT*AMqmm6ENH=H_5& zM*KvjKovdsMTezeY}ucuum>KUXhm zc&}L+`LOESFaMvDT9SUJ8t^*9RiUpvK!7dC6bdnhF0*#`Kux>|dj~;SS9}Pi)?nQI z5|%j3a@SNP>3dsWe&w2%?C2B@Rk^V0*VKEIX4dBGvFT803?>uw6M^6s)n}zpq2?1Q*(vN@{F<4gL@B3%`Ls75KH;jCwzVFNqmdw?t<;+*;#{FyjdV zxZdsZbH56BcVfO}vvEWxHt6s+%!=pICtfy}*p{!r+G1=bar({|1yScOJMQW}KDVty z#+(`95;XUa^2NFYv0SgpZcan9p59Lo z{=QK&(+W)>;6p0f7+UWTR{O0-WXFmi7iT##c{TI1=bCk13zT#{`{K2!PfuBFm78%j8 zcH*Nm)gH9*OWi%We5s;8Tx|KoY@W!eIcTzF$nrP3qTlI>Kc(MSS`Oal!>uJM6)wGnOcUG9jX&l6tP8SlM=Mwj zH78a(Iyx9~W7pz|s|pnM?^vKj@mx>+Kc2ojoa_DlU$RGJuZ$A1_sCYt-h1!8M-h=# zSrH%kFKk8UFV$iem|f0^S&SVW5i~$yq%q$jR8yV z=bU7b;+ZT8=Ua)B8QG{3=r{gGRV?U&ydpQaQVFCZyR?BtEv*rzPqM|ZP#dc{jE;3gY|m7`ra2C z^J-EG`_7IP%a;jCBmY#K%k_E)|g=I9mcg;=6HF;Tn6+ZJI^MXfE=)l zgrC7W>6P{(pU+7vz9l3=F4t9i7^xO7-}7;zgW?t(uUEo|JajJ}ukTjZw) zrAH+ysCb$lR{_$z3wldhLW)Tb)k=IR8_~#_oo3&=Ieehs92e)34sM;^yzbWaDrS1) zF}nBWE4vTfHv1Mc(+$KxBa$SK>ru1o6&(>ZPeUGMx4ck+T>P}*ZqFr2KKt_eLp-MQZjKEU+LCBi70&A zYg6Hr+Lp-x%Mkdcb4KhXyiUhe@g|7@@0L*xzBJOW$q5*p&A24&y`ZQ$ z0C5FRAjP6z)ZH(CmUaJPd>+`FIxgte(Z(vMcikh z33aJVr$$b_`?XsrKNaxbq*WA9&NFJ^qTG1;r$4gHWgRQ3C$;L)r{87K^u8|PrBelH zq1O6*(8sk}Og*XiZB+{ukMO^Wm#U$wJCWJe);93O%j-N5G+8@2Cl5pNrzcR{-vQT!L>4F|psoWEQ8Of*`EMG| zSv-68tITa1`;mzs=plgO0Cix`=R@v0(nsB%f7ZiFKW+H+pk1Ah<`7|sYQ4NecIDHR zb%)6yxI;%wpMbsC_MUysjDNb0{-@w}Tlf(w&31R5*qwtr*pcgy+)MPtExWY6t_{(Y zdpQo8%ZJg$pLqBez7j)i4<&?S1;8se-qK4?-wpvbv8@_D4DAs;BRx0P_M;=>@P`oG zXFT!oC*#wSmof}jPeJRx+%s{EupR4%)(sQ`FoI&pY2Gv`vb-6%N}-4*oB6jSxol8Z ze0o9UP2azy`>@LU`)1ilK-FF?=@EM`6R>^;9}ob141EOxTa@U4SpT)@1e1>|SL9FV zmXSp@*jgNg+OvzVb}kn2Me7$m*ByEA)tO;xn!ff&v!Ej*z^&M$`|sY|PO->OC0N{w;^9^Pe{ z_7k2utQq_pC3I0b@R_vwnXtbO39Q}&%hXuJ9w5~%AE|Dw*mvW5oo}KI< zq=}iCnFlZXT5&P6kx+aVOTfnHyhwlWdMfrDQQ2Yz+O@*0`<)m9(O}3Huaf^(!{gr{ z{g%CGSGT=ISyQ(|^kJqWCglKIA>m!VQ1O*qSXOGMC zlf-wwCQ`d==CL!sAS^KA3vb7|OgvPIv?u#m`1co&Z0fW^pa)7(Yrj=}1SJ{yKo z_1E|Y0>RI5zt8*#n2>eEZ{4IUJHH5eah^fHUhjdvGxRHX?6}DVUw_j@cNL8Nz(fw7 zQJ_g6*z49*-N?j5H;~@}4tj*OAUS6u+E@y3EW*9_JKDAe4Gu{9+%HbOp?OSC6aC56 z!Cmg$lsWtAaqZSuu2BxTAj(~#ob;1>#T{RZ8H*K%jc=ed@VmI5#xWXdVXYTRjz20= zAdJEWr#JWR;EW7<-@mlcKBLzIfADmKdUP(eS~-j_c1}1inokrix4XEW*Wy=jPd`u9 zJfV@Am~MX|(^*ZU%Rb^2JdjjHWb9bc67rdhv;N3Z(*F_Wqj86e`;VL1-P%Oi*o>?2(%GJ2}S6 zJiYX%W%LDw-=TMWD;Ihhbd6v3_i$$^S3f>0y*nCKeLpGv8RF~qkTUvVidhbJ81 zOP{sv3E-x0cD58_3L6*`FY6XLHuLv_H83IOPE%4#TR)yIGvO23a55CyS^SM9&tEw4 zW<=Sa4*rbMFq?=!DlvdtckE6M!|2|gd*E~ad>8!7&6v#OkJmD_SyXf~f#%Ch%lHm; z*SHL?WByl-BXAshKS03bJ?DuUPL>?Z7w=nVuxLE>6yT;#e$b_qx@9pnUkgUG;6 z02?7kARk`Ks5@ZI0Ddt*x%)TeY70dU@e)vggs|72b&9eI4IV58Vcbv%FD!KFzoBm` ziLZl4u!eKnyzOtWX0*RopN)kI;V{rJy@^rly}g?8tkK8|Fg;KY)-ZCotR4SMYW)5o z&Vz{;bY~Y=Iu|Ez{RP3jg=OFP0$+K(vbxoQcN{%Q&i`COoT)#0XJVDPgl8CNmb2T6 zvFWE~+kQ-Fj0iBT$)Pg0)Wz4Br7a29L2ZXlVs-i~3i6e+_svfb#@FffmkGEhQb@s_WH1SEzC2 zri43?gusn_rSKmEKVOZ78zMM*;4Nl`(OP|x~QjOu+ta6EYZUmUoz$U zW@jynQ~DOB9f+Rp26qYUO{(78!D`ReiatEb8V@s;jQw?@NoW_5VWD7>8s~pDs{MoG z{U~0D8p}hbcxeS-B;-|9#ls+D`pwvt9lzTEg++CWBUDQJBjYt-qbV^hVJdL3v%CHI z$pd(^l7y*SiJ_yfQLE{$uf0i8P|#U7HHS`?Y*U)v3`)+$BWj^@$K_uqE;%(pXSI?s zCB}a~MC{`11YTLfYk}BX0_CJ`+5?wb(8+9byaec8R}EOfX7@f)i7=~tpeKv02)qgq zbe-)RQI%8{qji<5V9(7lC;`yXpz#;_fad3jeeYU~ac$#{9dT+tMbvB}@Z; z1%L5mc=$Qin)_SxyTzU<@*A&QQD=dSzdE6B1(1m7O9T?RT4W5x!pFzI*a0)R^f7+t z2k}i~s-Tj4F?Vb@!VhlF$i4^x-w|G(>*b2;@mcGYA8_F4&gU@^pA%$J1{4dU7Jtg# zN_dP&BGLCx#6a8!W{TiR6iGgd6*~PId_H%LU0O;t3SxVI*Ms5rNpkuL<#zqj4cNEA zI|}XI&G68RP5=Hvx9Z#qy}oG8HgW|+?ASDvai@|!*3P-==c36A(d^2`tKW^@7+)~N znKN5P$6^#3<>t(NKY8=mhod3Yn&S=Y$M1tFdG1gUvWDzBj$M|YjXC&Aj6gf$n$6T3%fhp5Tf zg2o(dcR`2=LpKQ2*88O&YtH%KWEXz2YK5YuZE0>E1cy|N7Ez$Vc-h7!yw=I+8`%Hu z>t?f&qyFwG!`ENr@*%}*!4zc!(PW=8{Im{)o44*)5(m|89u;h=2RGZHh+ek5h}yu( zZ!k(jh?U^6$D6zihN)I&W?yzT3pDeQjKmSO44$6>x8KhHPBOKD9}8JR!?rZdcZHH} z*LRD8bJu^Qo+F%^Km(IXdiVE%yl|HM3BEw=vp^{OrIVISyirrsyIjSy+pq54|dmm8p~=@Sb`lSx@j=_n=%yPAk;kjNGm7Cz1%Ix(Ao*wo(Q<$ZR;E0c>xwG=;`a5`}$({R{G;YQ)2-uSx6c-rvSp~apxR+ufx5;=48kB%&#XL z1VFFV@z@JUM35`D`;}M~$rOc53z%WMYMqfSFFe>`GDA-f-Ch68&7C>M4pILTvQJJu zEhuDda7y$MdqaZL8;Q%##idcD{p4^n^qV=$XCrxu?|VP4D}_BHMD$ z_3A#;K+HSef6=@L=(xSL_bAG(!gzA6K*tNH*xZH{1xBX@Pb_{B=O3Yi7IVBbde+=4 zwcb2WEp2Oa^ENIfmRzR~S7Zkbru>#VcF!F4IHYpm#|J;24w`_Giq8*G3l>)r3b;vNw4QsdNz z6QA{BA1NxZlP&qpozV)-`SZc+dIx3=2z@?IuE6V%QjljMc{cJiCW%rJzbnLto(oGN z$L@m@LFkE0qo@n{H=i}-y%>1{U@^b!V8hTWmSgW# z?sV)3_ay5T;j+0iPqucWz~;+1Lr)jOtGPt{l*Lg_9wl_xt~q&hElz8{4ik5m6GWTG z{Nor@mMD~VUlp}h@TrqvqVK{aHk3rug;x>;0jw3+x0XwuV z_~=Z)CklFI*oGpyIlPXtu8WPLvim7|>JzM(VRb^pu_@?&F_LNYWvn>y@x(?A{$XK8 zL20pO7M=9O6XAH`-}ZhSdEDcD9VR2^zWuqr{u_9JH^A|IX%4bk2y@yCcP-qyxjYmd zylZ$Uz9vCT^I+F#s`efU4tVQ&&OJXua!~-=fCBbdodkXwwa_nwRKA~+f;R9{`m$K5 z!V3F`dU#E5ad-r@ymVH?(T>!}RTvvrYkWyTLBnWTx_iWRE7y?Nf9(OC1xT-zl$4;1 z8+2ip9Ichgdp2QYjFkbjw5DuuzM_|=LzcZV7j3Ynvx?5Yfd9NCCi|w3CZ@WJX#d#Y z=Ck+}zp*3CB`vBm#XD;Dx9z83)91!6j(*d{(6OIbl}gWHTy#AEmiCEfdxa>c5Jp zf#N>TZ|s-ou~ww?YJOV{@3gQQ7Ju)M@M?RM;*V#gW`PT-cSnNC`K#Z0k~&p_Tr_oq zHK!#T&%LDbvZOLu*4GmliB+};z#J>ZtuWnC5Qvu36j}~%#<+z8U9{BAoH6spuWMt) zZeM%q{7d7spfuHY8t26b4wK8ZJ3_-EkQH>E6pxhmgF0?3m{~ML|WC1&%=9R(Ym*d{9fQ^?_!X zS;)$)n#M>KIW}c@XLnq3+_7e%^0x>+8B^V5aCC-+43pN!OBzsiHu^JEKOKZ(yiqR-m8>iQ6gEyQw zz6x=v^6)=@Zz}1-TsM6s3?wI@tpMc;1Xd`;1-L|i4x-t~m09;N_W3vZC+<&qM<1l> zKcYI(Bam?YV|$CxXE%eg9&KJWavAl|lAfy43_a1w(rya5(P6bCTH{+VuwhuH_DfvXea_J>O7 zC)Crmxer-z3bXiMir0&~8sWCBzQ?c(qIO<#op8Vaw(!^(JLLl;*>T;t;S=9hxs=6ZsBo=nfhgZ28>AJ?pW4Ozw! z%(i5jAfM*J@h`vIT!Ge2mSNT$OHNOR$Lsp;o8{+aTF}Wo%pNi$yMIkid1M$QcH%(X zQq=hF&>J~5npekza9;wJM%wjG62G}1P;g0?zMbrXzB9Z`U$5M2*ZHD zK}CFN9y_r5u|kgeo->JTTdlLCkB+uB5b(YL5DW2P_ywjRGG=UTRiz(Y{+gREC591) zZk)5Rq!4KjtrLo@L~!$0-khp!08@34$64FkV{2uu9f!A@h;r3n2N!GIT7p2sJf&J`_V9rj(hlBh{CF5b_2Md47=CaMVgz-mrn8z!M(YT|sm!FJ0 z5E{FRRUU7+|3%Ml=h@t6PgDgo{jv|+AIs{)xO#u{+Nz|R!$+2uMjO~K!ee+pqOkPZ zY(H4hQbmJ1FxaSm_B*Py?7jiIS0EJiR&wKI|DGU9CG zCmpLbZXABH(4+(Dvb2;$94yM)8PI}dNdLJI|CwC~zuWFwXoTLI@RP_vpr^>zSz+wi zdAOT&+=KwLak*jc3<-Ow9-b9iW~@vmRy-dQ^CONta?*SQKW^pf);9($)aQrG>?oLJ zSnN|>l}d9S)oJ@VCzL54J}kd|Ov^xm^S0k6WJi!7H0rBGg)z*rieFNiKO@`LeuB#UK_j`Y~4DCLB%>(_3XbO~Dh%2Ha)KZKAB11R#^-jqQmx5d5sz|slG zvF`iv1M#J{was_kK9T^)b;zPJe7&x|McN$YHCWD9k4$}o^gNx5tr@1f2&=i9n!AHh!H-8Dhs>; zxKbFqnmLcMhrH1rm3;=C0EB^j11h>A6qA}yX##zf>_A+CS|HOV&khz<2-oGfM{}8M zRlS7Q`hf6#@wFQzOQ+gWS1Gm2{aEUa+v3Pc6x zz~8{@{#IVsyOvZVzVwi#J(PzbgTECDrMU;iO#9oD=^hjPoWtVW4BDwIh<;SQ_)&Wz z3o|G#u+;D@7-MLRJT>)n<0%$_vu|p|Fjm4wuw{~bbJqMCn-ekl_i|(u zUbc_M4MT;AmY;ta7vW?8;i^Pu3Fs02TaKo8sG|3GI|!=a$^s)7P7bI6z%<=<;N!uP zY>L3YeoH&ql)Q%VD1F$dsYsa8(>`S_gYiTsF$tW7K$!r3xo_nlob|us$sh2A3b!M* zA%g#aJh=4c8w}0c;8qRvq2aM9RY6@di)USRK0Zg~&iOZFfvDu>77HaA3C}Jp1gP~y z=fk{FqQYH3$GRY?uRmY%!am?6DKHr#!h#6`c0>Nhe+3F1Y`FZDpT-8aa`a{auo6uz zbZWUbUd@d5%#10i7tA!kwARAi{bn!!P@$}q_q)n#xm10LXcG#oy0$ofqB-_W>7w=) z#Bcrewv$_Lm{<$_V}GCH-TF7IL|h6`fxI+FK)Ks*zcuc$ZuYAVTDWC5I35;Ly$n(> zI_YE*|1zj>wzK29W}0oC6X2Zf!+yQty+OQ_@YGeE^p|2&({7_^DW&5Vdc_TS4KXDs z`h4ZM1~101yQ9E1JIUl3VqyJcd%6b%_29UkkWT6NSvXe5(`rgZQcD^C`<&yaANLjx zdia(0!%!6!+4K_SRaJ$clen5ZIJKCHjlkV*dT^Jj?N;50OYX+kK)H!vuYYkpH6pJ= zNn@{dhV_~e@Uba8|Gd$t(30a}t-zp50v6t9Et>ur3wjz4J3fmO{{F1E@#QNnuj!_X zceXcYsF{UDFys;iEC~gKAZEVc3X99t{AFXqp+od%RWQnJ5}Yki=q|`)?oJ#0s4Gx* zRsC;qCdWb*?LtLC;qyp)tTd4Gcvm8ac5t__>sh;AktD(E_jwIn%FEqh!E{W$m5|&5 zlqO&X5V)-kGPpFZGv#=pW+f#hLCQ*L8b5QXN|shHJ{hX2r=*AooGx=q={byqKWK;H^eKw)rjl20nhHcsr{9ZrLsXr5!zKa=PF31TF<1bc7Ou$pzTP$?+yL5`||JvO=Z+Y-r&OLcT;m>Ti!pRlf5A)#njl zh8B-dAO0R54oyzVL)QV;CWteI=yrVwv>7cY{jP#qp02QcLFRWj46t&<$edfsPa0Fw z)`q{(W;Z*v`aKIuZ8Ak}eL^FBqQ6X}mm_C!=S@dm72?ECsxSri^&+sa4{n?D8sQ!W zRm1)IzfCpLqfi#PU}2^5x4J$8yfvKY<>N=(cp*^5eO`XlRZu%V`rSf3>$+9+Y0|pz z0|k0VI{_6rtsG&{?O;?)Bdlp3?o}EPgKCwT z$lsbjt!&xhW%i#}r~5QgnxJwkM+Y5!qRI`I0Y3GFoM(UUe6c= zm3{cEpetv{XT!BQ28Q8!1_q0cre{WIMEsuCxRK!JxBp4a>0eqkX|40H*p1!7^WWsV3kz9CG$+>A)~pT^OIRY>&(BdCOHWV(0b{>8fsSw(N=rErhkwX> z1ij8-P-*vOOyK#FKZMP#KHu@9i^y^V$-o;r$se8r;@#A)&C>8kLp24eALIj}9Dmns zS!}YcxeZg?mYuF{lIzLti+Z6a#uGfsBdStnlVp2Vm`{pRhxY6hPKeSQR96E<6Bfj& zvmXNUZH$)f#d>4q&lW+^hu`aEl&8Klj|VYF=3f=*FLd zXA?{V3U@;1--vF{gWhTd{t(!(Hqvcsw{pJ9{lxNRWkc-g@|$ulu?UAyADi(!!=gIO zADE?DtnMp)lt5|Sll!iWo6$9CyX$?{6&^&uUpLhiX zI*C=q+H55bC<9LO15@C1BWE}L>LmSuIdGr(yp8Vs8mL{^krWdE{5vbbHf;*xF_~y% z_`u&5wvLUZbu{tJ+?<@8mF`QAB>yq96#MBwbFIR;YPI@DA(us`FsdaW4m?=8uKpg- zE!~;APkAHS@*6k(^>&kN!P!Y2DINJ#w&jl0`bLB0uSI3Ib8}i-=blPC3YbP4T#b8@ z7!^rh6Gb|Z-{rYrcx(-{Km@qhybnYfU{FGn1;Pu*>FbU)R8aoK{r(}-0J33C>UG6& z3d!guUYzLSD@I3&$U1JfyG4k;v*4a^pYUHdE!LYO4i?8VA4}ad9f8pCbb=VD?BJFP z5U(e=O;v%lK4|*EN%n8pEOmpWKnQJbB<9|t$p;!WdbF4JaRcPwK?=Hu;hB$!t%n=S zD2f>4tm?W8ZX;1})6u<$9fy}}5yWTeB_e;SorHy$^o=^@TQ`GZFle9syp0vUG4#M2 zH_q<8rsU{@*GyAU4?u=Pk#}{&wX@EK7KZ_9A2eKVO|K43SMSiBU_tOI;;Surnk{Jo z6QkGt8QxwKH(FHj1Q{&IwwZGsqECJPKQ6%3zasE(*l)aLr7 zvvbv)#bR8of!iX>i+hQln@zdTD#(=tMvXH=M zkfT#15}d169@hS%;``+^b}eb^gP+YRawC-Mgf!{=$wl%q#iSIV(DvPJ!}Q(nVFqV* zfbb;Q;`8h&UP6NmS!d=H7{C>RLJjN8wY9Z*uo3w)RTl$GK!}M<3AUd9iVvbK=VX?| zaGB3IHTL?&Hl9wim0|GEg9&Vd+X5;WivVQfAW=Cq79H7 z1V0Ug5SM)OQ?vzM8EA+qhaS<8?E5kKWp52Vc%AX_@Sr0CsEot-p$i(7c=_lCO$T>9@L&-`*B+~9 zBEI{KqEELW)PS&q8_6W?3%_fCs4%QM0|OjuSW|^Wbw0&B|6_@?_wWG|bO1bg*=)Gk z{;veX5#1?56$V$D~SmBrz{Y>ks&aTK_x9{76^>|=(PUP^!O%TncJb`0!wFcmxzNyQL=5KHNqIVaqIq9WWDVP!?qi+ZzRqp2lkQcfDq#G z`LQHsLyu^&hCn-${nA{_v}nv`TuBW!OoEvRaYHf^PFw&NQMlOO0r$@i7<6sq{>1gM z?U^qx`nmS<*l!bk;aAQ?v$%CBz;bNP1%z05Gy}}``}(3Zxw6&hX~HeA!Z?e*ZiRXN z=?jd{ai=v5eS7DgvQu^#FP0u^1ry;8J`}32T3qnhLG< zr6cMuC58{};ZPhy+s&W+`6&(5b=nwcMUr9BgZPvqiPgyVfw2{&D9CDJ=lsVGGE4yR z-FKrP|F}c){6X5Yje7vx4%t;RL{~g514&qcmIahxs0#xG(NHv!7 z!H@x3BB&nt7e_|X;G+V^PArMj_;yocL_+!14^c>cdu%|aFM#7faPf|h_7zRr*ymTe zaSt@nNJmzdwcc^1mAZK}KGcrPX2pT>4$}qV2@ClhPELJwv(4{NgEy_OL-JSis`$HwMe7DnsG2;L=y;UPJJyL;4npETY>%uEF`J>IDhV#NcAWXe=j8vjQ;% zUwD;CWOI39r*GAjT{BJJc(50o6C!2(`5^V(UB~O+K5CWqmzr}JH6&!vZ|tcHj^5rY zC6K_BE}!T-gAp5uJC9i3EkY{*ajd(enyN!%V`FXs^1yR`f5h zcJJ8D><(|AlF`g@lwL~ka7;x@7Gw6-Wv#f5fy)N$^myvXDhV zOFcoD{=*k(O@|bw%Nh%rU^)T_XdQC^e>2Gk35A7yT%2(U7=n5qy|JV zQQ%G-jt1U3V8U}^_Qj)wRz_iBV*w*wky{-S&lnfw>_N8$aL=cR_TrMb0m}2~?Q63~ zUmw?>BpR-HTpIw1;AFY^b!2la0jF0G5M{8i_XbJpSyO8-63`1m z=FL3n@$tXC#57{PZD(^=0kB#YhJuac3axwnny{*)%6_^9Vk0<^Ao*Yjl^Wp(3?0!H z=O&q0SXiKTitDPQ^|BR7=n>X-#?8tPs|*^8Vk;B}8LMd9Q5f?3ocbrPa!!=r#S&Lh zQPe2W0t-51Hh~`)A)tUn0NN4*A(rQ#i}hsYy9MlGFG?}pG>!GIRv2lg0C2nik@qidP*Oy+Z2wng5f z4~J{1OGzc%^f#Z3WNCQC&ZB=oB@Ol)w<8t+75j*B2h$|@#l_qyBFhPb*^owi(BL`w6tr$EN{k; zg`@?z%=R-q4w|U}O8*VG4>V0p=K}G;ZSzV{{Tc_O~b`DUu(FunNlW<$9bq z_KZa^X7cYwLINtH69Lb6*slFG)^Con0?LV<9To!`;vux-H)jdnSfI+}6B2q1qo%2{ zuZ2ZBWylr@NwFc-^z_lNJ0+iTyx(@iE1-=K_g23Dn4DKEt7l9q)+oKuDwc8J*_6eS zJj2e$6Y4xPG}H!v(%I3@k>fjHGlLxw_^W)K##yJmO5v~&B8u9e@f200uVH$#qB-F` z$8`yoT???5g>@9hW+Y)Sw0IXsa|2xG?ObM4f`Kq>d`AQaC;m8%6UCS*u-l9g+sA^& z0!cLzJNr|mLh4!ODukj3`hO6n0(lZf7R0FqV2Pop`Fo*2aH&VJ1{TF$)8k6Qjm&}a zaKogE@Z;nVG90G4MzzJwRkl9zyD5g!jjRurN6}`Cjll{4NeYJ^AI3#QWs0cT#$z(* z$r!mT2LY(>g&2EtqzHl02Cy6~!N?t+)udj)3SdWm+#PuS7`%1w+_?j!JLFRZ@Cp*b z;G+RL4wSuVk6sS2;srFK&-7xU@R3Uwa%_bMCKP5TuX)*e_ z2H#2@!}!AN%%TIi)Vp>9%)W;o9%`e$=yhcNw!;+mAhwRkzm8|Up#^;hTQ4und>j`C z!_p^M>?i;;qz}CG`tl_X?;)WZ(Bz+-uSyQgUChkgyzvU8@k0Kl#kT1BF{t!b+;E8! zdw*X_E7+I%Asin|IcJpNJi3VXg-VCb*+0=Q%#xIZyr2VSP6NF3?vfoa>D(#NR#@vTA8xWEywP;?&^8P4M>< zeCoI21&W@R_V2GsK|%Wz&u{I$aP_%^{lV3b^)^LRN79e?jCULd{uYyiTpTPQfJT1d za}D^Cw{HE0lFbW{&F;K3@~xX{5^zKQLQz@EhONZD#MH(>4LrTz3c?Ts z4*KKu{JvAPt|6_iUp>3?TlSs}-1h=N{3->e495vu8yhu}FjyG@nBohOKe78)wmZt% z%b$LTZkuW!wkRJd4YWAUJ!(RWL$BqbufpoHiE@rwcoFWrD>KjdBu+@AIhoz2=Y_)xtqJ`{SUAupKDAxyYnoFybu#@3Fo$)4z&IUnTou_KoUAW@0pQeynfxRhE z+#DU*=mL%z+RUVmZmF6+W+GG8X}S?6^Qln5*H`2=A-QtYd&N&t|13!#VRfNBNyk5E zdT@>Ej9Bg-Q4tFckG>Q~ai^}jBA_8A_yO?#A*6zbx8G{{cRnQV`Lj1cqyWznu*T}Q zYNuH4-D~^pVNoZl*BT%`lCPSdm-lEOWo6Ijy?`SbOlI(^Ege2XrZUM6=uEl{V>IUHDD45oM^U#G!ek9POzV1Sb8W9@jd z?^5(q%F6hV;71op#*y{;GX(pj@LJlCPn#*ls7bdbf<1M(em8=cZ{8gNY*H>s~^vyvYY6`e9Y#s5+j7 zb{VlA`NWmKQq6BNTu%|#?~k~UN-yKBbWfw`lIs2T{z3u=4HaHkkE@HLgJ@U(>vdE8 z0NMD!JdT*&=jP@T^HwYWoAlW-+93hz{Xp=fQ<_WNRDR5xH!ZviFYYNVa8YQYS>Ysw zW@TlGeo$GR;Jo|qf%eF|)~f0_))y=h!G(njQuMo5uy_yymx(t;g;ZCXzo?@h#bAWA z;gdz?wmS)O2_`H3inuI@jde1gtarAuLMxj{?R#-Mf|2m#*iNW7;(?yB#t(LODy@t{ zsrKTplm1LW6Aad9J~+W&VA=ts>*Y%fm~UG)mgLDh|g9qmtU%lr%I}!tbZ=kwWh_NTBA5z{e;z&ioRE-!Y*EZCR(O}%Q(fJEkV{&TkTBfp zK%z*&p8aIJuB8)}X4hNx-<7#Rg2yaKSvUMZ5~C`I2Hyr)`)DpObgnU6nm1h zi}(FDz~6%r6BmA@;UXQ!;OC{a4szqqch_p*PGJE#N|r+1D89B9-tF=)>t-Ay($ z)rAUjVn{20ybVyc@6JD?jO;8oC@D5>N(2&c44B{O&`Fl`PkQ!QR3KwMg1=Q-VdIjq zXMFx_TqgUL&27#n9i2hHN0jEqX7aCx>T(8BO#6%%p1%~{`jZjkXpv&Gr!rgcP^amt z(^F`~Z|fE+Fk(Dbxfg25h+SpplNOyMT(Hv~|d-^?C8 z(Yo=p=L2@gNJ8@Ls7swE1Or4wM&6Wt3;6yXZ0Y~o!cDm}Mca?$0V*i+beo1L9`^M? zofhCTOcebHNNCTh{6M7R*`QIve3=ApUo^}4-X zrq6~CayKr{jyBhQKvVm($(8^a;=H`p?0u?c447t*_!pu&E&5UfBCUH9!NCuT6MU0P zUibA|{6%1J%`GoiNzg>V}4jmX>#1TQ39wj=xKSL%DHEu@+Uh=+PhyUT<-X z6<+HaHhu5gAWr!(g>@Co!le_fF9Hf33RmLXr=vfZuF|gaMBL42mNT>Akc*RI9jDe; zrz9vmJ!+9o4$0ScN`%<+_qW{&6xWysIKDD-rPYSy$BCOnCdyuExIQ z;Ny3Y#qVM+I7CK4mBn&f~l54 zQfA$uA$i^s!3ax^8qLq}}xI3yl zqjyvWfBbgbCRUP??dsXoo{!P`bB)Lk9SiedOb%1YEBz`Pcc8%z4Gz9w?}hRQ8Mp^yW+;}v+`R`K)mbJOAt`z;a{b=SH_w}$h^ zkfQTE@N^_WLlaOiw}>(^6gM9VW@O|OMMu3xFR#QwhO4cu4Py6I<%<*^CSS5cqqBlS z1!1Dhl9K4A?Z!yZn4C=qoNa08>W=*Sg~Y*wG1ZsNLk%6BE(q;wJ)7Cl`}|A*L>X}N z{%y}F0tsri)E{y%N5{tzs)?qyb|*3lMsl^h$0JOCNSuP(U}RyXZ?pBQrr4-~D78N? zf5ZF!NB9{w4~=2`Is3O``>B*jX1g4Ej{y=@Iuu*{G=&lcvu5071y`7yIkrlEA*J^$)tHR!vt@nYgx~3`!40EU~TD%Wl~|4F@HBu+;OhzgIV=WvMaivVN9% z81k1Y0bZD{uXY@KF2tcZowcwGhWt6?Yvc1=QMy4R`~||jPQWjhg^jJlp~gmRt^sS` z>fy4#!2A94ym-RY{(tD|BvT=6^KH$Ts^&O>4DWB#Yu4MrU7K;Pn{ut!J7SZT>khEv zW_OYiqn#TDK<}=8;wy>hC)5jv&nDn0noR%edw~6J5;rA_1<*=0W8;tP0r@P#xRD~W zKYMNmk`&$J_=fxK^#%)eL4wXi&7T9KM@^lonPr5pX4)$(yWQ^7G>((RF#^?CK~b>* z-f0N@e&$S=eQ57vMUm87K+Z%%Ntsz&n+W;UNbDuholMG-z{HNvbyh4-HT}(`QywVE zD_TF6iPZ5`aYwNHQXfkYP~7wzUyL#9%KFez(zsTudo$vpoul&@TZN;6ZT^V7tSma{ zNSTPjm&YzuDGo*js%CC!3FtdQzMZA>81{~Q8Vm;3BlKr!&$EU7#G%@x>##OKwz z%zQ7_uX-=~loRM8&AaWmO6d|GwTpBX+=LOd7(58NY^r{LybgF`mF>WO%++zse|DP7 zJ@FvfYz11OmrQ1J4_1-7T2GoJpsi5-VG{XE#SoE2FHZ#L5jq^`O(2{N<|L)K*W&ks zsp#&!=N_VswZl~aL&-fih!8Qq|7(DUS1h#0sm-dEo&u+aGR!4=mkuWk#+l5_%xhJX zN`{8i*4EY}WMs&dVJGX@Inq>DZ-c~TMRoO?q@<+K%P+bK@1FR>jGK~@^6As3jG7u! zX}QyJApwESiu)WK9M3$0ji4H^R7UkUsWb}Yv375w8gCpNA5#Eo2fbe~{hAIX$9!`^ zK{(7Qpt6T1^#;6kNYSB`eXz9Wb9zZ}NfmA|OqKI|JaG7Ef=?@#*y=Z_+DQJ7;^|V- ze@69g3^rBCN3(teWfQ$ZttZMZ4Tm}sfgs^9swb3H7k++P?V`?~HV2(05a#%vpL)%p z{)OLdx~oij8&x-uM?b2VbfSDH>p8cl}SD`_d)JpN#5`-P86p0 zZS}Ar_b^Lk>>vN+-YaFPSZVa#_EztZKcq;t`tX__XPv*Pz_>plD z#NVp}Y@)+iCd(gA*>BX9Z!L@5AE;%BxGj;c%1jlJwI=fingeD-uLFnQH3wkq0b@(D zkSi_HfO%bOx8mIcj>A5zb*f;E4zuf?j~KszfP25dM7i673>-lOHr6S62a?ba@B~0z z2a!-VL%jA%O;b}7B`xiWt>hUc0+(Mq?&Jz+I~b5GoA~?9DX>)i`^P z9C2fDfJ0(1DVvTPT={NjT$ z0M9%R{9AA#5G^`rD&Ptm|Lhmy>|q^q7w4#a|2;VOChyXkLR>=OtC6xMn)@G-KzF3C z0xe{9U7hFOHFcd*qaJuuawaJ5v9qIPz?vy{U1(NRdAI+~%(v$56BRf{{9Y7m(AqysEPhV-%96#Ez}I0VEW0ef1AYNUtht-P<-`==KFS2lsv3&B%D-X zVPSL7vhmf+?O$8FyuA0RAjt;QjPr_b<(8M3Cx7(JADpz<2&S$+r&|3{mtp-Nj`8&D z47^pd3mTGvUI!)>)9vrG1jgv&Y=2w8$CQ0E3hlla~1@N z-QVisN6{&r7MT?lZxe^vd9oV%3(VorDFC@l- z?%m~Yn%TxXqDt+5Ik%G!=nwo4KC)B3bu-Nhy697H;QGQQ=zARt@`&D7Crk=@Tr2B-G-Bu)MPbR2db_c=f=l$V( z1$EcqUTTh$h-O>;{UA%f(C_bGCnM)?n@GOqPp6ZtL07zHIitOqiUR`z*qek2Ziu_} zFhH(E9L&r0kH(Hi^AvauX<3-dtUIqkf0gFJV7C(YG*au?p8O;r-5M1^8+KEtr=@*g z3gy-|_<8r~ZyUF7NK(ft+<1K7tTnldF05!1B{-Eo^0IE+u&`;+z~5h>>1AOdV(LzF zvet9^I(TcV<{jxMy>-3$)f0}!yUYw)DqOdKyAT-|2p=!@bLY={XYg&K*?yLt=xkfBjjb+cCu5y>7*fdynF6~fU_v+QF+2?h1H1zeUGF0S_?L5k$ z!E7bV{^+T8jU0XG+TupxllqBn?{{4~w!tDSN+^AuUhu>E%g(1*@xJ|$eTZ!Y1Z~Dl zF}~W{by-xeBN{tBks`5BwZr4TeYd{IxVxjU{9{XDH;?-|QQWT(VcxsR6ykS$EshAne+}zx}-bdQJ8`@=LUzJut^PmQoIc?R?wRwD4tAQV~ZTJ&3LVIrB*BFgcRe`IP8* zP;x%Cw~wVq6#gNbThMrZbr44>_^|Q)mMvSXtgOCaa}x8W3Hw0pj+5M4N+M>qXM%3? zP<|NsgOQY?+RDZzv9gjavps`)(l0cNCPzZFYog;>sU1cRdWQE~?^Ss{ zr=wgSrp*2{*wT78rGnf~MoQ&lyOcE8t|Xe*ianHF{K;;qvx8Yr$G%ADg401Ii#jYv z8?4&GHgwQ4c!>GRQ+x6=M zZz%DxI__^u)|U==70k`C39rn}DwE&G^&&Qop0q?`ck{B}9o26MCL+-*lJS$5H0a$U z?aN1^w=0L`CGbrEo|-%8w`*B$k2s~K`~0`$zu&^7yT#c}M52OKcd@fmZBP-YZfx7w zPI0PL;&>@q05^=TgYfIiIiUdTE`|4aNx7%%7(D5cb`x>)>x>m`xXZE)|n`iI640=)=?{8$FlnJ&`_i zQ~w&zX+aw$!N3fjuh7n!2uG!5Wqr!lPv9GHdc}_!cfyH|=7Cs`Q$(U7%~8xoX2SQ_ zpHV5x=(TUEc%12P{enH|OSVNzTnmw^vaqm_hXV#`88>L%;1uceDt;$-jsr>y#_?cR z4mFzpFgbU*P@i8=Fa@_g+DlC%qjw?k?}NX3T((5}Xw#XKoRmZn)|hnAji|#; zvBn4M9qxS9GQYG?Mv)fE9WEaGE*$JYZdwM*t7lbDs_9o%|6vb&pKXg^Sz3~ip`BLz zHge~$@Y&secAb~TmWoP*@OX~5S=vZqILdN*)!V;xEcZrV%pbZU-rZlX^U0mPy4~hl zY4~pwHm^omfw-?jjS9Gmk?&S!Uad=Q`XNCcgTV{Z4U6`a1mi7w7bnpK@+CbxyVh2O z6gsr0O@Pd9SFjXnSRS<&tNC`MO8O4sGD9&G*rN_$A-iVv)3TE@TUjY$*SyYsdamZu7hRuGmVlLmJg(c>lne^+F>`tl= zuxC9Yln|;a&@sp}hKR2?NNQEgcy&4wf69LB)PwsY&Ut`RVz7N7-~8--w~k=j=Wp;Q z_VqnN6PcB@OgTZd?Pq2B#n2NpvfcV# zmprRVqHhFnXpfpFyb8bZj%o1v%PY1fChPobtBWgFuKr&&Cc&|RY;4CZjR4nxxl1{B zW^6ZHit$I|`#3VP0H5|cFsXG!Fz>lG=Q-YLEw~}9b%Q-e7vu3KEhFL&YJ_ae%!U|* zV-^8&uU-5Ha?}5GS~?a~KVv9-UTrtc>CFP`AEGxq6_H`Ldgb(u8&ioonU0$l&Rkt? zY$#$K>Zva|qELNF$8+T97muC^dPatwf%PZK*Dkwm*)r?puE3#s=HmF=QhHXF87c{y z?GL@Z+0@(WY-$H@VEZp7ECO!Bx`(dcw{yIO{dnErvAOJpnbCq@DbeT;PJlYWrv$j0 z@9<&8bpu{<4VtnpNe|vVmnjmd|LiEDqPn@@@u%sx8F!Styt^J~7Vf&$YwNd6nkWLq zvU&VokN-25_SL`6=0S!S7z+!-;hJ%iWWzP66zUDO9TKndwbdmsDSM=OH^P*Q9&`!- z=QNt~3!N%)VmG`l7`un#(orhDgSHPB;6L!L`HEx>etm+uk3?S^A=(V^@pAO?D zsRd771|%x$;p;*r=bm%+m%xRg2|@%w84x;%G9_2%FVp<&&waJaH#CXbQU94s_tW5J z*(9uDkn{4Jrm`#lwwdveQ9#r1$81Ks;%K}$7zI;OHfOfKC2KdlHc_K(grImY%@(`j zJwf#~DQBb8GBYp#FYyOSchE{;Q_Fnz&FhJdU~q~osWBs)1mE|A|loipTZsY z@iRO~3TZ7W54hZ@+q z(huFwYx+?dT;!3K#^)z~*V&A&-C$M{mTSB9?WUFRV%HNB6O^vMmsS>EonMM<^ zqqaw@#qsD~ngVpv9;-9)ZJ$2L;dNA-YyLSCd+j#sce*+=;g*7)iT$`cq6LTk!?ekH1%=*@55Ar{*3eIDg16Y-!Fuv@Ty@k_~x!o>Ef^Y8(7(H8l+kme+g}zJJr= zWMi3*YArBidpUs`*WE2{ZDZqGXX;(OlU7clzV1kLOIhvdo0ks?2sCdMJbdU-a(=$> z>C0B-DG>}d7^Hw%VJhVr$`%bxfR1$8LyBapb{gE=jxI-e?opl)w=$9M;&$J!buQuK zK9%d`>5(ge^-K?S^P(u^*6&iumyS)~KGJSo~AqT|fI_LIeH@1%~7_Jz(>A zLRKT7UqQ5A6JY^<-KuPw^q4!@=RRkM*O~MUD2fn_$GQL28)=Pi4c&hR&(HM>I{z#4 z5WhDO!vYX`8aWL)74u7Fx~jCM)5~!-lD-K_?6mKx4Onp?aM>H*YW=u1CFQtIVP%qc z6+OcRZKVcbh^@ZdsNaW9;oQZ@m@twc4TKoAB2}~d(cpFNaR<=HM*dkMDE;6o-Bbc@HHzhgQ2QY|qo1~v)2PHDL7_R;|3 zVg?sOGy;gF#4C?oiAHPHcEw2MYyub=)_pURLE~82?)|xsZ_}g}9A&1wUsU;F|G^0p z?(fG1C}fmMkDG@c2{R)j9^O4H5x2a0)f~EmEaOU}Tzi_RdY1Zbri=7J^@us$iXTV7 zbqprE!zdhV1{VY#d!ZMgGWj^jBm7J5$08j~OZjCl#vYFE(Ju$X(jA8bZpUZOf2eD* zoP{gpSwe!>16J3Eq@@5vNM?32yRWQd=n3U7UHKBxMDxHq3b7jz#Kr|fM+T|o zZ#x$1L|<3sn>RhIH7&<4v;19AYT!cUA_Gn!x;?;tB#oAUA2~UX@bMCh8~PVORA5~; zZ`ndrEtSBMow2L#Xq}ntbMcxADK;S?Dy0Rpd^fMSTGJ0l#S4pye&pyfd%4(O`Dh%< zW+u4Ui!%H}^`-{q2A*z?46~QXOi}46O6+#w|?y z_OmGLp|oq={YOmp^qZe%$4e{Vw)xJbMN=Rx47Z~Bn=f7 zVkH$76};dW#vpsa^rRG;bdiC)vE?o^h!L6^Hj%VR%(nqWf21M?((@yd#cHzRl4!OQU}S@_M8!5jkJdSTlotdnaL z*lRZmPIK`UpYi5&U>RPIIk6G^)B#5}tvQu-68m!ncx_x8>@BiG8%@*XG{BjW2osV4 zfdAq!5yvD#mD&KUX&D$~9dyfYloPa3%rRMZi=chg`>1W~7%kJE4-K=wnnY6;9x6HQ zX^RdMY}Lt}EePeF-Eyxgh!4?ccvYM%>ZQh`q7a}F7Mh;dZg1q`E)bYS zV+1B0G-Q5^H2wZ^m8}{yp~0uU2X-AwFQ49w(beyi+gVVXam8>$ z==xFXkD`5II%p2v2_8NcU06vgm zu;%5fi{pf;gfisH`H^=e@v3TKhaKJxElOPcDs0!e{O5SnLnC9am+a9U<-DGApsw8( z?7=9=xf||-87%4b>p0Nt6-Ekp9q|Cjhf7FLFRu;YZ2mNxhs+s{I?0<(Q`s=MHU15oqvwwZ|@AG+c-Ft zr@zj+PPtTwZO^%*@Xg6f$5?x3a`R{A=$1N&r!i0o=)SmvYy_gY0TRW}$0x1vxLh!$ zRA2+8o&vpa*v2GQ$89a|m$Ft;tb5yU$2k=H@tU1CPe|rkdgbIUukroo&m^F^@K4+PId91P#~5UiSE}?_ z@RH|+ClMh`jA4}i%A7mZY5nE%KL6axe>IQi?)R%OEwI!62UQr9;WJ18CoxD`XpzsH zp{`t+xJL3h=Tkiwc|n3fkD7{G03hkdwzhjHCsXxoqa7EoC1+&#jf_~txlJqoDjj8o zst_}BYuXj;hOh)02}I#r#6`PHZf-GfD?{6!ZBtqJC&}rR#OW|8{?hWTst>Ii7AM?f z6?2xZ(l^f@F*@78VAAsRI1$jG4IX(H>z|Q9LfHi_7OCEn3f0QdLkWd=jgXumr!z9X zS6{TU;sg; zK0ckJM~?g#CvlsMI;e1G0Jh@2JICkUIldqHR^8p9RMTyjuQ7r zkuhZqlQnrv`$>TO4g_4;&Jf41`5Tg`=^J9d-OXSRTu`u_K8*J{l2yx6(#J=1z~T1op0 zBZWp-odcx`ZD_R#ATVg42M~3=o)`=XwG3$D-@QK_SvfRUxh8?*?@GG>p_9wXY^USZ zSDoX-B;x_cfP_xev)&FMi7o`lJ9jQv=oi3#uDvufw>;-=ox)~mR4{_oko_fwUq99v z(WM+7dTspu)DfzqVX?P`56TE~2;YkdrXQf+pDsbO`JOWsRmsRxo8PV#t`(2EyY-2@ z74HMizhZ!Rn`CY&s@Qz^AeDO9+@b3&z0u9m1tvUwvs9Cxm$LBKtog@42H|?y@q^D&4n*