Compare commits

..

2362 Commits

Author SHA1 Message Date
romolo.manfredini@gmail.com 23b9a757e4 release 2647 2013-07-21 08:36:52 +00:00
romolo.manfredini@gmail.com 65fdb1a64b Meters in PREC1 should not be played as Feet in PREC1 (all languages) 2013-07-20 22:00:51 +00:00
bsongis@gmail.com 05fb10b7e3 [Taranis] Meters in PREC1 should not be played as Feet in PREC1 2013-07-20 21:42:33 +00:00
bsongis@gmail.com 3a359b2075 0 is singular in english! 2013-07-20 21:17:56 +00:00
rob@marotori.com 01fe85f969 Another fix to tts! 2013-07-19 22:00:56 +00:00
rob@marotori.com 7b00d70cac Update to tts 2013-07-19 21:59:55 +00:00
rob@marotori.com d56492403d TTS Update to include addition voices for built in Taranis alerts! 2013-07-19 21:50:17 +00:00
bsongis@gmail.com a26ee86101 TTS wavstrip added 2013-07-19 06:30:13 +00:00
bsongis@gmail.com 509399ad04 [Taranis] Negative timers badly displayed. Port to trunk 2013-07-18 22:01:55 +00:00
rob@marotori.com b444e857d7 Update to tts.py to enable support for the "2cnd speech" software.
The software is a sapi wrapper and makes cleaner sapi wavs than the ttsPY system.
2013-07-18 19:54:03 +00:00
bsongis@gmail.com 35f3ce021f New TTS engine added: translate.google.com 2013-07-18 18:10:56 +00:00
romolo.manfredini@gmail.com 05c55592f5 LCD Adjustment for TARANIS 2013-07-18 15:57:22 +00:00
bernet.andre@gmail.com 6968b552ea [Taranis] LCD refresh init removed 2013-07-18 14:47:12 +00:00
bernet.andre@gmail.com 566fc2344b [Taranis] Wider contrast adjustment range 2013-07-18 14:40:56 +00:00
rob@marotori.com 89c1962c5f Small tts.py update to improve sound quality 2013-07-18 06:03:46 +00:00
rob@marotori.com 511b63d604 Updates to tts.py to enable 'taranis on command line.
e.g:  ./tts.py en taranis sapi zip
2013-07-18 05:47:42 +00:00
bsongis@gmail.com 1839ff7dcc [Taranis] No more --- stored as a bitmap
[Taranis] Telemetry CRC fixed
[Taranis / sky9x] Unuseful sources are hidden in the lists
[Taranis / sky9x] No more --- 
[all] Recursive custom switches bug fix
2013-07-17 21:49:39 +00:00
bernet.andre@gmail.com e8822c805f [Taranis] Sport CRC not working yet 2013-07-17 12:49:57 +00:00
bsongis@gmail.com 19d1238ab6 [Taranis] Telemetry serial interrupt fix
[Taranis] CRC check on telemetry data
[all] Mixer bug on recursive channels
2013-07-17 12:34:00 +00:00
bsongis@gmail.com 7db61e7385 Issue 61 fixed 2013-07-16 21:24:47 +00:00
bernet.andre@gmail.com badff8ff1c [Taranis] Slider center points calibrated
[Wiki] Changelog, new options
2013-07-16 11:55:59 +00:00
bernet.andre@gmail.com 981e402e68 [Taranis] - sign not visible on timers on custom telemtry screens
Double - in logs for Baro alt/Vspd when value < -1
2013-07-14 19:17:47 +00:00
bsongis@gmail.com 50c7a8b5db [Taranis] frsky_sport kept as before with the fix from André! 2013-07-14 18:32:00 +00:00
bernet.andre@gmail.com b941aa0277 [Taranis] Bytestuff was wrong on SPORT! 2013-07-14 16:45:44 +00:00
romolo.manfredini@gmail.com 4a8f1281d4 rename lcd_init1 with a more explicative name 2013-07-13 11:53:05 +00:00
romolo.manfredini@gmail.com 3f9c37bb15 Initilize contrast to a reasonable value 2013-07-13 11:09:57 +00:00
bsongis@gmail.com bd1f7b332d Conflicts resolved in simpgmspace.cpp 2013-07-13 10:58:46 +00:00
romolo.manfredini@gmail.com f3d38ab8e2 Add contrast adjust for taranis 2013-07-13 08:53:42 +00:00
bsongis@gmail.com bd166cae99 [stock / gruvin9x] Prevents wrong PPM frame length 2013-07-10 22:15:13 +00:00
bsongis@gmail.com e8a2942895 [all] No vario when telemetry is not streaming 2013-07-10 22:12:48 +00:00
bsongis@gmail.com d144b2dc05 [Taranis] Issue 57 fixed (reboot with wrong PPM settings) 2013-07-10 20:00:54 +00:00
bsongis@gmail.com 3cbad08e50 LUA source code added 2013-07-08 12:58:33 +00:00
bsongis@gmail.com ed61d18878 Non regression test added for the mixer issue Andre found yesterday. 2013-07-08 11:09:48 +00:00
bsongis@gmail.com 34b6c5bc3b [Taranis] FrSky support/warranty removed from trunk. Only the stable FrSky branch has the warranty. 2013-07-08 11:09:06 +00:00
bsongis@gmail.com 35837548de [all] Revert of last 2 revisions with another fix 2013-07-07 09:20:52 +00:00
bernet.andre@gmail.com 4c92ad1da8 Refactoring 2013-07-07 07:50:18 +00:00
bernet.andre@gmail.com a548818523 Mixer issue when slow down was used 2013-07-07 07:31:46 +00:00
romolo.manfredini@gmail.com 47723faaeb Italian Translation 2013-07-05 22:20:16 +00:00
bernet.andre@gmail.com a366053b72 VC++ compilation
French translations
2013-07-05 21:27:15 +00:00
bsongis@gmail.com 9c1761972a VC++ compilation 2013-07-05 21:09:09 +00:00
mhotar@gmail.com 0d64e6b3c7 About page - CZ translations 2013-07-05 21:04:10 +00:00
bsongis@gmail.com 2b3fe0f752 Simu getpwd problem 2013-07-05 20:05:44 +00:00
bsongis@gmail.com 7ef4fc4594 Simu correction 2013-07-05 15:34:21 +00:00
bsongis@gmail.com 6e04ee65ee [Taranis] Version string added 2013-07-05 14:56:41 +00:00
bernet.andre@gmail.com 8312989282 Current log was 10x too small, consumption added 2013-07-05 13:55:39 +00:00
bsongis@gmail.com 32a2943a83 [Taranis] About screen modifications 2013-07-05 12:37:26 +00:00
bsongis@gmail.com 7501f9c403 [Taranis] Last minute LCD driver major change!!! Not tested at all by me! 2013-07-05 10:06:43 +00:00
bsongis@gmail.com 0f2d097a43 [Taranis] X16 renamed to D16 2013-07-05 09:55:06 +00:00
bernet.andre@gmail.com 0cb22c6cf2 [taranis] SD splash OK this time 2013-07-05 07:53:46 +00:00
bsongis@gmail.com 57c3a19e8e For companion9x. The SD directory will be customizable. 2013-07-05 06:20:09 +00:00
bsongis@gmail.com 9a79ea4919 [Taranis] Cosmetics in TRAINER menu 2013-07-05 05:35:46 +00:00
bsongis@gmail.com e97af2fb23 For companion9x. The SD directory will be customizable. 2013-07-04 23:05:50 +00:00
bsongis@gmail.com a7c26a4514 [Taranis] Splash on SD fix. Tested OK on simu. 2013-07-04 22:55:31 +00:00
bsongis@gmail.com a19970c0ca [Taranis] Splash on SD fix. Still not tested. 2013-07-04 21:21:40 +00:00
bsongis@gmail.com b362bc7f9d [Taranis] Splash on SD. Various fixes. 2013-07-04 19:31:03 +00:00
romolo.manfredini@gmail.com a03c3a849d FAI CHOICE prompt asked too much 2013-07-01 15:50:31 +00:00
bernet.andre@gmail.com 6442950fc2 [wiki] Taranis manual 2013-06-29 19:33:28 +00:00
bernet.andre@gmail.com 750922b698 [Taranis] LCD startup delay again 2013-06-27 06:10:37 +00:00
bernet.andre@gmail.com 0abbfa5f8e [Taranis] Debug log appended correctly... 2013-06-26 21:59:07 +00:00
kjell.kernen@gmail.com 3b491cdf82 Portuguese 8x10 lbm font. 2013-06-26 18:22:02 +00:00
bernet.andre@gmail.com 0f00dc3e16 [Taranis] Debug log kept between sessions 2013-06-26 16:11:50 +00:00
bsongis@gmail.com 75ce4c2afa [Taranis] DSM2 continued 2013-06-26 15:52:01 +00:00
bsongis@gmail.com b15030afc3 [Taranis] USB bug fixes
[Taranis] DSM2 continued
2013-06-26 15:22:21 +00:00
kjell.kernen@gmail.com b1389ee87a Portuguese 8x10 png font. Will check in lbm version when I have access to development environment. 2013-06-26 11:45:09 +00:00
bernet.andre@gmail.com 4035b82831 [Taranis] LCD reset time now respected, init is reliable again 2013-06-26 08:15:35 +00:00
bsongis@gmail.com 8bac09c126 Warning removed 2013-06-25 19:46:21 +00:00
bsongis@gmail.com 381af741fb [Taranis] USB deconnection fix
[Taranis / sky9x] Less maths for audio (no more sin)
2013-06-25 19:31:20 +00:00
rob@marotori.com 2d3215466f Small compiler fix 2013-06-25 13:05:08 +00:00
bernet.andre@gmail.com c924a369d7 [Taranis] Cleaner reboot on USB disconnect, longer LCD initialization delay to compensate for the time saved removing USB initialisation 2013-06-25 10:45:10 +00:00
bsongis@gmail.com a9208deb91 Some TODOs removed 2013-06-25 06:02:03 +00:00
bsongis@gmail.com d0156700f5 [all with SD support] Update to latest FatFS version
[Taranis] Bug fixed with EEPROM saving when USB is plugged. It will now reboot when USB is unplugged
2013-06-24 19:46:12 +00:00
bernet.andre@gmail.com 475b8bc3e6 More telemetry info logged
Negative numbers in logs fixed
[Taranis] SPORT telemetry
[Taranis] Crash when connecting USB during EEPROM write
2013-06-24 13:11:27 +00:00
bernet.andre@gmail.com d796623e3a Language .h files are auto-generated, but they should be committed too (for C9X) 2013-06-24 11:46:08 +00:00
bsongis@gmail.com e5595cfdce [Taranis] DSM2 BIND code 2013-06-24 10:17:25 +00:00
kjell.kernen@gmail.com 442264199f German 4x6 font fixed. Missing font dependencies in Makefile added 2013-06-24 00:14:08 +00:00
josemoreno259@gmail.com ea4ffb99b0 Translated the last change 2013-06-23 22:58:44 +00:00
bsongis@gmail.com 9cb49d7f83 Simu cored on SD Logs function (when no ./LOGS directory) 2013-06-23 18:44:08 +00:00
bsongis@gmail.com 4c34d8aaff simu core 2013-06-22 10:51:07 +00:00
romolo.manfredini@gmail.com 1f31c60c82 small fixes in IT translation 2013-06-22 08:41:21 +00:00
mhotar@gmail.com 7ecc01672f CZ translations 2013-06-21 23:45:40 +00:00
kjell.kernen@gmail.com 67b6a82671 Translated new string to Swedish 2013-06-21 23:26:11 +00:00
bsongis@gmail.com 5ee5fa7e98 [Taranis] DSM2 fix 2013-06-21 22:46:38 +00:00
bsongis@gmail.com e86aa51a22 My test code removed!!! 2013-06-21 22:36:48 +00:00
bsongis@gmail.com e25200b45e [Taranis] DSM2 fixes 2013-06-21 22:23:52 +00:00
bsongis@gmail.com d91b8ecd0b [M2561] I hope AUDIO fix... 2013-06-21 21:40:47 +00:00
bsongis@gmail.com 288a697264 [Taranis] DSM2 fixes 2013-06-21 21:33:52 +00:00
bsongis@gmail.com 432ee0f337 [Taranis] DSM2 fixes 2013-06-21 21:23:06 +00:00
bsongis@gmail.com 7534e58bbd [Taranis] DSM2 fixes 2013-06-21 18:39:50 +00:00
bsongis@gmail.com 5e6c32b929 [gruvin9x] Cosmetics 2013-06-21 18:30:26 +00:00
bsongis@gmail.com 0e441c1baf [sky9x] Compilation error 2013-06-21 18:30:03 +00:00
bsongis@gmail.com 0f3b5d8fd7 [Taranis / sky9x] Vario improvement. To be tested. 2013-06-21 18:29:33 +00:00
bsongis@gmail.com 9b0b2d078c [sky9x] PXX fixes
[Taranis] DSM2 fixes
2013-06-21 18:28:59 +00:00
bernet.andre@gmail.com 7fef965b08 String translated 2013-06-21 17:58:10 +00:00
bsongis@gmail.com fc4a41a689 Compilation fix 2013-06-21 16:59:34 +00:00
bsongis@gmail.com 836cadcb13 [9x 2561] AUDIO fixes 2013-06-21 16:55:41 +00:00
romolo.manfredini@gmail.com f65e99504c Italian german and portuguese prompts update 2013-06-21 09:57:13 +00:00
bernet.andre@gmail.com b7be29b9ca Servo test template fixed 2013-06-20 09:28:54 +00:00
bernet.andre@gmail.com 761eb7add1 Typo 2013-06-19 22:12:25 +00:00
kjell.kernen@gmail.com f4a3d199b9 Portuguese 10x14 font. 2013-06-19 21:50:06 +00:00
bsongis@gmail.com 318abd2667 [Taranis / sky9x] Delay now applies also to non-switches sources! For my demo tomorrow on ardupilot flight modes selection (8 modes selectable with S1, voice 1s after the pot is moved, fligh mode started 2s after pot is moved)
[all] Same reason ... curves can now be like steps: x(N) = x(N+1)
[Taranis] Model bitmap chosen from the SD Files Manager
2013-06-19 20:38:30 +00:00
kjell.kernen@gmail.com 171c77ff64 Checking in the various lbm file changes resulting from the png font file changes over the last two days. 2013-06-19 20:26:01 +00:00
kjell.kernen@gmail.com 82ffb34ec2 Auto translated langauge header files checked in. I suspect that these are still needed if someone needs to build without using python scripts. If this is not the case the header files should be removed. 2013-06-19 20:19:09 +00:00
kjell.kernen@gmail.com 5a157471fd translation.py only worked properly on Linux - Fixed. 2013-06-19 20:16:39 +00:00
kjell.kernen@gmail.com e416fa4871 Changed names from .tra to .txt of header files with national chars. This will simplify editing since .txt fileas are opened in text editors by default. 2013-06-19 11:14:34 +00:00
kjell.kernen@gmail.com 72aaae0b4a First Portuguese font in place (5x7) 2013-06-19 10:48:24 +00:00
kjell.kernen@gmail.com 0f3928743c Added a command line argument to reverse the translation. Detranslate is made obsolete by this, so it is removed. 2013-06-19 07:56:51 +00:00
kjell.kernen@gmail.com f6d1986b5c Found and fixed an error in the Swedish translation as a side effect of checking the German translation. 2013-06-18 23:59:01 +00:00
kjell.kernen@gmail.com d597c5d653 Changes in comments and the Spanish and German translation header files 2013-06-18 23:43:00 +00:00
kjell.kernen@gmail.com ec970f7dfa Integrated updates sent to me by Helle. 2013-06-18 23:32:00 +00:00
kjell.kernen@gmail.com 43e18379ee Oups. I had forgotten to update the filename inside the files before the name change. 2013-06-18 23:04:13 +00:00
mhotar@gmail.com 2f5fcfcc01 Custom doublesize font chars for CPUARM
CZ font bitmaps
2013-06-18 23:00:42 +00:00
kjell.kernen@gmail.com 5d484a3eff Reintroduced changes from r2504 that were lost at the name change from es.h.es to es.h.tra 2013-06-18 22:59:12 +00:00
kjell.kernen@gmail.com 5973057d7b Added automatic build time convertion of language header files in UTF-8 to header files with special characters inserted for language specific bitmaps. This one is scary since it affects all translation builds. Revert if anything breaks! 2013-06-18 22:53:08 +00:00
kjell.kernen@gmail.com 76ee88eb4c Translate.py made less smart and broken up into translate.py and detranslate.py. This means that any source and target file names can be used.
Only translate.py is used by the Makefile
2013-06-18 22:47:40 +00:00
kjell.kernen@gmail.com bfe67b39f5 All language specific files recoded to UTF-8 and renamed to *.tra 2013-06-18 22:43:55 +00:00
josemoreno259@gmail.com 3639ec807d Made a small change that caused a lag 2013-06-18 22:30:16 +00:00
mhotar@gmail.com ba51df10f2 CZ chars in translations.py utf-8 test 2013-06-18 19:12:55 +00:00
bsongis@gmail.com 2a2840eb14 I promised :) 2013-06-18 18:16:47 +00:00
kjell.kernen@gmail.com d38c32544c Added specification of output file to translate.py. Will be used by Makefile. 2013-06-18 15:31:31 +00:00
kjell.kernen@gmail.com 8b37174008 Czech 8x10 font defined. 2013-06-18 14:34:18 +00:00
kjell.kernen@gmail.com 66b810b7ad Last German font file completed. 2013-06-18 14:19:42 +00:00
kjell.kernen@gmail.com ed55931f77 Last Spanish font file completed. 2013-06-18 14:19:07 +00:00
kjell.kernen@gmail.com a92f0b3c72 Added header files containing language specific characters.
These will be parsed as part of the build and the result will be the normal translation header files.
This way the translators will not have to deal with the character mappings directly, which will result in 
higher quality translations. No more \200 \201 etc!
The make part will use translate.py, which I have corrected.
I cannot commit the Makefile since I do not have a working build environment with me. Will do tonight.
2013-06-18 13:14:43 +00:00
kjell.kernen@gmail.com fea4145271 Character mapping updated and corrected to cover all existing translations 2013-06-18 13:06:23 +00:00
kjell.kernen@gmail.com 5e5b093a2f Fixed French spelling error (è in source file). At least I think it is a fix, I do not speak French. 2013-06-18 11:19:27 +00:00
kjell.kernen@gmail.com 190100b8e2 Fixed spelling error 2013-06-18 10:39:01 +00:00
kjell.kernen@gmail.com bd7e6d8637 Match of recent change in en.h 2013-06-18 08:10:08 +00:00
bsongis@gmail.com 77409ec7d8 Compilation error when FLIGHT_MODES=NO 2013-06-18 06:52:41 +00:00
bsongis@gmail.com 10049de852 [Taranis / sky9x] Specific volume for beeps/wav/vario/background
[Taranis] New alarm when TELEMETRY lost/back
2013-06-17 17:21:36 +00:00
bernet.andre@gmail.com 24ee0f03e9 French translations 2013-06-17 11:17:50 +00:00
kjell.kernen@gmail.com bc8cfe5a04 Added a missing end clause in a piece of dead code since it made lupdate produce annoying messages. 2013-06-17 06:42:31 +00:00
kjell.kernen@gmail.com b66577deb5 Finetuning of Swedish translation after simulator tests. 2013-06-16 22:40:22 +00:00
bsongis@gmail.com aff9a411b9 [Taranis] Typo in logs 2013-06-16 19:26:48 +00:00
bernet.andre@gmail.com fd042add99 French extra fonts 2013-06-16 12:59:19 +00:00
bsongis@gmail.com 7d452e798b [Taranis] 32k EEPROM Massstorage FAT (thanks Mike!) 2013-06-16 11:55:10 +00:00
bsongis@gmail.com f79e2aba4f [sky9x/Taranis] Audio mixer! 2013-06-15 16:18:08 +00:00
bsongis@gmail.com 46ae2e434a [stock] Overlap in Custom Functions screen when GRAPHICS=NO 2013-06-12 05:34:35 +00:00
josemoreno259@gmail.com 4c01fa5ccd Eliminada la letra "Ñ" por problemas tecnicos con Companion9x 2013-06-11 22:51:39 +00:00
gbirkus@gmail.com 8270bdabdb haptic queue issue 2013-06-11 20:54:35 +00:00
bsongis@gmail.com 7ec7428da8 [stock] Audio sounds fixed! 2013-06-11 18:14:26 +00:00
bsongis@gmail.com 9016e8dc79 [stock] DBLSIZE char ':' fixed 2013-06-11 18:05:23 +00:00
bsongis@gmail.com 2ec67683ec [stock] Another simplification for DBLSIZE. Thanks Mike for the idea! 2013-06-11 16:33:00 +00:00
kjell.kernen@gmail.com a6c9883383 The Makefile was committed twice by misstake and my merge didn't work... fixed 2013-06-11 12:01:00 +00:00
kjell.kernen@gmail.com 1c695a05d7 Replaced all xbm font files with png versions. The reason is poor tool support for xbm files. 2013-06-11 11:57:06 +00:00
kjell.kernen@gmail.com f4d3759e8a Replaced all xbm font files with png versions. The reason is poor tool support for xbm files. 2013-06-11 11:53:21 +00:00
bsongis@gmail.com cbe3a02fb9 [all] A few other fixes with DBLSIZE font. We will decide which letters are really needed here. I am not sure that the , is needed! 2013-06-11 10:35:54 +00:00
bsongis@gmail.com ab37f82825 [all] A few fixes with DBLSIZE font. We should now use png instead of xbm files. Better supported by Qt! 2013-06-11 09:24:51 +00:00
kjell.kernen@gmail.com 5701c029db Reintroduced ':' character in 10x14 font. Removed dead code in comments. 2013-06-11 09:05:03 +00:00
bsongis@gmail.com 01033837da [stock] The asterisk is always there, no more (!) trick! 2013-06-11 05:48:13 +00:00
bsongis@gmail.com 29b941539b [all] PlaySound has now a repeat argument as PlayTrack
[stock] Flash saving in AUDIO code. Warning, I had to change some VOICE prompt numbers, check the tts.py to know which ones!
[Taranis] DSM2 protocol added when compiling with DSM2=PPM
2013-06-11 05:43:42 +00:00
kjell.kernen@gmail.com 63407597c5 Saved 600 bytes by removing a lot of 10x14 chars and all language specific 10x14 chars. I have left the old code commented out for the decision if Taranis should have full character support or not (no memory problem there). 2013-06-10 21:25:39 +00:00
kjell.kernen@gmail.com c246dc27ce Compressed version of the biggest font that will be used later to save flash in the 9x/9xr 2013-06-10 14:41:07 +00:00
bsongis@gmail.com 62326a67ce [Taranis] Display problem in Mixers screen 2013-06-09 21:42:39 +00:00
kjell.kernen@gmail.com b58dcc9824 Disabled the use of language specific chars (like ÅÄÖüíñ etc) i model names. The reason is that companion can not display them and that they display differently in different languages. Existing models will retain their names, but it is no longer possible to add language specific characters. 2013-06-09 20:00:01 +00:00
bsongis@gmail.com 4b014c163b [Taranis] Mixer screen rearrangement (phases are displayed)
[Taranis] Only 8 chars in Expos/Mixes names (instead of 10)
2013-06-08 19:10:00 +00:00
bsongis@gmail.com f4bdc3888e [all] THR and TH% are zeroed on flight reset 2013-06-08 11:14:15 +00:00
bsongis@gmail.com 86a7429f51 [all] Nasty copy/paste bug on Radio Timer (inactivity alarm raises far too quickly!)
[Taranis] Bad display of selected lines over bitmaps in MODELSEL screen
2013-06-07 15:30:49 +00:00
bsongis@gmail.com fc1349fb75 [all] Nasty copy/paste bug on Radio Timer (inactivity alarm raises far too quickly!)
[Taranis] Bad display of selected lines over bitmaps in MODELSEL screen
2013-06-07 15:29:53 +00:00
kjell.kernen@gmail.com d0c4ddd064 Due to a request from mhotar I have restored the settings for LEN_SPECIAL_CHARS to their original values. 2013-06-07 09:16:58 +00:00
kjell.kernen@gmail.com 6e14b9ee63 All the old font files are removed since they have been copied to another location. 2013-06-06 18:50:01 +00:00
kjell.kernen@gmail.com a861ab1dfd Minor fine tuning of the swedish translation. 2013-06-06 18:48:07 +00:00
kjell.kernen@gmail.com dc36a83cf5 All font files moved to a common directory. This will make skinning easier. 2013-06-06 18:45:52 +00:00
bsongis@gmail.com 855c3b6a6c [all] FAI mode enhancements (RSSI / A1 / A2 allowed), telemetry values also forbidden in custom switches
[all] Expo/DR screen cosmetics.
2013-06-06 16:54:27 +00:00
bsongis@gmail.com 4215d5b55d Compilation error 2013-06-06 05:11:13 +00:00
kjell.kernen@gmail.com cec998133f Checking in temp lbm font files (shudder).It seems that not all developers have the tools to generate them. 2013-06-05 22:32:42 +00:00
romolo.manfredini@gmail.com 718d055cbc Italian custom fonts updated 2013-06-05 22:17:55 +00:00
kjell.kernen@gmail.com e589f91d45 Corrected two faulty font file names in translations.cpp and broken dependencies in Makefile. Standard version now builds again. 2013-06-05 21:38:10 +00:00
kjell.kernen@gmail.com bb3751bb9a Oups I broke the build since I missed dependencies to removed files in the Make file.
This is an untested attempt at bringing the build back up. Hope it works.
2013-06-05 21:24:33 +00:00
kjell.kernen@gmail.com d5f19c0da7 Since a lot more new font files have been added I have changed the naming to directly link to the font sizes. A number of existing files have been renamed and this commit is for the removal of the old copies from the build tree. 2013-06-05 21:12:09 +00:00
bsongis@gmail.com c84501fbd1 [all] Bug introduced in last revision in TELEMETRY screen!
[sky9x] About screen
[all] Expos/DRs screen cosmetics
[all] CSW Timer better range (0.1, 0.5 and 1.0 precision)
2013-06-05 21:11:28 +00:00
kjell.kernen@gmail.com 784bab30b1 Deleting temporary font files that are regenerated automatically. I do not understand why these have been checked into the repository 2013-06-05 21:06:16 +00:00
kjell.kernen@gmail.com b2247dc943 Added stuff so that it is possible to use special characters for all font sizes for all translated langauges. Please note that I have only checked that the small size (4x6) font works in Swedish.Other langauges have empty definition files, which will produce space rather than pointer errors. 2013-06-05 21:00:12 +00:00
kjell.kernen@gmail.com d3704b1c1f Corrected errors in Spanish translation file.
There were no less than three ñ characters in the file.
These have been replaced with \201
2013-06-05 20:40:27 +00:00
romolo.manfredini@gmail.com 46d157f0a4 save some flash space in italian translations 2013-06-05 19:11:16 +00:00
romolo.manfredini@gmail.com 46b46b7c52 Italian translations 2013-06-05 06:35:46 +00:00
romolo.manfredini@gmail.com b2824994aa correct the size of taranis.bin file 2013-06-04 22:04:44 +00:00
bsongis@gmail.com 0ac385eed0 [sky9x] TinyApp and applets removed from the tree
[all] FAI reworked
2013-06-04 16:27:56 +00:00
bsongis@gmail.com cf578bbaa0 [stock] Sink tones on vario removed
[all] Bug in custom switch timers (when using the AND switch)
2013-06-04 09:25:09 +00:00
bsongis@gmail.com 6427b8a8bb Issue 41 fixed 2013-06-03 20:50:00 +00:00
bsongis@gmail.com ffe29e6f1a [stock] Issue 44 fixed (without AUDIO and VOICE)
[all] Issue 3 fixed (Timer function in custom switches)
[stock] Huge flash savings ...
[stock] No more sink in vario
[all] FAI mode (YES/NO/CHOICE)
2013-06-03 19:00:37 +00:00
bernet.andre@gmail.com dd7e9ae2b4 German translations by H.Renz 2013-06-03 14:43:32 +00:00
bsongis@gmail.com 6dc8eb75a2 Issue 45 fixed. Thanks for the report and the fix proposed. This code is used on boards where there is only 1 module. So only s_current_protocol[0] is accessible. 2013-06-02 14:45:53 +00:00
bsongis@gmail.com a8f99b1b61 Issue 43 fixed. Who wants to test? I didn't do it myself! Thanks in advance! 2013-05-31 20:23:06 +00:00
bsongis@gmail.com c9171c6d79 [all] Mixer bugs fixed (slow / delays)
[stock] Flash saving
[stock] PWM backlight fix
[stock] NAVIGATION=STICKS pulled from er9x, thanks Mike!
[Taranis] Telemetry logs in DEBUG mode correctly opened / closed (not tested)
2013-05-31 19:33:20 +00:00
bsongis@gmail.com 7e7b1914ff [stock] Avoids the renumbering of the prompts "30s" and "20s" 2013-05-30 06:10:40 +00:00
bsongis@gmail.com cf3da300b5 Cosmetics 2013-05-30 06:10:24 +00:00
bsongis@gmail.com f7c207547f Cosmetics 2013-05-30 06:10:07 +00:00
bsongis@gmail.com 61b8f4b4e4 [all] RSSI should be 0 when NO DATA 2013-05-29 15:43:21 +00:00
bsongis@gmail.com 3a8220a4bb [Taranis] Failsafe settings hidden when the receiver is a D8 2013-05-29 15:36:09 +00:00
bsongis@gmail.com ad653ecd0f [all] The delays now apply to mixes without a trigger (phase / switch), but with a 3POS switch.
[all] The "bolded mixers" (bolded, and beeping if beep selected) follow these rules:
- when a mix has no trigger, it is always bolded
- when a mix doesn't apply to the current phase, it is not bolded, even during fade out (same for expos)
- when a mix is leaving with slow down, it is not bolded
- when there is a delay applied to a mix, it is bolded according to this delay
[stock] All the changes described above even allowed me to save 68 bytes flash and 38 bytes RAM!

As always when the Mixer is partially rewritten, a lot of tests are needed before the next release!
2013-05-29 05:37:53 +00:00
bsongis@gmail.com b593317360 [Taranis] Failsafe modes NOPULSES and HOLD should be ok on channels 9-16 2013-05-29 05:26:30 +00:00
bsongis@gmail.com 40b42a4171 [Taranis] Failsafe modes NOPULSES and HOLD should be ok on channels 9-16 2013-05-29 05:20:41 +00:00
bsongis@gmail.com 1ee7247576 [Taranis/sky9x/gruvin9x] Some rework on Logs 2013-05-28 19:40:29 +00:00
bsongis@gmail.com 98456f9489 [stock] Compilation error fixed when HAPTIC and !AUDIO 2013-05-27 20:25:12 +00:00
bsongis@gmail.com 3492b5d0a6 Issue 41 fixed
RSSI alarms thresholds now 45 and 42 instead of 50
2013-05-27 17:36:01 +00:00
bsongis@gmail.com 1aff10dc35 [all] Issue 17 fixed (lowercase is now the default)
[all] Issue 28 fixed (10 beeps on countdown during the last 10 seconds)
[all] Issue 37 fixed (Pwr+) added
[all] Issue 39 fixed (Potscroll too slow)
[Taranis] Bug with delays on 3 states switches
[Taranis/sky9x/gruvin9x] Date & Time not always saved
2013-05-26 20:48:26 +00:00
bernet.andre@gmail.com 33fff62c0c Cosmetics 2013-05-26 10:48:08 +00:00
josemoreno259@gmail.com 1042f3ea2e slight changes 2013-05-24 17:43:47 +00:00
bernet.andre@gmail.com 6a3b539a22 Bind/Rangecheck sound for PXX and DSM 2013-05-23 22:48:29 +00:00
bernet.andre@gmail.com edb07e2c56 Bind/Rangecheck sound for PXX and DSM 2013-05-23 22:32:27 +00:00
romolo.manfredini@gmail.com 14bb497195 Split taranis stamp 2013-05-22 20:52:00 +00:00
bernet.andre@gmail.com 3e14bedf20 C9X compilation 2013-05-22 19:36:06 +00:00
mhotar@gmail.com 3846677431 CZ translations update 2013-05-22 19:10:50 +00:00
bsongis@gmail.com d9480578fb Cosmetics (for VC++) 2013-05-22 09:58:26 +00:00
romolo.manfredini@gmail.com 782ab91599 better companion9x simu support for taranis rev4a 2013-05-22 09:50:34 +00:00
bsongis@gmail.com 212b02dfc6 [Taranis] Failsafe settings changed for NOPULSES and HOLD 2013-05-22 09:08:15 +00:00
bsongis@gmail.com c36d366ef1 Spanish bugs 2013-05-22 06:07:14 +00:00
bsongis@gmail.com 6efaf223ba Spanish bugs 2013-05-22 06:03:53 +00:00
bsongis@gmail.com a1601aa6a2 Spanish version didn't compile 2013-05-22 05:53:54 +00:00
josemoreno259@gmail.com d043701944 Translate the new adittion. 2013-05-21 22:05:13 +00:00
bsongis@gmail.com 2c5c3de04a [sky9x] It was possible to highlight (but not change) the "Own" in GVARS on phase 0 (default) 2013-05-21 20:20:40 +00:00
romolo.manfredini@gmail.com 7251f7bafa Italian translations 2013-05-21 20:12:12 +00:00
bernet.andre@gmail.com 6b886cf5d7 [Taranis] SWR/RSSI for all languages, Telemetry value position on bars screens 2013-05-21 19:45:29 +00:00
bernet.andre@gmail.com 2ff6e1f644 [!M64] 10 min inactivity alarm by default 2013-05-21 19:28:39 +00:00
bsongis@gmail.com 6b412ed264 [stock] Flash saving
[stock] More code removed when GPS=NO
[Taranis] Last EEPROM massstorage block (512 bytes) never written
[Taranis] Values displayed near the gauges
2013-05-21 18:35:59 +00:00
bsongis@gmail.com b0e49b8aaf [stock] New Makefile option GPS=YES/NO (saves 1.5k flash if disabled)
[stock] FRSKY_BARS option renamed to GAUGES=YES/NO (it could be used for another telemetry system in the future)
2013-05-21 12:44:14 +00:00
bsongis@gmail.com 53e061ab6a [Taranis] Storage capacity on EEPROM disk was wrong 2013-05-21 10:05:43 +00:00
kjell.kernen@gmail.com 53f111ccbf Updated the wording of the translated About page to make it look native Swedish and less machine translated. 2013-05-21 07:58:58 +00:00
kjell.kernen@gmail.com 937183e629 Changed use of CENTER constant to exactly match the use in en.h after heads up from Bertrand 2013-05-21 07:22:41 +00:00
bsongis@gmail.com bc2a9e1fd5 [stock] New option FRSKY_BARS added in Makefile. With FRSKY_BARS=NO around 1k is saved. 2013-05-21 05:28:40 +00:00
pienk@planet.nl 59fdea8ee5 [Mavlink] Added battery status and mode menus. Synced mavlink library with official repository. 2013-05-20 21:41:16 +00:00
romolo.manfredini@gmail.com a2aa7c62c2 fix compilation error for sky9x 2013-05-20 21:03:48 +00:00
bernet.andre@gmail.com 8d4c57bf8d [Taranis] Remaining temporary fix removed 2013-05-20 19:58:50 +00:00
bsongis@gmail.com f31edc88ea [Taranis] Telemetry screens cleanup
[stock] 4bytes flash saved :)
2013-05-20 19:33:22 +00:00
kjell.kernen@gmail.com e25e903896 Translated all the new strings into Swedish. I have not had the possibility to build. I have made a real effort not to break the build, but I am almost certain to have broken something since there are so many changes. 2013-05-20 15:33:33 +00:00
bernet.andre@gmail.com 68a4d94e59 [Taranis] S2 inverted on production models 2013-05-20 13:46:49 +00:00
bsongis@gmail.com 2815ddd4b7 [Taranis] EEPROM is 32k on REV4 (was not changed on massstorage!). To be tested by FrSky with companion9x before production, please! 2013-05-20 13:37:30 +00:00
bernet.andre@gmail.com 149079e8ae [Taranis] About screen translated 2013-05-20 13:05:05 +00:00
bsongis@gmail.com ec5b3039b8 [Taranis] If there was no mix on a channel, that channel's name didn't appear in the header when the cursor is on the channel label 2013-05-20 12:26:35 +00:00
pienk@planet.nl e41ae1fadc [mavlink] Updated mavlink code to work with the current Arducopter (and probably plane and rover). Mavlink library has been updated to V 1.0. 2013-05-20 12:02:17 +00:00
bernet.andre@gmail.com c107643d69 [Taranis] Bitmap loaded upon USB disconnection, A2 never valid if proto==X16 2013-05-20 11:38:48 +00:00
bernet.andre@gmail.com 20af91b9e1 [Taranis] NCH < 8 for PXX
Shift in strings
Cosmetics
2013-05-20 10:01:45 +00:00
romolo.manfredini@gmail.com 0e9b213845 Fix compilation error 2013-05-20 09:23:09 +00:00
bernet.andre@gmail.com 64a2a74a52 Cosmetics 2013-05-20 08:16:37 +00:00
bsongis@gmail.com 10cb8b72db [Taranis] Model bitmap not always reloaded 2013-05-20 08:15:25 +00:00
bernet.andre@gmail.com ce4804d94c [Taranis] PPM polarities 2013-05-20 08:07:25 +00:00
bsongis@gmail.com 05569ef15a [Taranis] EEPROM is written 64bytes per main cycle, instead of completely written in one cycle
[Taranis] Channels count may go down to 4
2013-05-20 06:55:15 +00:00
bernet.andre@gmail.com c762e1bf65 No data reset with EXIT when menus are enabled 2013-05-19 22:47:08 +00:00
bsongis@gmail.com 0a719d9ec7 [Taranis] DEBUG Tx now in its interrupt at 115200bauds 2013-05-19 22:17:54 +00:00
bernet.andre@gmail.com bea62a03ff [Taranis] Telemtry alarm sounds
Translations
2013-05-19 16:43:22 +00:00
bernet.andre@gmail.com d386b65343 Cosmetics 2013-05-19 15:03:31 +00:00
bernet.andre@gmail.com a7ebbe8c94 Translations 2013-05-19 14:04:54 +00:00
romolo.manfredini@gmail.com 6f1291ca21 fix compilation problems for sky9x 2013-05-19 12:52:37 +00:00
bernet.andre@gmail.com 7b46be2118 [Taranis] No TX RSSI on Taranis, some work on translations 2013-05-19 12:08:18 +00:00
bernet.andre@gmail.com ded8f237e0 [Taranis] Alignment on DR screen, better key for editing curve from DR/mixer 2013-05-19 09:42:17 +00:00
bsongis@gmail.com 182d97ed18 [M2561] Audio added
[Taranis/sky9x] Code cleaning
2013-05-19 09:00:52 +00:00
bsongis@gmail.com 6753e0f92b Issue 34 fixed 2013-05-19 08:47:27 +00:00
bsongis@gmail.com ae82c5f7a0 [Taranis] Bug on SD massstorage write (on block numbers > 0xFFFF) 2013-05-18 20:38:11 +00:00
bsongis@gmail.com 878c7b081c Missing BMPs 2013-05-17 18:32:46 +00:00
bsongis@gmail.com 367ca4dfa7 [Taranis] Code cleaning 2013-05-17 17:46:51 +00:00
bsongis@gmail.com c4d6bfbff8 Cosmetics 2013-05-17 16:47:44 +00:00
bsongis@gmail.com a41dc24a2e [Taranis] Asterisk BMP (thanks Martin!)
[Taranis] WDT timeout adjustable when dealing with long delays without pulses (thanks Mike for the trick!)
[Taranis] After USB is disconnected, the SD and the EEPROM are read inside the main, not inside the interrupt
[Taranis] Removed dead code about CPU temperature
[stock] Flash saving (thanks Mike for your emails!)
2013-05-17 16:30:30 +00:00
bernet.andre@gmail.com 80b0f0ee52 [Taranis] Channel monitor with MENU LONG in all model menus, About/stats screens navigation 2013-05-16 18:47:39 +00:00
bsongis@gmail.com 79aa9f6648 Warning on simu / 64bits systems 2013-05-16 17:21:10 +00:00
bsongis@gmail.com 6df7a23d0a Issue 30 fixed 2013-05-16 13:10:15 +00:00
romolo.manfredini@gmail.com e933f62096 fix issue in log with wshh 2013-05-16 13:00:07 +00:00
bsongis@gmail.com f664c2a763 [Taranis] About again ... 2013-05-16 12:45:06 +00:00
bsongis@gmail.com db805b35df [Taranis] Missing about bitmap! 2013-05-16 12:24:10 +00:00
bsongis@gmail.com 1e500d56bf [Taranis] "About Us" screen
[Taranis/sky9x] Lang directory added in TTS script
[Taranis] PPM delay taken into account in Trainer (slave)
2013-05-16 10:34:14 +00:00
romolo.manfredini@gmail.com 931294081c trainer patch from Mike 2013-05-16 00:11:58 +00:00
bsongis@gmail.com 984e179c0e [Taranis] Reboot when loading a model with an external module ON 2013-05-15 08:38:09 +00:00
bsongis@gmail.com db93fb0f14 [Taranis] Reboot when loading a model with an external module ON 2013-05-15 08:13:07 +00:00
bsongis@gmail.com 90be0bae10 [Taranis] SWR implemented with popup when SWR > 0x33 (Tx antenna problem)
[Taranis] RSSI/A1/A2 alarms
[Taranis] Better code when no pulses sent (internal or external module). Thanks Mike!
[Taranis] Correction on DEBUG serial code
2013-05-15 07:57:21 +00:00
bsongis@gmail.com a4cfa395a8 Cosmetics 2013-05-14 20:26:13 +00:00
bsongis@gmail.com 14828737ee [Taranis] Cosmetics 2013-05-14 07:39:55 +00:00
bernet.andre@gmail.com 406d17ff35 [Taranis] Overflow with negative battery calibration value 2013-05-13 21:03:58 +00:00
bernet.andre@gmail.com ed268ff085 [Taranis] VBatt += 0.2v because of the diode, this time at the right places ;) 2013-05-13 20:37:49 +00:00
bsongis@gmail.com 59b26ad36c [Taranis] RSSI is sent by the module even if the Rx is OFF! 2013-05-13 20:07:03 +00:00
bsongis@gmail.com 698e977833 [Taranis] RSSI is sent by the module even if the Rx is OFF! 2013-05-13 19:47:42 +00:00
bsongis@gmail.com 2d58fa3f55 Cosmetics 2013-05-13 17:10:17 +00:00
bsongis@gmail.com 67120bb5e7 [Taranis] DEFAULT_MODE Makefile option added for FrSky production in Mode 1 / Mode 2 2013-05-13 13:30:05 +00:00
bsongis@gmail.com 97402aa919 [Taranis/sky9x] Wrong prompts played for the units 2013-05-13 10:13:18 +00:00
bsongis@gmail.com e57be1ac6e [Taranis/sky9x] System prompts were not played 2013-05-13 08:05:58 +00:00
bsongis@gmail.com 6ee4c7c269 [Taranis/sky9x] Wrong prompts played for the units 2013-05-13 07:58:38 +00:00
bsongis@gmail.com 70b11d037d [Taranis] VBatt += 0.2v because of the diode 2013-05-12 21:25:22 +00:00
mhotar@gmail.com 9184adb2ab Cz translations -Taranis 2013-05-11 22:11:35 +00:00
bsongis@gmail.com 37aa54f1a1 [all] Bug when TRNs and TRNl are used as trigger in 2 different custom functions 2013-05-11 20:11:30 +00:00
bsongis@gmail.com ab8e72e89c [Taranis] Display problem of the INPUTS screen 2013-05-11 19:41:35 +00:00
bsongis@gmail.com 96371bd27d [Taranis/sky9x] Bug in languages (thanks Martin!) 2013-05-11 17:52:14 +00:00
romolo.manfredini@gmail.com cf2c83ff10 SK PT ES Languages added 2013-05-11 08:36:39 +00:00
bernet.andre@gmail.com e4e211a7a9 [Taranis] Shorter WDT timeout was causing reboots when connecting/disconnecting USB 2013-05-11 08:36:34 +00:00
bsongis@gmail.com 156a05bee3 [Taranis] Cosmetics 2013-05-11 07:45:42 +00:00
bsongis@gmail.com 57703965ae [Taranis/sky9x] CZ language added 2013-05-11 07:45:21 +00:00
bsongis@gmail.com 60f7d97194 [Taranis/sky9x] DE language added 2013-05-11 07:16:01 +00:00
bsongis@gmail.com 8079b7c053 [Taranis] WDT made the Tx shutdown during EEPROM last save on power off when model size > 500 2013-05-11 05:51:21 +00:00
bsongis@gmail.com 3be0515cf2 [Taranis] WDT set to 500ms instead of 1500ms 2013-05-11 05:46:56 +00:00
bsongis@gmail.com 4dfa4d7249 [Taranis/sky9x] SD sounds directory /SOUNDS/en/SYSTEM instead of /SOUNDS/SYSTEM/en 2013-05-11 05:45:13 +00:00
bsongis@gmail.com 47881b80da [Taranis] Core in simu 2013-05-10 21:19:36 +00:00
bsongis@gmail.com 6217e1331a [Taranis] New board revision. Betas are PCBREV=REV4a, production are PCB=REV4
[Taranis] FrSky module alarms removed
[Taranis/sky9x] Multilanguages (only en, fr, it)
[sky9x] Compilation error fixed
2013-05-10 20:24:25 +00:00
bsongis@gmail.com 4b7c16fc9f [Taranis] Cosmetics 2013-05-08 05:25:58 +00:00
michael.blandford@mypostoffice.co.uk 21a85244b0 Fix missing semi-colons 2013-05-07 23:06:27 +00:00
michael.blandford@mypostoffice.co.uk 53cbfd5d8f Add debug read, Add PXX preamble, Add Taranis no_pulses drivers 2013-05-07 23:01:13 +00:00
romolo.manfredini@gmail.com ea1a07dbfa wrong paths to include files 2013-05-07 20:57:14 +00:00
romolo.manfredini@gmail.com 8f3122ab74 wrong paths to include files 2013-05-07 20:47:05 +00:00
bsongis@gmail.com dfb99c80e5 [Taranis] Include error 2013-05-07 19:55:49 +00:00
bsongis@gmail.com 1f97f644e9 Cosmetics 2013-05-07 16:20:20 +00:00
bsongis@gmail.com 20a9369f2f [all] First calibration screen reworked
[all] Default settings for backlight
2013-05-07 13:16:07 +00:00
bsongis@gmail.com 86baf80ac2 [Taranis / sky9x] Bad wrap-around in files selection popups 2013-05-07 09:35:19 +00:00
bsongis@gmail.com 481c18d6ff [Taranis] SMALL font updated for timer switches 2013-05-07 08:46:31 +00:00
bsongis@gmail.com 233342e0e5 [Taranis] Display bugs in the Flight Modes screen 2013-05-07 08:23:56 +00:00
bsongis@gmail.com 81f8bd4570 Wrong directory for fonts used in translations 2013-05-07 07:31:06 +00:00
bsongis@gmail.com c7c907e7ce Files movement.
Issue 26 fixed (JETI)
2013-05-07 05:42:43 +00:00
bsongis@gmail.com 37880ee9ec Issue 25 fixed 2013-05-06 05:28:38 +00:00
bsongis@gmail.com f82680b53c [sky9x] 2nd module EEPROM 2013-05-05 09:34:09 +00:00
bsongis@gmail.com a5ed5599ce Simu didn't compile on all platforms 2013-05-04 17:19:09 +00:00
bernet.andre@gmail.com 914ca9d865 [Taranis] Reboot when changing stick mode and throttle warning active, External PXX wrong, Elevator stick inverted with new gimbals 2013-05-02 13:21:51 +00:00
bsongis@gmail.com eb7488f670 [Taranis] Trainer master / slave toggled 2013-04-30 08:59:09 +00:00
bernet.andre@gmail.com ec2445e0c8 [Taranis] Reboot when changing model if old model had both modules OFF 2013-04-30 06:42:22 +00:00
bernet.andre@gmail.com b9b36220da German translation by Helle 2013-04-29 21:11:47 +00:00
bernet.andre@gmail.com 68c28187a8 [Taranis] Pulses for final hardware 2013-04-29 19:55:38 +00:00
bsongis@gmail.com 240c6223fe Simu compilation 2013-04-24 20:08:21 +00:00
bsongis@gmail.com 0e824f8e8a [all] Sticks calibration launched automatically when needed
[Taranis] Curves again!
[Taranis] Trainer menu
2013-04-24 19:33:56 +00:00
mhotar@gmail.com f565f3c893 CZ translations - "One" in VSWITCHES 2013-04-23 21:02:10 +00:00
bsongis@gmail.com f0259d499d [Taranis] Trainer data structure added 2013-04-23 17:36:28 +00:00
bsongis@gmail.com 22a6669b1e [all] Work on curves 2013-04-23 17:06:55 +00:00
bsongis@gmail.com 71518e8e8c [all] Interpolation (curves) was less precise than before! Automatic google test added to avoid this later... 2013-04-23 17:03:41 +00:00
bsongis@gmail.com 6f4a8ccb74 [sky9x] Possible endless loop in the coproc interrupt 2013-04-23 17:02:07 +00:00
bsongis@gmail.com 1ce2e2c3d4 [Taranis] Some work on the curves system. Still Clear and Mirror to add, and interpolation has a little bug 2013-04-23 05:45:46 +00:00
bsongis@gmail.com 5c06fdba92 [sky9x] WDT is now 500ms instead of 1500ms 2013-04-23 05:20:47 +00:00
bsongis@gmail.com 67a683e6c4 [Taranis] EEPROM write from USB massstorage seems working on windows here! Not tested again on Linux 2013-04-21 17:24:41 +00:00
bsongis@gmail.com 38afc96e2c [Taranis] EEPROM write from USB massstorage seems working now here! 2013-04-21 11:00:29 +00:00
bsongis@gmail.com f915a7c82e [gruvin9x] Logs not working before we go to SD Manager 2013-04-20 09:12:02 +00:00
bsongis@gmail.com 19d4bfe50a [Taranis] List of bitmaps updated when one is changed 2013-04-20 08:25:59 +00:00
romolo.manfredini@gmail.com 1ecea6b4af Logs for taranis 2013-04-20 06:10:22 +00:00
bsongis@gmail.com a23a7204cf [Taranis] Bitmap name moved to the start of the structure
[Taranis] Bitmap displayed in MODELSEL
[Taranis] Empty EEPROM is not calculated on each keypress in MODELSEL screen
[stock/stock128] Huge RAM saving (thanks Mike!)
[sky9x] Good register used for reboot cause
2013-04-19 17:49:53 +00:00
mhotar@gmail.com 2f3f2157fb lcd.cpp -curve name from translations
CZ translations -FM,CS,GV,CV
2013-04-18 22:03:16 +00:00
bsongis@gmail.com 11c1dba91e [Taranis] Curve names
[Taranis] Menu system now allows hidden rows
[Taranis] DEBUG menu removed
[stock2561] First draft!
2013-04-18 20:04:37 +00:00
josemoreno259@gmail.com e7a0c793bb Translation to spanish By Jose Moreno with letter Ñ .Thanks Kilrah 2013-04-17 09:09:35 +00:00
josemoreno259@gmail.com 295f42007d Translated to spanish By Jose Moreno adedd letter "ñ" .Thanks Kilrah for your work. 2013-04-17 09:03:39 +00:00
josemoreno259@gmail.com 71711b1008 Translated to spanish By Jose Moreno adedd letter "ñ" .Thanks Kilrah for your work. 2013-04-17 08:24:03 +00:00
josemoreno259@gmail.com b05f6476f6 Translated to spanish By Jose Moreno 2013-04-16 20:37:24 +00:00
bsongis@gmail.com 335f1dffc3 Compilation errors 2013-04-16 09:14:50 +00:00
bsongis@gmail.com 0576edc6a6 [de language] Remaining PCBX9D ifdef in de translations 2013-04-15 19:46:35 +00:00
bsongis@gmail.com 36d300b248 [all] Problem with |d|>=ofs and Timer2 in custom switches (thanks thomas9x for all the infos) 2013-04-15 19:45:36 +00:00
bsongis@gmail.com ae1be246b6 [all] d>=ofs and Timers were not working with EXT=STD 2013-04-15 13:48:58 +00:00
bsongis@gmail.com 9cb026ec58 [all] Layout problem in Custom Switches menu 2013-04-15 12:38:45 +00:00
bernet.andre@gmail.com fd39a178bb [M128] Variant missing in stamp 2013-04-15 10:37:23 +00:00
bsongis@gmail.com a7655c30ff [all] Min/Max values on T1/T2/ALT/RPM badly displayed 2013-04-15 09:15:48 +00:00
romolo.manfredini@gmail.com 471511c24c fix sky9x compilation 2013-04-14 21:57:28 +00:00
michael.blandford@mypostoffice.co.uk 37cc13c140 Fix SKY compile errors 2013-04-14 21:24:39 +00:00
michael.blandford@mypostoffice.co.uk 5118eccf4d Add stop_trainer_capture() 2013-04-14 19:07:39 +00:00
michael.blandford@mypostoffice.co.uk aa9ae51e21 Taranis - PXX/PPM for two modules, trainer input/output changes 2013-04-14 14:44:29 +00:00
bsongis@gmail.com 452ac21f89 [Sky9x] BUZZER support in addition to AUDIO 2013-04-13 20:42:31 +00:00
bsongis@gmail.com 1ec8c74911 [Taranis] Backlight working on simu 2013-04-13 11:42:49 +00:00
bsongis@gmail.com ebbfb7336e [Taranis] Warning fixed, backlight working on simu 2013-04-13 11:19:58 +00:00
bernet.andre@gmail.com 464755e302 [Taranis] PA10 no more configured by USB driver, trainer jack doesn't keep power on anymore 2013-04-13 10:51:30 +00:00
bernet.andre@gmail.com 064c8d8a5c [taranis] trainer detection and main view icons 2013-04-13 08:52:05 +00:00
bsongis@gmail.com f14a874bf5 [Taranis] PXX pulses reworked 2013-04-12 21:03:19 +00:00
bsongis@gmail.com de34cb7ef2 [Taranis] Cosmetics 2013-04-12 20:43:22 +00:00
bsongis@gmail.com 72a3098f26 [Taranis] Channels range masked when internal module OFF 2013-04-12 20:26:57 +00:00
bsongis@gmail.com 358a57945f [Taranis] External module and Trainer support (menus only) 2013-04-12 18:57:52 +00:00
kjell.kernen@gmail.com e9abf59ee4 Mirrored Bertrand's name change of flight phase to flight mode in Swedish (Mode = Mod). 2013-04-12 13:57:42 +00:00
bernet.andre@gmail.com 5ff4335b50 [Taranis] Trainer detect working (thanks Mike!)
Trim reset via long press with audio confirmation
Backlight flash shorter
2013-04-11 09:46:10 +00:00
bsongis@gmail.com 4d797f5e83 Simu code cleaning 2013-04-11 06:02:37 +00:00
bsongis@gmail.com 2a8fe6d110 [all] Inverted flash on beep when backlight is ON
[Taranis] Menu in MODELSEL
[all] Menus wrap around + keys repeat
[Gruvin9x] Issue 16 fixed
2013-04-10 16:02:22 +00:00
bsongis@gmail.com ea7acfa5a6 Bug in german TTS files 2013-04-10 05:31:59 +00:00
bsongis@gmail.com 2de5a8dcb6 [all] BEEPER renamed to BUZZER, PHASES renamed to MODES
[Taranis] PPM Center Adjustable
[stock] Issue 225 fixed
[all] Throttle Inverted is now a Model parameter
[Taranis] Issue 15 fixed (when >5 GVARS)
[Gruvin9x] Issue 16 almost fixed
2013-04-09 20:17:50 +00:00
bsongis@gmail.com e064edc69b [stock128] A compromise for RAM! 2013-04-08 20:52:00 +00:00
bsongis@gmail.com 4d03134e9e [stock128] Less RAM used!!! 2013-04-08 19:12:38 +00:00
bsongis@gmail.com 541c5aa000 [stock128] Less RAM used!!! 2013-04-08 17:34:33 +00:00
mhotar@gmail.com ad82ce9c1b tts files synced to EN version 2013-04-08 10:03:40 +00:00
bsongis@gmail.com 7c4bb27ebd Remaining traces removed 2013-04-07 21:01:16 +00:00
bernet.andre@gmail.com e484668033 [taranis] inverted pot 2013-04-07 19:40:13 +00:00
bsongis@gmail.com 5f9a24cddd [gruvin9x] Issue 12 fixed 2013-04-07 19:31:38 +00:00
bsongis@gmail.com 5154ba238a Cosmetics 2013-04-07 19:28:38 +00:00
romolo.manfredini@gmail.com c4a8e121d3 taranis eeprom write 2013-04-07 09:29:21 +00:00
romolo.manfredini@gmail.com 6c068076e4 Buzzer fix 2013-04-06 20:57:46 +00:00
romolo.manfredini@gmail.com 8b5165c271 Beeper fix 2013-04-06 20:43:28 +00:00
bsongis@gmail.com 61f430cb43 [stock] Beeper was broken (BUZZER ifdef instead of BEEPER) 2013-04-06 20:42:24 +00:00
bernet.andre@gmail.com 144f47b6cf "Flight Phase" was bad English
Taranis simu now uses up/down keys
2013-04-06 20:32:56 +00:00
bsongis@gmail.com a493e022a7 [stock] Beeper was broken (BUZZER ifdef instead of BEEPER) 2013-04-06 20:29:09 +00:00
bsongis@gmail.com 517c5521be [stock, gruvin9x] TTS script wrong numbers for errors / alarms 2013-04-05 19:39:23 +00:00
bsongis@gmail.com aedb5211ab [all] Cosmetics in HELI menu (en) 2013-04-05 16:47:03 +00:00
bernet.andre@gmail.com 8833a3e451 A couple of string changes 2013-04-05 10:42:28 +00:00
bsongis@gmail.com 79c0754af9 Issue 13 fixed (HELI menu) 2013-04-05 09:23:58 +00:00
bsongis@gmail.com 49cb4f97d6 TTS script bug fixes 2013-04-05 08:26:23 +00:00
romolo.manfredini@gmail.com a5bf114f2b Fix string in SE translation 2013-04-05 06:28:09 +00:00
bsongis@gmail.com 022caee996 [Taranis] Timer display fixed 2013-04-05 05:44:08 +00:00
bsongis@gmail.com ca4d00ca4b Translations updated 2013-04-04 21:08:27 +00:00
bsongis@gmail.com a1a18aae57 [Taranis] Default Batt range / alarm
[Taranis] No USR Protocol selection
2013-04-04 20:50:19 +00:00
bsongis@gmail.com bc078d5e3f [sky9x / Taranis] Imperial is now an option selectable in the FW
Strings moved to translations.h/.cpp files. Need to be moved to the translations files
2013-04-04 17:54:55 +00:00
kjell.kernen@gmail.com 8bab0aee9a There are some string length related issues in the Swedish translation. Fixed a lot of string length to closer resemble the English version. Lets see if I fix any of the problems. 2013-04-04 13:24:11 +00:00
mhotar@gmail.com 900bc139b5 EN changes ported to other languages 2013-04-04 10:12:59 +00:00
bsongis@gmail.com 48c913a96a [all] Bug in AUTOSOURCE feature 2013-04-04 06:29:12 +00:00
bsongis@gmail.com 9092f52999 [stock] Mavlink compiles again. Flash saving. This file has a lot of potential flash / ram savings! 2013-04-04 05:39:54 +00:00
bsongis@gmail.com 68f6d68138 [gruvin9x, sky9x] Issue 64 fixed. It's now possible to have AUDIO=YES and BEEPER=YES
[all] Issue 32 fixed (AUTOSOURCE option added)
[all] Issue 226 fixed (Menu in main views / telemetry views)
[all] Issue 226 fixed (Imperial bug with playValue)
[sky9x] Issue 234 fixed (rotary encoder inverted)
[sky9x / Taranis] Bug with AUDIO stopped when selecting Background Music without a file
[all except M64] Shift in Telemetry sources when !GVARS
2013-04-03 21:25:10 +00:00
bsongis@gmail.com e2df5ef0ed [all] New german translations
[all except '64] Trainer short and Trainer long in Custom Functions
[Taranis] No Haptic function
[Taranis] Overflow problem in playValue
[Taranis] EEPROM flushed and loaded again before / after USB connection
2013-04-02 17:23:39 +00:00
mhotar@gmail.com 3001a754c1 CS function strings updated in all languages 2013-04-02 11:32:38 +00:00
bernet.andre@gmail.com 56c4db624a [ARM] Vario sounds improved? 2013-04-01 21:22:18 +00:00
bsongis@gmail.com 5126de7ed8 [Taranis] EEPROM disconnected when Massstorage is active 2013-04-01 20:49:48 +00:00
bernet.andre@gmail.com 1a7bb8e966 [Taranis] Overlap
French translations
2013-04-01 19:19:09 +00:00
bsongis@gmail.com 9701ac54e8 [stock] Wrong parameter displayed for Reset function when !FrSky 2013-04-01 17:51:56 +00:00
bernet.andre@gmail.com 311c05b256 SD card folders renamed ("9x" removed) - PLEASE UPDATE YOUR CARDS! 2013-04-01 12:30:26 +00:00
bernet.andre@gmail.com 1ddfb6b81e [Taranis] Navigation consistency 2013-04-01 11:03:28 +00:00
bsongis@gmail.com 91abaa4f61 [all] German translations (thanks Hellmut!) 2013-04-01 11:01:25 +00:00
bsongis@gmail.com e3327ce2c1 [all] German translations (thanks Helle!) 2013-04-01 08:25:04 +00:00
bsongis@gmail.com 4b4c9728be [Taranis] All 'old' sensors now supported 2013-03-31 19:34:32 +00:00
bsongis@gmail.com 3a93ae3558 [all] TTS script for prompts new numbers 2013-03-30 16:41:15 +00:00
bernet.andre@gmail.com dc2c4efde5 [taranis] SD card detection, 2nd PPM initialised as input (temporary), external module powered up (temporary) 2013-03-30 16:17:56 +00:00
michael.blandford@mypostoffice.co.uk d2aaac6819 Taranis EEPROM disk add volume name, file is system 2013-03-29 21:24:10 +00:00
bsongis@gmail.com 7d5543f5a7 [9x stock] Issue 7 fixed.
[9x stock / gruvin9x] All prompts renumbered!
2013-03-29 21:15:14 +00:00
bsongis@gmail.com 0a49777e6d [stock] Last changes on vario reverted 2013-03-29 20:47:18 +00:00
bsongis@gmail.com 8f0a996c0a [all] Display bugs on the Voltages Telemetry Screen 2013-03-29 09:10:30 +00:00
bsongis@gmail.com 0b665f145a [stock] New commit for jhsa tests on the vario 2013-03-29 07:40:39 +00:00
bsongis@gmail.com c1a8026406 [stock] New commit for jhsa tests on the vario 2013-03-28 21:47:01 +00:00
bsongis@gmail.com 07dc3459a2 [stock] New commit for jhsa tests on the vario 2013-03-28 21:42:13 +00:00
bsongis@gmail.com 8132f530d9 [stock] Only 16bits needed for calculating free EEPROM
[stock] Vario makes the system reboot. To be tested!
[all] Mixer contextual menu adjustments
2013-03-28 20:33:51 +00:00
bsongis@gmail.com 6686c75206 [Taranis] Cosmetics 2013-03-28 14:19:47 +00:00
bernet.andre@gmail.com 692f8b1ef4 [Taranis] Overflow on free EEPROM size with 64k 2013-03-28 14:08:55 +00:00
romolo.manfredini@gmail.com 237fa71133 64K eeprom support and eeprom contents on second lun 2013-03-28 13:42:40 +00:00
bernet.andre@gmail.com c7491a8dee [Taranis] Mixer editor displayed wrong for some languages 2013-03-28 12:08:40 +00:00
bernet.andre@gmail.com 4d7f2c8579 Heli template was broken 2013-03-28 11:42:15 +00:00
bsongis@gmail.com b4e2086506 [Taranis] Bug on voltage gauge when voltage < mininimum of the gauge 2013-03-28 09:18:58 +00:00
bsongis@gmail.com c0a509e3fa [all] Issue 4 fixed (Mixer menu)
[sky9x / Taranis] Issue 1 fixed (PlayFile/Play were called from an interrupt). To be tested and re-tested
[all] FrSky alarms are not any more sent from the 10ms interrupt, but from the main loop. To be tested as well
2013-03-28 06:49:39 +00:00
kjell.kernen@gmail.com 8b7ed2bdec Changed file to yet again become row aligned to the en.h file.
This is important to be able to check for missing translation strings.
2013-03-27 10:20:46 +00:00
kjell.kernen@gmail.com bf43703666 Translated all new strings. 2013-03-27 10:01:39 +00:00
kjell.kernen@gmail.com 5845bb8d4a Made test change of country names, fixed some indentation issues 2013-03-27 09:52:53 +00:00
bsongis@gmail.com 874281a081 [Taranis] SHdn bug! 2013-03-26 22:12:52 +00:00
bsongis@gmail.com d3c967c6cd [Taranis] Send failsafe straight away when model changed 2013-03-26 21:36:18 +00:00
bernet.andre@gmail.com e9531e3990 [Taranis] Send failsafe straight away when changed 2013-03-26 21:14:25 +00:00
bsongis@gmail.com 34b56368dd [simu] Traces allowed in SIMU mode
[stock] Flash saving (around 50bytes)
[gruvin9x / sky9x / taranis] No "Restore Model" on non empty slots
[taranis] Failsafe sent in PXX protocol
2013-03-26 19:39:52 +00:00
bsongis@gmail.com 2df2c5a011 [Taranis] Problem wrap around inside Model Setup 2013-03-26 06:39:49 +00:00
bsongis@gmail.com 17cdf85d15 [Taranis] Stupid bug with massstorage (sectors count) 2013-03-25 21:22:57 +00:00
bsongis@gmail.com aef84e0063 [stock] Compilation error with EXT=JETI
[all] Font changes for the Custom Switches screen
[Taranis] Channel name in Mixes screen
[sky9x/Taranis] Negative AND switches in Custom Switches screen
[Taranis] Altitude displayed with PREC1
[Taranis] Correct SD size in massstorage
[Taranis] Unmount / Mount SD in massstorage
[Taranis] A1 / A2 displayed in Top Bar depending on Voltage source selected in Telemetry menu
[Taranis] No RSSI / Voltage in Top Bar if no RSSI
2013-03-25 19:36:55 +00:00
bernet.andre@gmail.com 9358ed084e [Taranis] Trainer driver fixed, thanks Mike! 2013-03-24 17:43:10 +00:00
romolo.manfredini@gmail.com 4a1f897ad5 Small fixes in model menu 2013-03-24 16:41:29 +00:00
bernet.andre@gmail.com 39b1492f19 [Taranis] RSSI displayed during range check 2013-03-23 23:01:21 +00:00
bernet.andre@gmail.com 93ccb3da05 [Taranis] Let's get crazy with DBLKEYS. Pretty useable I think! 2013-03-23 21:48:59 +00:00
bernet.andre@gmail.com 564c1469a3 [Taranis] Wrong key for Trims2Offsets 2013-03-23 21:01:52 +00:00
bernet.andre@gmail.com 1c1ca9b890 [Taranis] DBLKEYS! That's gonna make things easier! 2013-03-23 20:54:16 +00:00
bernet.andre@gmail.com deb5954055 [Taranis] Flight phase selection in line by line nav - SHOULD not have broken other boards, I just can't test rotenc... 2013-03-23 19:15:07 +00:00
bernet.andre@gmail.com 3b16e017d4 [Taranis] New name in USB device string 2013-03-23 15:04:15 +00:00
bernet.andre@gmail.com e102a9d57d [Taranis] Failsafe setting now blinks 2013-03-23 14:42:55 +00:00
bsongis@gmail.com fc363d408e [stock] Compilation error with JETI extension! 2013-03-23 13:38:31 +00:00
bernet.andre@gmail.com b46278b791 [Taranis] Failsafe settings page
Fix for decimal point when TINSIZE | INVERS
2013-03-23 11:58:09 +00:00
bsongis@gmail.com 4858993cd8 [sky9x, taranis] Compilation problem 2013-03-23 08:02:29 +00:00
bsongis@gmail.com c5fbd3dd73 [sky9x, taranis] Compilation problem 2013-03-23 07:43:09 +00:00
bsongis@gmail.com 7513dfaf1d [sky9x, taranis] Compilation problem 2013-03-23 07:37:49 +00:00
rob@marotori.com a2076c8717 Typo fixed for flight mode - normal 2013-03-22 22:03:50 +00:00
bsongis@gmail.com aa92d59ada [Sky9x] Bug in Custom Switches
[Stock] 450bytes flash saved (files order changed in allsrc.cpp)
2013-03-22 18:05:10 +00:00
rob@marotori.com 3d3c3833dd Minor updates to the soound file options for UK. 2013-03-22 16:37:44 +00:00
bsongis@gmail.com 1e2edee88c [Taranis] Rx voltage displayed in the top bar 2013-03-22 11:33:00 +00:00
bsongis@gmail.com b9b4214d8f Include error in companion 2013-03-22 11:27:07 +00:00
bsongis@gmail.com 86b5e0de04 [gruvin9x / M128] The flight phase 5 was not useable in Expos / Mixes. New EEPROM conversion for these targets, sorry! 2013-03-22 07:11:39 +00:00
bernet.andre@gmail.com aca37b43f3 [taranis] Wrong key to edit FP list
Channel monitor only on taranis
2013-03-21 22:36:18 +00:00
bsongis@gmail.com 6d653cf2db [taranis] Telemetry 2013-03-21 21:11:01 +00:00
bernet.andre@gmail.com 80b85fcc87 [TARANIS] Channel monitor on mixer screen is now a long press on the unused MENU key. We had lost it since LONG PAGE was assigned to previous page. 2013-03-21 20:03:23 +00:00
bsongis@gmail.com 63461069b8 Refactoring again... 2013-03-21 15:12:26 +00:00
bernet.andre@gmail.com 38ea2afa9c [TARANIS] Channel monitor 2nd page 2013-03-21 14:55:56 +00:00
bsongis@gmail.com 2ab712f40b A new "search/replace" commit ... 2013-03-21 14:21:04 +00:00
bernet.andre@gmail.com 21c518e5f3 [taranis] Remove "Overheat" general setting 2013-03-21 11:49:06 +00:00
bsongis@gmail.com c41185f690 [X9D] Renamed to Taranis
[9x] New logo!
2013-03-21 11:22:46 +00:00
bsongis@gmail.com cf54528a9e open9x replaced by opentx 2013-03-21 10:48:14 +00:00
bsongis c6d6c7f66d [X9D] Sport driver fixed (thanks to Adela, 12 minutes without WDT reboot ...) 2013-03-21 07:35:11 +00:00
bernet.andre@gmail.com 781b3c6188 [X9D] SD card write error fixed, DMA enabled (thanks Adela), SPORT debug code 2013-03-20 22:39:21 +00:00
mhotar@gmail.com 8760bae8a6 Cz translations bugfixes 2013-03-20 18:11:43 +00:00
bsongis cffdacbe94 [all] Compilation error when VOICE=YES and GVARS=NO 2013-03-20 13:31:27 +00:00
bernet.andre@gmail.com 8f7959a201 More translatable strings, failsafe mode still TODO 2013-03-19 23:57:14 +00:00
bernet.andre@gmail.com 1284ed2051 Translation files updated 2013-03-19 23:15:00 +00:00
bsongis 1e7f517aa5 [stock] PXX was not compiling 2013-03-19 22:10:12 +00:00
bsongis 0dc7060c92 [X9D] Bind and RangeCheck navigation changed 2013-03-19 21:34:56 +00:00
bernet.andre@gmail.com 6d2a731acc [X9D] GVARS screen navigation 2013-03-19 20:44:57 +00:00
bsongis 7973386f9a [X9D] Navigation reviewed again! 2013-03-19 20:28:33 +00:00
bernet.andre@gmail.com 63f2fcd507 [PXX] Range check bit was wrong 2013-03-19 12:03:35 +00:00
bsongis 3326b69169 [ARM] Better frequency precision for AUDIO. Is needed for the Vario feature. 2013-03-19 11:10:29 +00:00
mhotar@gmail.com 0cdfa9b6e5 CZ translations update 2013-03-19 10:58:41 +00:00
bernet.andre@gmail.com 873847e42e PXX scaling was done wrong 2013-03-19 10:53:31 +00:00
bernet.andre@gmail.com 998f904c41 [X9D] PXX Pulses scaling, cleanup 2013-03-19 09:56:44 +00:00
bernet.andre@gmail.com 403f14c0ea [X9D] PXX working, thanks Robert! 2013-03-19 09:02:04 +00:00
bernet.andre@gmail.com 7f15566d5c [X9D] We now have PXX pulses, but they still don't seem to be recognised by the module... 2013-03-19 00:02:35 +00:00
bernet.andre@gmail.com 3eea221b24 No rotarySteps on stock 2013-03-18 23:11:47 +00:00
bsongis a8dd74bd89 [X9D] BIND mode is not automatically disabled 2013-03-18 22:31:38 +00:00
bsongis dfdca2dcfc [X9D] The internal module must be powered! 2013-03-18 21:09:18 +00:00
bernet.andre@gmail.com 566291bc17 German translation 2013-03-18 20:41:58 +00:00
bsongis 0ddf92ce0e [X9D] PXX work. UI and pulses 2013-03-18 20:38:30 +00:00
bernet.andre@gmail.com 12f866cfb6 Copy/paste = evil 2013-03-18 17:48:07 +00:00
bernet.andre@gmail.com 431a9ecc0e [X9D] Module power control 2013-03-18 17:43:17 +00:00
bsongis 39bc1700be [stock] Vario min frequency 2013-03-18 07:18:49 +00:00
bsongis 6e6b0c4b5f [MEGA2560] First files from Franck 2013-03-17 16:03:45 +00:00
bsongis 4fb205def7 [all] Switches Warning bug fixed 2013-03-17 13:26:32 +00:00
bsongis 989593f5f6 [all] Switches Warning bug fixed 2013-03-16 22:22:54 +00:00
bsongis b0ae67e2e5 Issue232 fixed (Steps for sky9x rotary encoder) 2013-03-16 20:50:31 +00:00
f.aguerre@wanadoo.fr 2a41cec5ae Makefile correction 2013-03-16 19:58:01 +00:00
f.aguerre@wanadoo.fr c00620b891 New MEGA2560 board
(DIY transmitter based on Arduino MEGA2560)
2013-03-16 19:55:20 +00:00
bernet.andre@gmail.com 0026262520 [X9D] Strings for protocol settings 2013-03-16 08:14:00 +00:00
bsongis 49f0da06fa [X9D] Grey bar rounded on main view
[X9D] Column headers
2013-03-15 18:02:53 +00:00
bsongis d1d3d7ff95 [X9D] Grey line on all menus. To be tested on real HW! 2013-03-14 21:46:34 +00:00
bernet.andre@gmail.com 8fa5bc405f [X9D] Alignment details 2013-03-14 21:33:00 +00:00
bsongis f44607aff0 [X9D] Navigation reworked 2013-03-14 20:43:27 +00:00
bernet.andre@gmail.com d92a379249 [X9D] Missing define 2013-03-14 08:00:34 +00:00
bsongis d558e33647 [X9D] Previous revisions re-enabled. The CoOs was not started, which is a little bit a problem! 2013-03-14 06:50:53 +00:00
bernet.andre@gmail.com d360c0e820 Reverted r2089, 2088, 2085, 2084, 2081, X9D was broken. 2013-03-13 23:36:08 +00:00
bsongis 617b256bb8 [X9D] Regression, the Mixer was always alive at full speed! 2013-03-13 23:08:51 +00:00
bsongis 3291f21309 [X9D] Compilation error (includes) 2013-03-13 21:57:27 +00:00
bernet.andre@gmail.com 95aa8f2ec8 [X9D] New channel monitor idea, making use of the new channel names - Needs 2nd page added and decimal point fix 2013-03-13 20:38:30 +00:00
bsongis fa268017c8 C9X compil 2013-03-13 18:26:00 +00:00
bsongis 4dd2daedcd [all] Many little fixes
[X9D] RxNum for PXX
2013-03-13 18:12:24 +00:00
bernet.andre@gmail.com 283b75dfd7 [X9D] Trainer detect was inverted. Note, doesn't work yet as the PPM is still being output on that pin. 2013-03-13 14:46:40 +00:00
bernet.andre@gmail.com cee86dd968 [X9D] Battery voltage scale on calib page, double reboot sign 2013-03-13 13:54:10 +00:00
bsongis 36e6751f73 [stock] 48bytes flash saved, 32bytes RAM saved 2013-03-13 10:26:56 +00:00
bernet.andre@gmail.com caaf6db7ad [X9D] Lighter grey on main views, USB icon working, power driver 2013-03-13 08:48:22 +00:00
bsongis d92f6d4978 [X9D] Massstorage is working, WOW! 2013-03-12 22:00:16 +00:00
open.20.fsguruh@xoxy.net f9b9a5497c Battery Range translations added; All languages needs translations
except: English ;-)  and German
As requested by Helle, the translation for the battery range for the BATTGRAPH was missing.
Now the language.h in translations needs adaption.
2013-03-12 17:15:15 +00:00
mhotar@gmail.com ded307c494 cz.h wrong string lengths 2013-03-12 16:25:24 +00:00
bsongis 1d5e1881eb Cosmetics 2013-03-12 13:41:35 +00:00
bsongis 49762250d6 [X9D] Pulses on REV4 board. By Mike again! Robert@FrSky code kept @ifdef-ed under the pillow ;) 2013-03-12 13:27:02 +00:00
bsongis 392a10c98d [all] Problem with momentary switches when used in timers. Thanks Gabriel for reporting this bug! 2013-03-11 22:21:44 +00:00
bsongis ea148dfcda [X9D] REV3 voltage regression (I already forgot the REV3!!!). Thanks Mike! 2013-03-11 20:34:58 +00:00
bsongis 28bd8e4f07 [X9D] Voltage measurement fixed, thanks Mike! 2013-03-11 20:07:54 +00:00
bsongis 2abaa19c01 [X9D] Notification bar 2013-03-11 18:49:07 +00:00
bsongis e9cb986bdf We don't change the EEPROM version 2 times between 2 releases! 2013-03-11 17:56:35 +00:00
open.20.fsguruh@xoxy.net 770376e4ad again flash savings 36bytes
hopefully this do not break anything, but I noticed mix is actually set to 0 therefore only negative weight values needs the helper function. That's good.
Additionally I noticed a weight of 100 do not need to be set because it's done in setDest anyway. Reduced flash cost about 36bytes.
2013-03-11 17:56:00 +00:00
open.20.fsguruh@xoxy.net 1cd24d218b small flash savings if templates are active.
Prevent a little bit code increase necessary because of new offset, weight handling.
Saved me 12 bytes flash.
However not sure if md_SetWeight(md, XXXX) is not necessary for all weight settings from template. Currently only for negative values done.
Will try how much code cost this is. Can we rely the memory is 0 for all mix elements?
2013-03-11 17:39:39 +00:00
bsongis 0994312782 [X9D] REV3 pots assignation (regression) 2013-03-11 16:36:26 +00:00
gbirkus@gmail.com 1f44987aff Templates fixup for r2057 2013-03-11 14:26:05 +00:00
bsongis 92106aedd8 [all] I increased flash in previous commit. It should be ok now. 2013-03-11 14:05:49 +00:00
bsongis 3a662afe73 Compilation error fixed 2013-03-11 13:54:18 +00:00
bsongis 5bdd8f8994 [X9D] Top bar 2013-03-11 13:47:16 +00:00
bsongis d6543f6c55 [all] New helper for filling MixData::weight in templates 2013-03-11 13:46:40 +00:00
bsongis a81d77b364 [X9D] Patch from Robert@FrSky amended with #ifdef, thanks Robert! 2013-03-11 09:24:53 +00:00
bsongis 2d1f3e3441 [all] Warning removed. Saves flash on stock. 2013-03-10 21:57:21 +00:00
bsongis 21de55e550 [X9D] REV3 switches assignation (regression) 2013-03-10 21:08:37 +00:00
open.20.fsguruh@xoxy.net e419708561 [MERGED] bring in advantages from branch to trunk; Performance optimizations
This combines now the changes from branch PerformanceOptimizations to trunk
Mainly this change should do following:
- Flash savings should be around 224 bytes for stock
- Added option ARITHMETIC_OVERFLOW_CHECK to prevent overflows.
  Still not bulletproof, but codecost is about 50 bytes
- Increases mix speed about 25 - 30% depending on task for stock
  Also increased for other boards, but they may not notice...
- Increased ranges for weight and offset from +-125% to +-245%
- Easier now to increase number of GVARS if needed; Just increase GVAR_MAX in myeeprom.h.
  But!!!! EEPROM layout changes and may not be compatible. Do this for own proposes.
  Till now we do not know how we handle this in future.
- Corrected Timer for stock if used together with AUDIO or VOICE option
- See comments below, what I potentially forgotten...

Be aware this version is currently not compatible to companion9x. But the version before wasn't either. Work is current in progress to tie this up.
2013-03-10 19:51:19 +00:00
bsongis ff609188cb [X9D] REV3 switches assignation (regression) 2013-03-10 19:12:19 +00:00
bsongis 958dee594f [X9D] REV3 switches assignation (regression) 2013-03-10 18:05:36 +00:00
bsongis d8467af191 [X9D] REV3 switches assignation (regression) 2013-03-10 17:54:42 +00:00
bsongis 6e553663ee [X9D] REV3 switches assignation (regression) 2013-03-10 17:22:12 +00:00
bsongis c41ac65fd2 Issue 230 fixed (Python 3.0) 2013-03-10 16:51:54 +00:00
bsongis de1cac6e5d [X9D] REV4 switches assignation 2013-03-10 16:46:02 +00:00
bsongis 5d507af66d [X9D] Cosmetics (tested ok with this version) 2013-03-10 11:17:25 +00:00
bernet.andre@gmail.com 10dce7dee4 [X9D] Temporary i2c driver for v0.4 board 2013-03-10 10:49:36 +00:00
open.20.fsguruh@xoxy.net 67689c8f71 [BRANCH] preperation for merge to trunk; GVARS 5; introduced RANGE constant
I would like Bertrand to check this version. It's currently my proposal for the merge. It holds following changes:

- Introduced constant RESERVE_RANGE_FOR_GVARS to make number of MAX_GVARS independent.
- NEGATIVE_SHIFT_CORRECTION is now set by makefile by default instead inside the code
  The would at least give the option to save code and have less precise calculation.
- ex_chans is included like in trunk. No change here, because it would break output as input.

Actually this version would reduce the effort to merge:

- We stay with the GVARS defines we had till now
- We reserve for ranges space for 10 GVARS, which do not hurt, because  we doubled ranges anyway.
- We stay with 5 GVARS in the moment. According my poll not many people currently use GVARS.
  Therefore there is plenty of time finding here a better solution. I expect the number of 
  people will increase soon, but up to this moment 5 GVARS are more than enough.
- The layout of EEPROM for the values is already the new format. That means when we allow more GVARS in future, at least the parameters like weight, offset, etc. needs no additional conversion.

What do you think. Should we go this way?
2013-03-09 17:19:56 +00:00
bsongis 52c283602d [X9D] Icons for the top bar 2013-03-09 16:50:22 +00:00
bsongis 1ad5aa4785 [X9D] REV3 / REV4 support 2013-03-09 16:43:24 +00:00
open.20.fsguruh@xoxy.net 7b5cca58c0 removed code and memory optimization, because it breaks output as input
This version reverts r2029.
It also activates CORRECT_NEGATIVE_SHIFTS by default and activates ARITHMETIC_OVERFLOW halfway.
Unfortunately this removes a lot of flash optimization but is necessary to work properly.
Maybe we find later a better solution.
2013-03-08 18:10:16 +00:00
bsongis 53315d0132 [all] SafetyCH and General Menu fixes
[stock] Flash saving again
2013-03-07 18:26:19 +00:00
bernet.andre@gmail.com 204014c8c2 [X9D] We can avoid CONDENSED for values >1000 on X9D 2013-03-06 18:56:22 +00:00
bernet.andre@gmail.com fac0e5df5e [X9D] Autoswitch fixed 2013-03-05 15:42:10 +00:00
bernet.andre@gmail.com 41431161b3 [X9D] Overlapping label, labels in header (TBD...) 2013-03-05 14:04:39 +00:00
bernet.andre@gmail.com 4b09e1ed23 Reused previous flash saving to improve custom telemetry screens, Timers and footer line items now have labels on all boards 2013-03-05 13:49:53 +00:00
bernet.andre@gmail.com ea6820a046 Wrong array size... was too late last night I guess :\
Of interest: That different way of displaying the custom screen items I introduced in r2033 for conveniency happens to save a whopping 92 bytes on stock!! I forgot about stock when doing it, and when I remembered I expected it would be the opposite and I'd get a slap...
Might be worth looking if this could be replicated in other places!
2013-03-05 11:12:59 +00:00
bernet.andre@gmail.com bb83933c8c Had broken PLAY_TRACK custom function display on sky9x 2013-03-05 10:37:28 +00:00
bernet.andre@gmail.com a19cf2d7ef [X9D] Telemetry views 2013-03-05 09:50:14 +00:00
bernet.andre@gmail.com c66fab2e6d [X9D] 10 characters for audio files, 3-column on custom telemetry screens 2013-03-05 00:06:22 +00:00
open.20.fsguruh@xoxy.net 9f2b486152 [BRANCH] Created possibility to increase GVARS number; is set to 9
Warning!!!
==========
Be aware this version is in branch and is not supported currently by Companion9x. Whatever you configure will be lost in final version!

Because EEPROM interpretation changes anyway because of higher offset and weight values possible in this branch, I tried to align the bits a little bit different to allow a higher number of GVARS. The code change is nearly flash neutral. It costs only 18 bytes flash, but would us allow to either increase range for weight and offset further, or allow more GVARS.
I set it to 9 for this branch now. Please try and report.
It's very easy now to adjust the GVARS number by changing the constant in myeeprom.h. Just change the MAX_GVARS constant for your build in myeeprom.h in the beginning of the file.
The lower MAX_GVARS the higher is the possible number for weight and offset and vice versa.
That is quite likely too complicated for conversion so we need to agree maximum for GVARS.
Not sure in the moment, but this is a branch only and is just to play with it.
Not sure how Bertrand would like this anyway, so may be removed at all.
2013-03-03 13:57:30 +00:00
open.20.fsguruh@xoxy.net 214bc9c4d4 Small flash and data saving
I need Bertrand for this change, but also testers.
I removed ex_chans[] array, because I am the opinion it can be easily replaced by chans[].
According history ex_chans was there first, after that chans[] are introduced. Now we can use chans instead of ex_chans and get rid of this part to have savings. I am incorrect?
My tests are all OK. The only area I can imagive this change is influenced are flight phases changes. And only if output channels are used as input. But I think this way is even better. Please test and report.
2013-03-02 08:35:55 +00:00
open.20.fsguruh@xoxy.net 82783013fd arithmetic overflow check improved:
- Now it should be more unlikely to prevent arithmetic overflows. Please test.
- This change costs about 20 bytes flash
- Unfortunately still not bullet proof. A bullet proof check would cost additionally 100bytes flash, is it worth?
- To get in dangerous areas, both weight and offset needs to be set very high. Without offset no more overruns should occur.
2013-02-28 05:37:16 +00:00
open.20.fsguruh@xoxy.net 792412f5fe bugfix speed calculation for stock; flash saving 32bytes
A speed calculation didn't work on stock, should be fixed now. Be aware SPEED is now calculated on the input side. Just to remember was already in earlier version as well.
Found a way to reduce overflow protection and gives 32bytes back. Please test
2013-02-27 05:34:24 +00:00
open.20.fsguruh@xoxy.net 6fbbac60dc prevent arithmetic overflows
This version should finally prevent nearly all arithmetic overflows.
Unfortunately this costs over 100bytes flash.
Please test and state your option.
2013-02-26 22:36:28 +00:00
bernet.andre@gmail.com 8bb4681578 [X9D] Finer volume steps on the low end for use with headphones 2013-02-26 17:45:50 +00:00
bsongis 62d80d8145 [all] Small bugs again 2013-02-26 17:18:18 +00:00
bsongis b74f8ee61d [X9D] Cosmetics 2013-02-26 17:02:56 +00:00
bsongis 48a7090e6e [all] Timers countdown / minute beep are configurable
[stock] Port from a part of Andreas patch relative to timers. Thanks Andreas! It allowed me to implement the configurable beeps for timers at a almost 0 flash cost.
2013-02-26 16:07:41 +00:00
bsongis 6fc8ba804c [all] Timers countdown / minute beep are configurable
[stock] Port from a part of Andreas patch relative to timers. Thanks Andreas! It allowed me to implement the configurable beeps for timers at a almost 0 flash cost.
2013-02-26 16:07:41 +00:00
bernet.andre@gmail.com fbd1488b62 GVARs display/adjust was truncated to 8 bits 2013-02-26 15:29:54 +00:00
bsongis 42b41e8f03 [X9D] GVARS screen 2013-02-26 13:32:58 +00:00
bernet.andre@gmail.com 98aa332fb3 [all] Overflow when PPM frame length was at maximum with a 4-CH output 2013-02-26 12:18:13 +00:00
open.20.fsguruh@xoxy.net 5c8d5dbd95 Now extended range for weight, offset also without GVARS, GVARS fix, overruns fix
This version holds mainly bugfixes and prepares this branch for merge.
Please test and report.

- gvars didn't work for value ranges usually from -100 to 100 (e.g. diff function)
- gvars shown wrong also in models menu (same in trunk as well)
- gbirkus tested ranges with speed optimizations, overruns occured at half range of trunk version. Now this is fixed and a much bigger range can be used. Still overruns possible. Please test.
- ISR 10msec now safe and code optimized.
2013-02-25 22:08:23 +00:00
bsongis 78c713d7a5 [all] AdjustGVARs bugs fixed 2013-02-25 22:00:11 +00:00
bernet.andre@gmail.com 18385ceebd BATTGRAPH off by default
GVAR presentation in FP edit view
2013-02-25 21:34:28 +00:00
gbirkus@gmail.com 944c66dca4 adjustGV +/- was swapped 2013-02-25 21:32:09 +00:00
bsongis 56eec662a3 Compilation error 2013-02-25 20:16:51 +00:00
bernet.andre@gmail.com 74eb65117d [X9D] Massstorage 2013-02-25 20:16:36 +00:00
bernet.andre@gmail.com dcfbd424dd [X9D] Branch based on r2011 for trying to get mass storage to work... library should be included more or less correctly, need to now connect with the SD card driver (in x9d/usbd_storage_msd.c) 2013-02-25 20:13:14 +00:00
bsongis e35cf751de [9x] BATTGRAPH option added to display the Tx voltage
[all] AdjustGVARs feature reworked (now 4 modes)
[!ARM] PlayTrack can now play GVARs
2013-02-25 18:48:11 +00:00
bernet.andre@gmail.com d1b862a4f3 [X9D] Telemetry view
SIMU compilation
2013-02-24 18:06:09 +00:00
bernet.andre@gmail.com 38bcc1f29f [X9D] SPORT driver draft, only feeds the frsky packed decoder for displaying good old telemetry for now 2013-02-24 17:19:42 +00:00
bernet.andre@gmail.com 98100708d6 [X9D] Serial debug now uses a FIFO, RTC fixed 2013-02-24 15:48:03 +00:00
open.20.fsguruh@xoxy.net 83dedd83bc changed ISR masking back to old solution; throttle rescale bugfix with limits changed;
This change make ISR masking for 10msec call back to the old solution.
Bugfix for throttle time calculation if limits are changed.
Noticed my optimized recalculation routine was wrong.
Now I changed it and recalculation is done on 32bit basis which cause 16bytes more flash.
I also noticed the original version (in trunk) just does recalculation of 10 base. That means for full throttle range there would be only 10 steps noticed if limits are changed. That leads to a very unpresise calculation if your throttle limit do not match these steps.
I can do something similar but this time only with 8 steps but save 16bytes flash.
What's your opinion.
2013-02-24 14:11:12 +00:00
bernet.andre@gmail.com 5def4849fe [X9D] UART driver renamed, work on debug output 2013-02-24 12:31:02 +00:00
bsongis 87105c1268 [all] The Batt field was displayed as a timer 2013-02-23 17:27:02 +00:00
bsongis 74a6b54071 [X9D] Problem when switching a char in a model / phase name to lowercase 2013-02-23 16:36:37 +00:00
bsongis f7441620cb Issue 207 (first try, I can't test myself!) 2013-02-23 15:17:19 +00:00
bsongis 1b8e0f12b9 [X9D] Possibility to unselect the bitmap 2013-02-23 14:58:44 +00:00
bsongis eb2b7623c1 [all] The AND in Custom Switches was not at the good position 2013-02-23 11:24:00 +00:00
bsongis 0358976a4a [sky9x] Navigation bug in Model Setup 2013-02-23 10:20:33 +00:00
bernet.andre@gmail.com 3984a68671 Issue 220 fixed 2013-02-23 08:33:20 +00:00
open.20.fsguruh@xoxy.net f3a02f0f4e Timer fixed for Audio/Voice; fixed throttle calc; small flash savings; SLOW change again
brief:
------
* added compile options to makefile:
  - CORRECT_NEGATIVE_VALUES 
  - EXTENDED_EXPO_CURVE

* bugfix for Timer calculation if AUDIO or VOICE was selected for stock and Gruvin
* bugfix for Throttle timer calculation
* small flash savings about 28 bytes if SLOW wasn't moved, now only 20 bytes
* SLOW calculation moved to beginning, but no weight compensation

detailed
--------
Makefile options:

Like all other options this is set either to YES or NO. Both are default NO.
This gives the user the possibility to choose themselves about which precision they want.
Or if they want a greater EXPO range, both increases code of course. The code changes are explained in detail in source code and earlier version of this branch.

Bugfix for Timer calculation if AUDIO or VOICE was selected for stock and Gruvin
Need again some reports. I noticed there was a correction algorithm activated for 10msec call generated. For some unknown reasons, the correction was disabled, if AUDIO or VOICE was selected. This fix should make it working again. The clock was actually too fast. It's about 5 - 6 seconds per hours. Should be correct now, please test and report.
Also the IRQ disabled the timer IRQ while it is on. This is wrong as well and saved code.

Bugfix for Throttle timer calculation
Actually the throttle calculations leads to an overrun if full throttle was given. Due to -1 calculation problem this issue was not seen, because it was 1 digit smaller. With the CORRECT_NEGATIVE_VALUE option actually the full range was used, and boom, throttle timer didn't work. This fix actually corrects this and made the code about 28 bytes smaller and faster.

SLOW calculation moved to beginning, but no weight compensation
As stated by bsongis I moved the SLOW calculation to the beginning. This matches to most other remote controls. However I still left the weight compensation out. This would cost 90 bytes flash and a slow division. Basically if we move the SLOW feature to the beginning it changes the meaning for SLOW. It is not actually defining the output speed in percentage per second. It is defining the input speed in % per second. In this case a mix with high weight will move faster as a mix with small weight. That's the same for other remote controls as well.
Doing this compromise only costs 8 additional bytes of flash.
2013-02-22 20:57:31 +00:00
bsongis f69a77098f [X9D] Cosmetics 2013-02-22 20:48:55 +00:00
bernet.andre@gmail.com 3af21718cb Overlap on mixer screen in French 2013-02-22 19:59:03 +00:00
bernet.andre@gmail.com 4814a529da [X9D] French translations, Heli setup 2013-02-22 19:48:51 +00:00
bsongis 3e91b3f46d [X9D] Custom Switches screen reworked 2013-02-22 18:36:34 +00:00
bernet.andre@gmail.com d9d52762ae [voice] ONm correctly reset on model change
[X9D] Default bitmap on main view when none selected / no SD
2013-02-22 15:44:52 +00:00
bernet.andre@gmail.com bb0489725b [X9D] No SD on WDT reboot 2013-02-22 10:33:09 +00:00
bsongis 69bf79f0bc Compilation error 2013-02-22 07:59:42 +00:00
bsongis 86807ea1f4 [ARM] volatile missing 2013-02-22 07:19:39 +00:00
bernet.andre@gmail.com 85e6ac893b All translation files updated with new items. PLEASE CHECK EVERYTHING!!! 2013-02-21 22:54:03 +00:00
open.20.fsguruh@xoxy.net 2a9160fcab weight and offset range extension change (flash code cost 22bytes)
This change makes both weight and offset range bigger for all 32 possible mixers.
Instead of -125 to 125 now -245 to 245 is allowed for weight and offset in mixer.
No additional EEPROM is needed. Conversion of EEPROM follow soon...
2013-02-21 22:11:33 +00:00
bsongis b7a37c4e8a [all] Stupid bug in calcRESXto100 2013-02-21 21:14:14 +00:00
bsongis 21a5238ca9 [all] Mixer problem with switches 2013-02-21 20:41:48 +00:00
bsongis 3824939030 [all] And switches added to Custom Switches
[ARM] No Init of SD after a reboot (not tested)
[X9D] Bug when [EXIT] on MODELSEL
2013-02-21 20:25:40 +00:00
open.20.fsguruh@xoxy.net 1e3c1d8ce2 Expo EXTENDED function added, SLOW moved to old position, 8 bytes code saved
Now the expo function is explained properly. Expo execution speed should be again better.
Codesaving this time only 8 bytes.
Added EXTENDED_EXPO define for a wider range of expo. So around 0 the curve is more flat and the edges increase faster. This change costs about 84 bytes. 
I noticed the curve doesn't much change especially for smaller k values.
Now the range is extended. From 0 to 80 it gives the old curves from 0 to 100.
From 81 to 100 a higher raising curve is used. There is a small break between 80 to 81.
If this is a problem I can change it to be smooth and even less code size, but loose the old curve form.

I moved SLOW function back to old position, because it might be not a good idea if differential is actived, and the end positions are reached at different times. Therefore the smaller movement needs to be slower. Please try and test and report your opinion.

Please also test more about overruns. I was able to generate a overrun by added about 4x a 125% value with 125% offset. (output each above 200%, in total more than 800%) The overruns occurs earlier compared to original version. Could this cause a problem? I can change the internal calculation to be more like the original version, but would cost more flash.
2013-02-21 20:17:54 +00:00
bsongis 8cfde7854b [X9D] Reboot when changing the model 2013-02-21 10:51:46 +00:00
bsongis e4296225a8 Issue 213 fixed (15 custom switches on '128 / gruvin9x) 2013-02-21 09:01:24 +00:00
bsongis 229cfe45f3 A wrong constant used in Custom Functions menu 2013-02-21 07:49:07 +00:00
bsongis 390b7f12cf Issue 213 fixed (more phases, expos, switches, functions on M128) 2013-02-21 07:00:38 +00:00
bsongis a0a9d13694 Issue 214 fixed (16 files in the VOICE queue on M128) 2013-02-21 06:59:43 +00:00
bsongis aef70fc850 Issue 214 fixed (more files in the VOICE queue on M128) 2013-02-21 06:17:41 +00:00
mhotar@gmail.com 7a3499b6a4 CZ translations update 2013-02-20 23:19:21 +00:00
open.20.fsguruh@xoxy.net 2b12eabcb9 2nd try for SLOW / speed fix / opinion needed
brief description:
- SLOW should be correct now, please test a lot
- further small flash saving of 40 bytes
- higher THROTTLE accuracy not for stock but all other boards as proposed by bsongis

detailed:

while first fix claimed to be correct, it wasn't because the original version was not wrong. I was confused because the simulator in companion9x simulates nearly half of real speed. Is this intended? You will see it also on the seconds measured.

The original code was just a lot confusing and in a silly position. That's why I need your opinion!
I moved now the speed calculation to the last position in mixing calculation. This causes the slow directly operate on the output values. This saves additional 40 bytes flash code.

The original position was after trim, offset, curve, but before weight and differential.
The before weight position makes this confusing weight correction necessary. A simple position change would avoid the weight division.

My opinion for the best position for speed calculation is on the output, because whatever curve, diff, etc. calculation you had before the output will have the defined speed.

However somebody want the output to change speed according a curve? This wasn't possible with the original implementation, but a change could make this be easily possible. 
As far as I know the implementation of the expensive Graupner remote controls do it that way. So speed is something like a controlled stickmovement speed and the rest is calculated on the base of it. I asked a lot, and most people do not really care if it is calculated on input or output. An advantage on the output is the easier calculation, which results in higher mixer speed and flash code savings.

What's your opinion? Where is the best place for speed calculation?
a) on the input
b) somewhere in the middle (please specify)
c) at the output
2013-02-20 21:22:21 +00:00
bsongis 28b62a0f80 [X9D] Flight Phases screen reworked 2013-02-20 19:49:26 +00:00
bsongis 4a1ae0eaa4 Issue 203 fixed (Timer minute beep)
Issue 204 fixed (Tx Batt spoken)
[X9D] It was impossible to avoid a Format on EEPROM Alert
[all] Function v1==x modified to v1~=x (needs to be tested)
Developers list updated
2013-02-20 11:17:44 +00:00
mhotar@gmail.com 2633af9fef CZ translations 2013-02-20 09:51:06 +00:00
gbirkus@gmail.com 3c064d2275 Sticky T-cut template - issue 206 fixed 2013-02-20 08:35:41 +00:00
bsongis f5cd611683 [stock] Unused variable removed = 16bytes saved (thanks Mike!) 2013-02-20 06:18:08 +00:00
open.20.fsguruh@xoxy.net 69731d7904 Safety channel fix; Switches fix; Slow fix (potential); Optimizations
Let me explain the fixes:
1.)
Safety channel fix should avoid throttle being pushed the first few PPM outputs. Also the throttle counters are affected. Mostly noticable, the THt starts, even no throttle is given during startup. This fix should prevent this. Its just a new position for evalFunctions as proposed by bsongis

2.) Slow fix
Not so sure about this. I noticed the speed of Slow options in the mixer was always too fast for me. Wathever slow value I gave the movement was quite quick. Then I noticed I have always a small weight for that mixes. A bigger weight makes the movement faster. I thought what is the sense of this? Shouldn't it be vice versa? Then I realized the most useful way is just make it independ from weight. The speed just defines persentage of full movement per second. I think that is the most useful way to calculate it. And additionally this would simplify the mixcalculation a lot.

3.) Last but not least I found further code and data savings
- Additional 198 bytes code saved with avr-gcc 4.7.2 compared to last release. So this is in addition!
- Reduced data about 4 bytes
- Potentially there is also a slight mixer speedup possible. Not measured yet.

My first tests showed everything is now working as intended. Please test and report bug.
2013-02-19 20:23:44 +00:00
open.20.fsguruh@xoxy.net 35fc938b1e Safety channel fix
This change should avoid setting all output channels to 0 for the first few outputs generated.
Also this prevents the throttle triggered timers to start not intended after power up.
This occurs when you set throttle timers to output channel instead of stick. (By the way, is there any reason, this should be the source at all?)
Because reset of safety channels is only moved, this do not cost any additional bytes of flash.
However the reinitialisation in evalFunctions() may be missing somewhere? 
Please comment...
2013-02-18 22:03:43 +00:00
bsongis abb604bf6d [X9D] Virtual switches in Mixer sources should now work correctly 2013-02-18 21:45:35 +00:00
bsongis 8eaefce7b5 [X9D] Shift in Mixer sources 2013-02-18 20:40:41 +00:00
open.20.fsguruh@xoxy.net 63e2ae60a5 now does rescaling on 256base instead of 100; removes a lot of division by a shift right 8
Needs testing!!! Volunteer please come in. 
Benefits of change:
-248 bytes code generated used gcc 4.7.2
-huge performance increase. My measurements:
   simple mix goes down from 2,87msec to 1.93msec
   middle complex mix goes down from 3,37msec to 2,00msec
   complex mix (with phase change) goes down from 6,87msec to 4,18msec
2013-02-18 20:26:16 +00:00
bsongis 9fb1eb665f [all] Change in Mixer sources order (will allow the EXTRA_3POS option later)
[all] Change in Switches order (to match the Mixer sources order and save some flash)
[all] New menu in MODELSEL when a ROTARY_ENCODER_NAVIGATION enabled
[all] Add REs (short) and REl (long) in Custom Functions screen. Will be needed later to reset the Rotary Encoder (for example)
2013-02-18 18:52:11 +00:00
mhotar@gmail.com 9d8bfea60a CZ translations 2013-02-18 18:11:11 +00:00
open.20.fsguruh@xoxy.net 71b311cb26 created copy based on r1960 as a base for performance optimizations
This branch holds changes to improve speed and code size of stock and other versions of open9x. Some of the changes might be dangerous, that's why it is in a branch. After proper testing this branch may die, and will be merged into main trunk
2013-02-18 18:08:55 +00:00
open.20.fsguruh@xoxy.net c184efeb31 This branch holds changes to improve speed and code size of stock and other versions of open9x. Some of the changes might be dangerous, that's why it is in a branch. After proper testing this branch may die, and will be merged into main trunk 2013-02-18 18:02:37 +00:00
open.20.fsguruh@xoxy.net c724779b4d German translation updated; Thanks to Helle! 2013-02-17 19:48:58 +00:00
bernet.andre@gmail.com a0aca08c3d [X9D] Splash should now show reliably during eeprom load 2013-02-17 09:28:48 +00:00
gbirkus@gmail.com a830c0c95c Heli setup template fixed
wiki update
2013-02-15 21:08:53 +00:00
bsongis d64a71f5ab [all] Custom functions reworked
[all] Expo function rewritten and many other flash savings (thanks Andreas)
[stock] LONG key press duration is longer
[stock] Rotary Encoder bugs fixed
[stock/gruvin9x] Play Both function added
!!! TRANSLATIONS ALL NEED TO BE UPDATED BEFORE NEXT RELEASE
2013-02-15 20:11:12 +00:00
bsongis 5cda44ac0b [stock] Flash saving 2013-02-14 08:10:55 +00:00
bsongis e53ce519ff [stock] 16bytes flash saved 2013-02-13 21:32:01 +00:00
bsongis 3b756bcede Previous commit reverted 2013-02-13 21:00:19 +00:00
bsongis 2ee478d310 [stock] 16bytes flash saved 2013-02-13 20:59:31 +00:00
bsongis c36fe15174 Issue 183 fixed (JETI)
Issue 193 fixed (PWM Backlight)
[stock] Rotary encoder bug fixes
[stock / '128 / gruvin9x] Play Both function. Translations needed, who wants to add them in all language files?
[stock] 40bytes flash saved
2013-02-13 20:29:51 +00:00
bsongis 93ca2436b1 Companion9x didn't simulate a single the model in ModelEdit (open9x / sky9x board) 2013-02-13 06:58:31 +00:00
bsongis e616c4674d [Rotary encoders] Navigation system reworked 2013-02-13 06:35:45 +00:00
bsongis d7bb012f16 [stock] Fix for BG display problem 2013-02-11 22:18:29 +00:00
bsongis 983a7d8c28 Jeti compilation error 2013-02-11 06:16:17 +00:00
bsongis 18cbde2e41 Docs moved to their own directory 2013-02-10 19:52:32 +00:00
bsongis 2a39ece5af ACT Tx is stopped. Directory removed 2013-02-10 19:40:17 +00:00
bsongis fa91162539 Cosmetics 2013-02-10 17:54:55 +00:00
bsongis 0d9544d914 [sky9x] Rotary encoder button may be used to clear alarms / warnings 2013-02-10 10:22:33 +00:00
kjell.kernen@gmail.com d72c58ef92 Fix for issue 176. The fix was very easy since someone had already defined a hard coded end tolerance constant for the sticks of the 9X (value: 64). The fix only applies for PCB9XR and PCB9XR128
After some practical testing I lowered the vale to 16 for the 9XR. 32 does not work well. The sticks of the 9XR are really, really sloppy. I defined a new constant in the middle of the calib function, which is not very clean. Feel free to move this to a better place.
2013-02-10 09:35:43 +00:00
bsongis 8e6c1074e5 Battery alarm timings 2013-02-09 22:57:33 +00:00
bsongis 1568e3475f TELEMETREZ and ROTARY_ENCODER_NAVIGATION 2013-02-09 22:13:34 +00:00
bsongis 309d340daf [X9D] Audio adjustments on warnings 2013-02-09 19:36:45 +00:00
bsongis ac2fd120dc [all] Many little fixes 2013-02-09 17:51:27 +00:00
mhotar@gmail.com a90f09c4dd CZ translations 2013-02-09 15:21:07 +00:00
mhotar@gmail.com 0b5f85ab90 PWM_BACKLIGHT missing strings. Translation required. 2013-02-09 12:22:01 +00:00
bsongis c087ed17ef [stock] Rotary encoder support 2013-02-08 20:58:18 +00:00
bsongis a323af62c0 [X9D] Splash 2013-02-08 20:49:21 +00:00
bsongis db21488060 Compilation error 2013-02-08 13:23:45 +00:00
bsongis 992006217e [all] DSM2 changes (variants are now chosen in Protocol field)
[sky9x] PPM Port2 support added
[all] Negative GVARS bug fixed
2013-02-08 11:14:59 +00:00
bsongis 82ee36571e [stock] Flash saving on PWM_BACKLIGHT option 2013-02-08 06:25:56 +00:00
bsongis 0a4604615c [stock] PWM_BACKLIGHT compatible with AUDIO, not VOICE 2013-02-08 06:24:50 +00:00
bsongis 8f485462eb PWM_BACKLIGHT de translations. All other translations still missing 2013-02-06 20:49:13 +00:00
bsongis 2eed4e35a2 [stock / M128] Issue 193 fixed (PWM_BACKLIGHT option added)
[ARM] No SD support after a Tx reboot on ARM flavors
[all] Issue 194 fixed (negative GVARS - on all boards!)
[all] Vario small change on center high limit
2013-02-06 20:27:31 +00:00
ztrojanek@gmail.com 46da62bf05 Manual update: Added short description of global variabAdded information on alternative motherboards, modified description of telemetry and description of the GV link to the flight phases. Descriptions of protocols PPM, PPM16, PPMsim, PXX and DSM2 were added to chapter Setup. Picture of swashplate types added. "Overview of allowable input values" table added to Custom Switches. Chapter "General Settings" formatting error corrected. Manual text improvements by open.20.fsguruh@xoxy.net 2013-02-06 18:58:56 +00:00
kjell.kernen@gmail.com 9187b52f81 Minor changes to make the translation as much like en.h as possible. The number of characters in each translated string are now the same, at least in the strings that are likely to be truncated. 2013-02-06 11:25:10 +00:00
bsongis c4b3f94a31 [FrSky] ID 0x30 for vertical speed - unit is cm/s 2013-02-06 06:36:38 +00:00
kjell.kernen@gmail.com 6cc2f8c889 Corrected error in trim setting strig lengths 2013-02-05 21:15:57 +00:00
kjell.kernen@gmail.com 2b29a65bb1 Fixed double quotation on last row. 2013-02-05 20:52:30 +00:00
kjell.kernen@gmail.com 2ed85780f8 Minor corrections after testing the translation with X9D simulator 2013-02-05 20:49:28 +00:00
kjell.kernen@gmail.com 26dfee2b7f Fixed string problem on row 438 2013-02-05 19:45:11 +00:00
kjell.kernen@gmail.com eb161ff3e8 Reformatted to mimic en.h - Every translation on the same row in the same order
Added all the new stuff for 9xd
2013-02-05 19:41:02 +00:00
bsongis 20db18316d Companion9x compilation 2013-02-05 06:52:05 +00:00
bsongis 554aeeae76 [X9D] Navigation bug in MixerOne 2013-02-04 21:54:41 +00:00
bsongis 21b888be5d Companion9x 64bits compilation 2013-02-04 21:53:32 +00:00
bsongis 29025d98bb Companion9x 64bits compilation 2013-02-04 21:36:09 +00:00
bsongis afc058ad7b Cosmetics 2013-02-04 19:46:06 +00:00
bsongis 04fb2bdc2b [X9D] New 4 bits logo (thanks to Michael Byrne
[X9D] Model COPY / MOVE operations fixed
[X9D] New navigation system
[X9D] Pulses driver
[X9D] Watch dog
[all] es translations
2013-02-04 19:43:27 +00:00
bsongis 3a1d0b1fd9 [ARM] Negative current values with PREC2, above 200.00A 2013-02-04 07:12:21 +00:00
bsongis 3829212bef Compilation error on stock 2013-02-03 21:49:54 +00:00
bsongis 8886906c0f [All] It was possible to select THRm and !THRm in Custom Switches... 2013-02-03 21:46:13 +00:00
bsongis cf54d94f08 Issue 189 done (will be there only on ARM as we need 32bits calculations almost everywhere) 2013-02-03 21:31:17 +00:00
bsongis 2163c7a1fe Part of last commit reverted (delay always applied when a source is a switch, even if no switch configured) 2013-02-03 20:54:47 +00:00
bsongis 992e0f7ea4 Issue 188 fixed - Delay up / down and Slow up / down in Mixer must be re-tested before next release! 2013-02-03 16:25:26 +00:00
bsongis b1881ead99 Cosmetics 2013-02-03 11:54:02 +00:00
bsongis e247194fac [FrSky] VFAS is now ID 0x39
[X9D] New Mixer menu (with 2 columns)
[X9D] Names for channels
2013-02-01 18:40:08 +00:00
bsongis 313a74bc7c [Vario] Now ID 0x38 instead of 0x3F for vario (home made sensors)
[Jeti] Code cleaning
[sky9x] No more SD mount polling
2013-01-31 20:16:30 +00:00
bsongis cdc4470d1e [X9D/sky9x] No need to retrieve FP-BG system audio files as they are not used now 2013-01-31 20:10:20 +00:00
bsongis 66beb47e2d [All] Problem with 2nd telemetry screen (impossible to select bars) 2013-01-31 20:09:08 +00:00
bsongis 9c5f5c12b6 [X9D] LCD optimizations
[All] FrSky vario V2 (with cm support)
2013-01-30 21:51:57 +00:00
bsongis 6e80e39443 [X9D] Compilation error 2013-01-30 11:36:34 +00:00
bsongis 02d9800ba1 Cosmetics 2013-01-29 22:12:00 +00:00
bsongis c8abcc85ef Some fields displayed as 0 when the GVAR option was not selected 2013-01-29 21:57:04 +00:00
bsongis 857442f147 TELEMETREZ option removed. It's now EXT=TELEMETREZ 2013-01-28 21:44:38 +00:00
bsongis 4c6b4dd061 [ARM] Custom switches delays and durations reworked. Not tested. 2013-01-27 21:58:34 +00:00
bsongis 0b1bdc540e Halcyon protocol removed. Halcyon vario added instead. 2013-01-27 16:35:31 +00:00
bsongis 302de76fff [stock] Flash saving 2013-01-26 09:55:25 +00:00
mhotar@gmail.com 303f79f0bd [all] CS menu corrections- function params renamed 2013-01-25 17:58:18 +00:00
bsongis d859c9acd6 [X9D] Problem with Phase/Mix/Expo Name 2013-01-24 08:04:06 +00:00
romolo.manfredini@gmail.com afe88258d5 THR and AIL stick were reversed 2013-01-23 23:15:34 +00:00
bsongis 6dacb0fd7c 64bits simu compilation error 2013-01-23 21:20:07 +00:00
bsongis b94f54822f Code cleaning session 2013-01-23 21:16:44 +00:00
bsongis a095fab84c Code cleaning session 2013-01-23 17:40:37 +00:00
bsongis bd2e522bcf [stock] Flash saving
Companion9x compilation
2013-01-23 11:13:49 +00:00
bsongis 7c40eefe84 Companion9x compilation 2013-01-23 07:46:01 +00:00
bsongis 791d9cf66e Companion9x compilation 2013-01-23 07:27:29 +00:00
bsongis 1ae35b5148 Companion9x compilation 2013-01-23 07:20:21 +00:00
bsongis 469346178a Companion9x compilation 2013-01-23 07:18:35 +00:00
bsongis a157f0e22a X9D compilation error 2013-01-22 22:09:21 +00:00
bsongis 90405ad9ed Halcyon could not work!!! 2013-01-22 22:00:56 +00:00
bsongis a599e6da11 Issue 166 continued (2nd 3-pos switch)
Issue 177 fixed (Vario range)
Halcyon again selectable
2013-01-22 20:15:59 +00:00
bsongis a626ea2ceb [Voice] Slider for the audio volume
[Sky9x] Defaut audio volume is 12 (max is 23)
Issue 166 continued
2013-01-22 11:21:14 +00:00
bsongis 12ca975280 Issue 166 started (Thanks KanishkaRC) 2013-01-22 07:04:52 +00:00
bsongis cd90b935f3 Issue 177 continued 2013-01-21 22:36:52 +00:00
gbirkus@gmail.com 2087078d83 [ARM] same fix like in r1875 2013-01-21 22:07:04 +00:00
gbirkus@gmail.com 73386b309d spacing fix for issue 174 2013-01-21 21:39:02 +00:00
bsongis 2a6692b37a Issue 177 fixed (Vario limits). To be tested. Perhaps some flash saving to find here. Companion9x needs to be updated. 2013-01-21 20:35:53 +00:00
bsongis b07308ab80 [all] Calibration bug in last commit. To be tested and re-tested once tested 2013-01-21 20:30:02 +00:00
bsongis 9290ccc988 [X9D] Volume fixed 2013-01-21 07:27:35 +00:00
bsongis 72351d5f5d [X9D] Alaw / Mulaw codecs initialization 2013-01-20 21:37:43 +00:00
bsongis f0b2b56990 [X9D] Now the SD sounds are played. 2013-01-20 20:57:08 +00:00
bsongis dbc0a16134 [all]
- Issue 159 fixed (Pots calibration)
- Issue 174 fixed (Custom switches delta steps for telemetry)
- Flash/RAM saving in vario function and "editName" function
- -GVxx feature added
[ACT] Global variables screen continued
2013-01-19 10:40:26 +00:00
bsongis 5a11cf03cb [ARM] Support of s16le wav files
[ACT] New GVARS menu started
[X9D] Volume control added
2013-01-17 19:02:15 +00:00
bsongis 0287369be2 [Sky9x] Model name not in MIDSISE 2013-01-16 22:09:39 +00:00
bsongis 19aaeb8a27 Compilation problem 2013-01-16 21:05:00 +00:00
bsongis aa21524183 Compilation problem 2013-01-16 21:03:49 +00:00
bsongis 200edbf857 Compilation problem 2013-01-16 21:01:57 +00:00
bsongis b3e7e25849 [X9D & sky9x] Refactoring 2013-01-16 20:53:43 +00:00
bsongis dccb20d127 Companion9x helper 2013-01-15 20:08:17 +00:00
bsongis 3a852e9be1 [ACT] Navigation & Menus 2013-01-15 18:22:54 +00:00
romolo.manfredini@gmail.com 9537c3f940 fix c9x compilation issue 2013-01-14 21:14:01 +00:00
bsongis e41aa9fbd6 [X9D] Full use of the 16 grayscales.
[X9D] BMP 4bits support
[X9D] Debug driver
2013-01-14 20:08:34 +00:00
bernet.andre@gmail.com 2e747a1663 [Widescreen radios] More long strings 2013-01-14 00:37:08 +00:00
bernet.andre@gmail.com 29e669cc03 [Widescreen radios] More long strings 2013-01-14 00:17:50 +00:00
bernet.andre@gmail.com c3eb1254bc [Widescreen radios] Longer string support, telemetry screen layout
[all] 1px overlap on MODELSEL screen when line selected
2013-01-14 00:03:18 +00:00
bsongis 3f724dc6ab [X9D] Code to quickly show the 16 greyscales 2013-01-13 21:00:18 +00:00
bsongis c1c4631b73 [X9D] Navigation bugs 2013-01-13 11:09:30 +00:00
bsongis 3b7cebe09a [X9D] 64bits simu compilation ok 2013-01-13 10:04:47 +00:00
bsongis 52b7208335 [X9D] Bugs in ModelSetup menu (last line missing, last slider missing) 2013-01-13 09:39:27 +00:00
bsongis 4cb48022a2 [X9D] Navigation in CustomFunctions menu 2013-01-13 07:45:10 +00:00
bsongis af344a3687 Companion9x compilation 2013-01-12 19:30:01 +00:00
mhotar@gmail.com c60210f799 Centered texts cleanup
CZ translations
2013-01-12 18:47:27 +00:00
bsongis 0d38bd3323 Companion9x compilation 2013-01-12 18:39:52 +00:00
bsongis dfca0bd85a Companion9x compilation 2013-01-12 18:36:48 +00:00
bsongis ec3d660258 Companion9x compilation 2013-01-12 18:35:02 +00:00
bsongis a9a561aa4c Companion9x compilation 2013-01-12 18:32:14 +00:00
bsongis 9d52bdd6bd [X9D] Trainer driver
[X9D] Audio started
2013-01-12 18:21:08 +00:00
bernet.andre@gmail.com 51a665cec7 [X9D] Trims working, RTC driver fix 2013-01-11 21:38:04 +00:00
bsongis b3d26bc21f [X9D] Trims 2013-01-11 20:47:10 +00:00
bsongis 7f9092a90e Andre Bernet added to the authors list 2013-01-11 13:32:27 +00:00
bsongis ca617d8094 [X9D] RTC. Tx Setup cosmetics 2013-01-11 11:27:11 +00:00
bernet.andre@gmail.com a4ea524748 [X9D] Debug UART driver 2013-01-11 10:12:26 +00:00
kjell.kernen@gmail.com 2f0cc91aaf Translated CHANNEL MONITOR to KANAL-MONITOR 2013-01-11 10:06:18 +00:00
bsongis 13957219b9 [ACT] Remaining LCD260 2013-01-11 08:37:28 +00:00
bsongis 45458792bc [ACT] Simu is back 2013-01-11 08:01:55 +00:00
bsongis 5a5c9828d5 [X9D] Switches warning screen 2013-01-10 21:56:44 +00:00
bernet.andre@gmail.com d82e8a9359 [X9D] Buffer overflow in BMP code
[X9D] External clock for RTC
2013-01-10 09:55:14 +00:00
bsongis 20900734b8 [X9D] Bug in BMP menu 2013-01-10 06:35:02 +00:00
bsongis 29deb4c4d4 [stock, gruvin9x] Uncommanded throttle after Tx powered on. Without the inline! 2013-01-09 21:46:31 +00:00
bernet.andre@gmail.com 3236481bd6 [X9D] Forgot date format conversion 2013-01-09 20:45:18 +00:00
bernet.andre@gmail.com b1625e7980 [X9D] RTC driver (not in use yet) 2013-01-09 20:44:07 +00:00
bsongis ab501696ed [stock, gruvin9x] Uncommanded throttle after Tx powered on 2013-01-09 20:04:18 +00:00
bsongis 73e807062a [X9D] No more GREY on inactives mixes / expos. CoOS delay instead of loop in SD Init. 2013-01-09 17:38:02 +00:00
bernet.andre@gmail.com d271f3422e [X9D] Vertical menu navigation now the right way 2013-01-09 16:03:15 +00:00
bernet.andre@gmail.com b431f2e5bf [X9D] Peripheral freqs now as defines 2013-01-09 14:46:59 +00:00
bernet.andre@gmail.com 8abf660e2b [X9D] SD Card and clocks sorted hopefully for good. 2013-01-09 13:24:49 +00:00
bsongis 78ed555f6e [X9D] SD File Manager navigation 2013-01-09 09:53:59 +00:00
bsongis c434217b08 [X9D] DBLSIZE Grey 2013-01-09 07:19:14 +00:00
bsongis d8ab94d07c [X9D] Many little corrections
[stock] Another flash saving!
2013-01-09 06:38:21 +00:00
bernet.andre@gmail.com cfb1550ff5 [X9D] SD Card working 2013-01-08 23:27:42 +00:00
bernet.andre@gmail.com c07e0a7f2f [X9D] Pot directions harmonized, slider display matched, prompts adapted to key labels 2013-01-08 18:54:10 +00:00
bernet.andre@gmail.com 4c24e881c4 [X9D] Analog ref is 3V, not 3.3V 2013-01-08 09:45:11 +00:00
bernet.andre@gmail.com 9812daa0aa [X9D] Battery voltage scale factor
[X9D] Pots+Switches work in mixer
2013-01-08 08:38:40 +00:00
bsongis 7189fa0b54 [all] Updated es translations 2013-01-07 22:53:32 +00:00
bsongis b746528ac8 [all] Updated es translations 2013-01-07 22:41:25 +00:00
bernet.andre@gmail.com edd838d866 [X9D] Sticks and pots OK, calibration OK 2013-01-07 21:22:46 +00:00
bsongis 599bacd673 [X9D] SD support 2013-01-07 18:42:58 +00:00
bsongis dfee4b4f36 [X9D] SD support 2013-01-07 18:41:16 +00:00
bsongis 5cb5ee0111 [X9D] SD support 2013-01-07 18:35:24 +00:00
bsongis 8123713372 [X9D] Anas array 2013-01-07 11:16:37 +00:00
bsongis 6ab940a334 [X9D] Anas array 2013-01-07 11:14:42 +00:00
bsongis 6cd0b4832f [X9D] Tx voltage 2013-01-07 11:11:54 +00:00
bsongis f686e5325d [all] Timers alignment problem (thanks Gabriel for the report!) 2013-01-07 11:06:08 +00:00
bsongis df1a2ac19a Remaining messages on EEPROM format! 2013-01-07 10:58:18 +00:00
bsongis d3fd34a765 [X9D] ADC driver added. Unused files removed. 2013-01-07 10:37:35 +00:00
bernet.andre@gmail.com 97595efa83 [X9D] Switches now OK on both HW and simu 2013-01-07 08:42:12 +00:00
bsongis 5e940e56f4 Companion9x compilation 2013-01-07 07:30:09 +00:00
bsongis 5c60440d36 [gruvin9x] Compilation broken 2013-01-07 06:19:56 +00:00
bernet.andre@gmail.com 6ff0448d67 [X9D] Switches for simu hopefully OK, it's getting late 2013-01-06 23:30:58 +00:00
gruvin@gmail.com 3cc65aa771 G9X: Corrected TX_CADDY / DSM2_PPM. (See comments comments r1735) 2013-01-06 22:57:36 +00:00
bernet.andre@gmail.com 3f21e6c1a4 [X9D] Switches now match case labels, home screen display still to adjust 2013-01-06 22:56:39 +00:00
bsongis 148d8a726f [X9D] Mixer now runs 2013-01-06 22:25:10 +00:00
bsongis 796c1adfbc [X9D] Free bytes displayed correctly in MODELSEL 2013-01-06 21:43:47 +00:00
bsongis d657619430 [X9D] Little dissplay bug on MODEL01 in MIDSIZE 2013-01-06 21:42:37 +00:00
bernet.andre@gmail.com 59696d639d [X9D] Soft power control working 2013-01-06 21:29:50 +00:00
bsongis f420cc7d56 [X9D] EEPROM eeCheck() re-enabled 2013-01-06 21:10:39 +00:00
bsongis f8bff1640e [sky9x] Compilation failed 2013-01-06 19:41:17 +00:00
bsongis 24ce936d2b [X9D] Inverted keys 2013-01-06 19:07:43 +00:00
bsongis 0a976e1f3e [X9D] Keys seem working with that ... 2013-01-06 18:36:29 +00:00
bernet.andre@gmail.com 78efc5f0f0 [X9D]
- blocking delay_01us using timer13 (need to check peripheral frequencies)
- eeprom working
2013-01-06 18:09:27 +00:00
bsongis 6c4193f158 [X9D] Traces removed 2013-01-06 16:55:04 +00:00
bsongis 4953141252 [X9D] EEPROM again 2013-01-06 16:31:29 +00:00
bernet.andre@gmail.com 6b3836e9a2 [X9D] I2C eeprom driver fix 2013-01-06 15:15:06 +00:00
bsongis 8f5aaad3d6 [X9D] EEPROM bug fixes 2013-01-06 12:49:46 +00:00
bsongis a8f3e77e22 [X9D] 4 greyscales now ok 2013-01-06 12:34:47 +00:00
bsongis ee7b9f2001 [X9D] Soft switch not working. I remove the code for the moment. 2013-01-06 11:34:48 +00:00
bsongis 356906c1eb [X9D] I remove the test code 2013-01-05 22:32:13 +00:00
bsongis 216e172dcf [gruvin9x] Latest change on TX_CADDY reverted 2013-01-05 09:33:35 +00:00
bsongis 9c7c55e4cd [gruvin9x] Latest change on TX_CADDY reverted 2013-01-05 09:32:52 +00:00
bsongis 532848849c [X9D] EEPROM support
[X9D] LCD greyscale support when writing chars on screen
[stock] Flash saving in EEPROM read function
[gruvin9x] TX_CADDY little optimization
2013-01-04 22:18:35 +00:00
bsongis e406021828 Companion9x compilation 2013-01-03 07:42:49 +00:00
romolo.manfredini@gmail.com e13b957b17 Fix linking issues in c9x 2013-01-03 01:10:53 +00:00
bsongis c84314862e Companion9x compilation 2013-01-03 00:28:55 +00:00
bsongis 4b87e1a859 Companion9x compilation 2013-01-03 00:13:03 +00:00
bsongis 5d88b83491 Companion9x compilation 2013-01-03 00:11:44 +00:00
romolo.manfredini@gmail.com 0c0d8ba47e fix for no curves 2012-12-31 23:54:10 +00:00
bsongis 4e522fce6c [stock] 6bytes flash saved 2012-12-28 22:15:12 +00:00
bsongis 13c15bd6ef [X9D] Simu now displays greyscales 2012-12-28 19:03:11 +00:00
bsongis 485d5bbdea [X9D] lcd_img now works with GREY1 and GREY2 2012-12-28 09:13:37 +00:00
bsongis 56e01f4fb5 [X9D] EEPROM driver started 2012-12-28 08:37:29 +00:00
bsongis 3d92371570 [X9D] Backlight support on simu 2012-12-28 08:20:22 +00:00
bsongis 7eae709938 [X9D] I commited the SysTickk_Handler :( 2012-12-27 20:25:15 +00:00
bsongis aeb727bcbf [X9D] Problem when changing trackname parameter when > 4 chars 2012-12-27 19:24:41 +00:00
bsongis 13f8bb018b [sky9x] Scrollbar display problem 2012-12-27 19:11:28 +00:00
bsongis 759027cea4 [X9D] Corrections from Mike on LCD driver. Addition of 2 grayscales in LCD functions. 2012-12-27 18:46:11 +00:00
bsongis 326f85dcd7 [X9D] Backlight should now work 2012-12-23 09:05:19 +00:00
bsongis fd002d68cd [X9D] LCD driver optimization 2012-12-23 08:41:21 +00:00
bsongis b7de04020d [X9D] LCD driver bug 2012-12-23 08:37:21 +00:00
bsongis 155f27c217 [X9D] HSE_VALUE set to 12000000 in Makefile 2012-12-23 07:46:56 +00:00
bsongis 94b710ceaa [arm] No refresh on Mixer AUDIO files, not implemented now ... 2012-12-22 22:19:46 +00:00
bsongis e410336348 [arm] PPM_CENTER_ADJUSTABLE should now work 2012-12-22 22:16:46 +00:00
bsongis 3f3cdadb30 [arm] Virtual channels were not working any more 2012-12-22 21:43:00 +00:00
bsongis 5e29fa0737 [arm] Custom Switches duration was never working! 2012-12-22 20:47:27 +00:00
bsongis 808809650d [X9D] Simu warning removed 2012-12-22 20:34:24 +00:00
bsongis cb92decfe3 [X9D] Simu warning removed 2012-12-22 20:23:38 +00:00
bsongis a999009c24 [X9D] Wrong PINS in the FrSky keys driver 2012-12-22 20:00:23 +00:00
bsongis 310a9e03e2 Companion9x compilation 2012-12-22 19:11:43 +00:00
bsongis 4cb7f6497e Companion9x compilation 2012-12-22 19:03:49 +00:00
bsongis 40c353524d Companion9x compilation 2012-12-22 19:01:49 +00:00
bsongis f5addfa8ca [sky9x] Some more file movements 2012-12-22 18:51:23 +00:00
bsongis 618d7f924f [all] Files movements...
[X9D] Switches driver added
2012-12-22 18:04:32 +00:00
bsongis e534c2c7ea [ACT] Link against the right ST libs 2012-12-22 16:58:09 +00:00
bsongis fd6f0ec952 [simu] Error with the LCD 2012-12-22 16:19:22 +00:00
bsongis 5954d213a6 [ACT] STM32F10x lib added 2012-12-22 15:34:33 +00:00
bsongis 57bf12dbdb [ACT] STM32F10x lib added 2012-12-22 15:28:35 +00:00
bsongis b1bc43aa1d Simu fix 2012-12-22 15:12:39 +00:00
bsongis 4996756e21 [X9D] Test code 2012-12-21 21:04:46 +00:00
bsongis a87c74bf31 [X9D] Test code 2012-12-21 21:02:25 +00:00
bsongis a78c5d348e [X9D] Some more drivers added (keys / power).
[ACT] Splash. Simu working. All screens need to be reworked!
2012-12-21 18:29:59 +00:00
bsongis cea3ee724e [ACT] First simu now compiles. Next step: the keys 2012-12-21 07:35:02 +00:00
bsongis 3d6d7e6a20 [X9D] I remove the Project directory from ST library 2012-12-21 06:30:49 +00:00
bsongis f00ed18da8 [X9D] Keys driver initialization added 2012-12-20 22:15:38 +00:00
bsongis 8c3c429a20 [X9D] Keys driver initialization added 2012-12-20 22:13:21 +00:00
bsongis e15654edad [X9D] First compilation OK! Next step: integrate the code for the drivers (only LCD done) from FrSky... 2012-12-20 21:51:26 +00:00
bsongis 5f19f78509 [all] PPM value in us in the title bar of LIMITS menu when using PPM_UNIT=US (thanks François for the bug report!) 2012-12-19 17:37:51 +00:00
gruvin@gmail.com fada51f5b3 G9Xv4 Board: Committing TX_CADDY feature to trunk.
This feature allows use of a transmitter module 'caddy' PCB, which facilitates
automatic DSM2(X) or Fr-Sky transmitter module switching, without having to
swap TX module on the back of the radio. Two antennas are installed on the
radio instead of attempting to switch 2.4GHz RF signals, for reliability. The
TX Caddy circuit schematic and PCB layout can be found in the gruvin9x hardware
project.

I am not really expecting anyone else to implement this feature. But it's there 
for those who might and adding it to trunk prevent me having to manually port 
the feature to new versions, each time I update my field radio.

-- Gruvin
2012-12-18 21:35:14 +00:00
bsongis 0c6dbbba4c [sky9x] No shutdown after INVALID EEPROM
[all] Some functions names renamed
2012-12-17 21:06:36 +00:00
bsongis 648d2c3beb [sky9x] Model audio files function not finished, I comment everything to be able to release! 2012-12-16 22:37:44 +00:00
bsongis 689fea2f90 [all] Fade-in / Fade-out in flight phases was broken (wrong flash saving) 2012-12-16 22:11:35 +00:00
bsongis 139c700025 [sky9x] Current consumption was always 0 2012-12-16 17:38:10 +00:00
bsongis bc52f7077f [all] PPM_UNIT instead of PPM_LIMITS_UNIT and DECIMALS Makefile options
[sky9x] Aurora gimbals support (untested)
[arm] Start of implementation for sounds associated to Mix/FP/Switches in SD directories
2012-12-16 13:30:59 +00:00
bsongis 7329d8b728 [X9D] LCD Driver - 2 functions: refreshDisplay() and lcd_init() 2012-12-14 18:41:37 +00:00
romolo.manfredini@gmail.com 2f311dddfd Avoid segfault in simulator 2012-12-13 23:08:42 +00:00
bsongis 16d4601043 [stock / gruvin9x] Problem with FRSKY + DSM2_SERIAL 2012-12-10 21:23:36 +00:00
bsongis 5a2d6cb250 [X9D] Makefile option added: CPUARM
[Sky9x] GVARS Bug in EEPROM
[Sky9x] Mu-law codec added
2012-12-10 21:00:02 +00:00
bsongis 2037f0d8b0 [stock / gruvin9x] FrSky and DSM2 serial mode
[Sky9x] Bootloader mode on REVC
2012-12-10 10:30:54 +00:00
bsongis fb7525e42d [sky9x] REVC support 2012-12-10 08:11:05 +00:00
gruvin@gmail.com 7e75360ef3 G9X (and others?): Issue 163
FRSKY and DSM2=SERIAL are NOT mutually exclusive.

NOTE: This fix may have broken something else. But for now, it has 
made DSM2 SERIAL work again.
2012-12-10 05:26:36 +00:00
bsongis 46000a15ba Simu compilation 2012-12-08 08:36:10 +00:00
bsongis 8a98283cb0 [All] getADC() now uses something between SINGLE and OSMP methods 2012-12-07 19:36:28 +00:00
bsongis f6caf5eae3 [All] getADC() now uses something between SINGLE and OSMP methods
[X9D] MODELSEL menu continued
2012-12-07 19:05:11 +00:00
bsongis 13370a6abf Companion9x VC++ compilation 2012-12-07 13:24:08 +00:00
bsongis 05649d7123 Companion9x VC++ compilation 2012-12-07 13:15:25 +00:00
bsongis 488fbfd29d [All] FILTER mode for ADC inputs removed 2012-12-07 10:29:19 +00:00
gruvin@gmail.com 7591e6411e G9X V4 board: Conditional code for Cam's new SOMO initialisation to prevent
crash for folaks without SOMO-14 installed.
2012-12-07 01:05:26 +00:00
bsongis 37457e8151 Mix bug (when undeterminate value). 2012-12-05 22:17:39 +00:00
bsongis b80a6dccaa [stock / gruvin9x] Issue 164 fixed
[X9D] Calibration menu
[all] 5-pass mixer
[stock] Flash saving
2012-12-05 20:48:49 +00:00
th9xer 209c685f11 [GRUVIN9X] Changes for SOMO sound module
Correction to start pulse timing, and extended data setup time.
Also started using the SOMO reset signal, this allows for faster power on and WDT reset initialization and stops erroneous playback after WDT reset.
Connection needs to be made from PORTH pin 3 via a 220ohm series resistor to the SOMO14D reset pin.
2012-12-04 18:31:06 +00:00
bsongis 7303e99bab Spaces removed 2012-12-04 18:23:47 +00:00
bsongis ce7adabfbe [X9D] Switches working on simu
[stock / gruvin9x] N-pass mixer
2012-12-04 14:26:41 +00:00
bsongis 968d1307fc [X9D] Mix Sources 2012-12-02 22:22:13 +00:00
bsongis 6b77921948 [X9D] Mix Sources 2012-12-02 18:54:01 +00:00
bsongis 3256be6f3a Just spaces removed 2012-12-01 19:26:28 +00:00
bsongis 72fd306015 [X9D] Some switches in simu, not finished 2012-12-01 19:07:58 +00:00
bsongis a2309abc88 Simu link error (when -O0 used) 2012-12-01 19:05:43 +00:00
bsongis 2248750812 Simu link error (when -O0 used) 2012-12-01 18:44:06 +00:00
ztrojanek@gmail.com 7b84ba8c6d CZ Manual update: Adding descriptions of protocols PPM, PPM 16, PPMsim, PXX and DSM2 in Chapter Setup 2012-12-01 09:32:33 +00:00
bsongis cdaa063188 [DEBUG] Issue 162 fixed (Test function - while 1; to test the WDT - was not removed). Test label badly displayed when GVARS disabled. 2012-11-30 06:30:54 +00:00
bernet.andre@gmail.com c89d4b05c7 [X9D] Channel monitor labels better centered
[X9D] Backlight color ;)
2012-11-29 22:23:57 +00:00
bsongis 206f3bd334 [X9D] Tiny font script added 2012-11-29 22:13:51 +00:00
bsongis 7c192910d1 [X9D] Tiny font added (numbers only)
[X9D] Channels monitor
[X9D] Switches main view
2012-11-29 20:27:21 +00:00
kjell.kernen@gmail.com 1d6c8627c0 Translated Own. Changed all caps headings to caps/lowercase to improve readability. 2012-11-29 11:17:49 +00:00
kjell.kernen@gmail.com 53a4bfaac5 Translated the new and changed strings. Except "own". I do not know if own should be interpreted as short for the noun "owner" or the adverb "own" or the verb "own". Swedish uses three different words for these. 2012-11-29 08:25:55 +00:00
bsongis 424daa752c [X9D] Positions and sizes adjustements 2012-11-29 06:43:17 +00:00
bernet.andre@gmail.com 5e78ec7edd Updated midsize font was missing 2012-11-29 00:16:02 +00:00
bsongis 18174446bc [X9D] Midsize font: lower case chars are narrowed 2012-11-28 22:46:46 +00:00
bernet.andre@gmail.com c5a8e15f21 Translation strings missing 2012-11-28 22:44:44 +00:00
romolo.manfredini@gmail.com 897a698e4b Small typo 2012-11-28 22:40:09 +00:00
bsongis 814452ee35 [X9D] Midsize font: numbers are narrowed 2012-11-28 21:56:01 +00:00
bsongis ab1fcd9997 Companion9x compilation 2012-11-28 18:21:30 +00:00
bsongis 0a6cbe92b6 [X9D] Small font added
[X9D] Main view continued
[Sky9x] Sounds selection again OK (thanks Scott for the report)
2012-11-28 18:04:18 +00:00
bsongis b16971b644 [X9D] New midsize font 2012-11-27 22:34:11 +00:00
bsongis 7173fc3d2b [X9D] Les cacas retirés 2012-11-27 22:28:06 +00:00
bsongis 9f8045c362 [X9D] Display regressions fixed 2012-11-27 22:13:48 +00:00
bsongis 10fa05c3ce Script for the fonts 2012-11-27 21:24:06 +00:00
bsongis ad8eb930da [X9D] New font. BMP 1bit support. 12 chars model name. Main screen 2012-11-27 21:15:09 +00:00
romolo.manfredini@gmail.com 031bf5e3a1 Some cut and paste mistake corrected 2012-11-26 19:49:20 +00:00
bsongis 6e558b41f0 TTS script bug (thanks njozsef!) 2012-11-24 19:16:04 +00:00
bsongis 7ce5df53a9 Remaining printf in last commit 2012-11-23 20:19:33 +00:00
bernet.andre@gmail.com 92e20f2427 Stick sensitivity for inactivity/backlight 2012-11-23 20:12:10 +00:00
bsongis 8220f84616 [stock] TelemetrEZ board support
[stock] Flash saving again
[stock] Inactivity alarm / Light auto off should be again ok
[X9D] Mixer sources names / Switches names
2012-11-23 18:56:19 +00:00
bsongis 03751a1c75 [X9D] Switches added 2012-11-22 19:17:26 +00:00
bernet.andre@gmail.com 31c2d69303 [wiki] Changelog for r1670
[wiki] TODO in FR manual
DBLSIZE extra font improved
2012-11-22 17:26:37 +00:00
bsongis 9d4f38f127 [all] Bug introduced, [EXIT] in CurveOne exits also the CurvesAll menu... 2012-11-22 15:23:51 +00:00
bsongis 1c3a8a9803 M128 EEPROM Variant to differentiate from gruvin9x EEPROM 2012-11-22 14:00:04 +00:00
bernet.andre@gmail.com 613ebe97d4 Extra font files for ARM boards - only arrows (every 45deg) for now 2012-11-22 12:24:30 +00:00
bsongis 99aa5eead5 [X9D] Navigation wraparound inside menus 2012-11-22 11:45:31 +00:00
bsongis 60616c1619 [X9D] Navigation wraparound in menus pages selection 2012-11-22 11:33:42 +00:00
bsongis b6debf27ec [stock] Flash saving
[X9D] Navigation continued
2012-11-22 11:20:15 +00:00
bernet.andre@gmail.com 47fc05c25e DSM2=PPM was rendered unsafe by a change in r1579:1015 aiming to reduce latency a bit too much 2012-11-22 09:51:20 +00:00
bsongis 28b736f1e8 [rotenc] Navigation bug fixed 2012-11-21 22:10:14 +00:00
bsongis 84e91d8c27 [stock] Flash saving
[X9D] Navigation continued
2012-11-21 21:50:16 +00:00
bsongis f99f7bcd55 [X9D] Different center position on screen (centered strings) 2012-11-21 20:49:50 +00:00
bsongis d489482dfc Bug in TEMPLATES screen (confirmation warning skipped) 2012-11-21 20:47:22 +00:00
bsongis 98992ce1b0 [stock] Flash saving
[X9D] Navigation continued
[sky9x] Mulaw codec added as an option
2012-11-21 18:27:21 +00:00
bsongis efe8c2ec8c [stock/gruvin9x] Better synchro when the mixer duration increases! Safety check on mixer interval. 2012-11-21 10:10:12 +00:00
bsongis 92a7363abc Companion9x compilation 2012-11-20 23:15:07 +00:00
bsongis 40ba5925fc [stock] Issue 157 fixed
[gruvin9x] Issue 160 fixed
2012-11-20 22:33:26 +00:00
rob@marotori.com 6f2452afd0 Updates to the english language to make some alerts sound better. - stopping words sounding too close to each other! 2012-11-20 15:54:37 +00:00
bsongis 680f838b1d [gruvin9X] WDT reset when changing Tx mode 2012-11-19 20:08:01 +00:00
bsongis 923a03f775 [X9D] Navigation in CurveOne menu 2012-11-19 16:41:37 +00:00
bsongis 97b261abe2 [gruvin9x] Stack overflow during Backup / Restore of models 2012-11-19 16:40:35 +00:00
bsongis 6014b6fdbf [all] Google tests now again all OK 2012-11-19 16:38:33 +00:00
ztrojanek@gmail.com d707709b94 CZ Manual update: Modified Introduction, described the new structure of the menu Radio Setup, modified graph of the Limits, Czech pictures added to chapter Global Variables. Added information on alternative motherboards, modified description of telemetry and description of the GV link to the flight phases. 2012-11-19 01:29:52 +00:00
romolo.manfredini@gmail.com aec4c783eb Missing stamp for stock128 2012-11-18 19:34:58 +00:00
ztrojanek@gmail.com 554521746b Manual update: Added short description of global variables 2012-11-16 03:03:15 +00:00
bsongis bef5ee525d [X9D] More work on navigation
[RotEnc] Pressing [EXIT] inside a menu returns in page selection mode
[stock] More flash saving
2012-11-15 17:49:31 +00:00
romolo.manfredini@gmail.com 6150cac0f5 TTS fixes 2012-11-15 02:10:48 +00:00
romolo.manfredini@gmail.com b3b670b55f ES and PT TTS 2012-11-14 19:27:48 +00:00
bsongis bad137b615 [X9D] Model Menu navigation continued 2012-11-14 08:11:13 +00:00
bsongis 4339896e4b [X9D] Main view navigation continued 2012-11-14 07:36:54 +00:00
bernet.andre@gmail.com e924c8fa64 PT final translation 2012-11-13 22:30:07 +00:00
bsongis 395d0d6b39 [X9D] Some work on navigation with the 6 keys (+ - Enter Menu Page Exit) 2012-11-13 20:46:41 +00:00
bernet.andre@gmail.com 4c22ea18fd PT translations replacing BR
[Wiki] typos
2012-11-13 20:35:46 +00:00
bernet.andre@gmail.com 7a6d3fea3f [wiki] changelog now goes further back 2012-11-13 10:44:44 +00:00
bsongis 3f787ffe24 [stock] Flash saving 2012-11-13 08:55:37 +00:00
bsongis 339e250b76 Brazil translation added! 2012-11-13 06:24:06 +00:00
bsongis aceb935066 [stock] Flash saving 2012-11-13 06:23:12 +00:00
bsongis 1801cc5b53 Issue 157 fixed
[stock] Flash saving (around 100bytes)
2012-11-12 21:06:40 +00:00
romolo.manfredini@gmail.com a29c9c724e German translations updated 2012-11-12 20:08:47 +00:00
bernet.andre@gmail.com b135645132 [wiki] French manual work 2012-11-12 17:40:48 +00:00
mhotar@gmail.com 7f4fe24c68 Cz translations 2012-11-11 17:24:57 +00:00
ztrojanek@gmail.com 03936ee234 CZ Manual update: Added global variables 2012-11-11 16:57:19 +00:00
romolo.manfredini@gmail.com e25c54e83e German tts (first commit) 2012-11-11 14:10:23 +00:00
bernet.andre@gmail.com 50a6b2645a German translations 2012-11-11 13:37:36 +00:00
bernet.andre@gmail.com 3a9dac665b German / French translations 2012-11-11 13:21:05 +00:00
gruvin@gmail.com d3aba9688c Companion9x / simu compilation -- better this way, I think. 2012-11-11 10:00:12 +00:00
bernet.andre@gmail.com 71c0b7b1d9 Companion9x / simu compilation 2012-11-11 09:34:59 +00:00
gruvin@gmail.com b627237b1d [g9x] Nothing changed -- just a typo on code comment. 2012-11-11 08:58:01 +00:00
gruvin@gmail.com 2d12a7dc44 [g9xv4] Tightened up DSM2_PPM latency by reverting previous band-aid fix
for mixer timing problems, now fixed.

Added/edited code comments some more.
2012-11-11 08:48:50 +00:00
gruvin@gmail.com 6a08bd830a [g9x] DSM2=SERIAL FIXED AGAIN -- this time better.
See comments for r1577 for details. Short version is that I found
a deeper root cause for the problem and corrected that instead
of the previous fix, which turned out to be a band-aid only.
2012-11-11 08:21:40 +00:00
gruvin@gmail.com f222600612 [g9x] DSM2=SERIAL FIXED.
I found that wdt_reset() was not being called in the scheduled interrupt 
iservice routine because HEART_TIMER_PULSES was not being flagged in 
serial transmit interrupt. This is needed because in DSM2=SERIAL mode, 
there are no bit-bang functions being used and thus no HEART_TIMER_PULSES 
'heart beats' to record.

I am at a loss as to how or exactly when this bug crept in. I have gone
over everything I committed since r1380 but cannot find anything 
directly related. So I just don't know. But it's fixed now. Yay \o/

I also added/edited a bunch more code comments along the way to finding this.
2012-11-11 05:23:44 +00:00
gruvin@gmail.com fa7de3dbd8 [pcbgruvin9x] Removed two lines no longer needed for a feature that
never worked on '2560 chip because UART takes over RX pin even when
receiver is disabled (a chip design flaw, far as I can tell.)
2012-11-11 04:09:32 +00:00
gruvin@gmail.com bff713d8d8 [avr boards] Just code comments plus one fix ...
-#if defined(PCBGRUVIN9X)
+#if defined(PCBGRUVIN9X) && defined(DSM2_PPM)

DSM2=SERIAL mode continuous WDT reset problem still present. Still
can't figure out why. Still working on it. :-/

Gruvin.
2012-11-11 04:04:54 +00:00
gruvin@gmail.com 434c071bda [avr boards] Minor fix to legacy problem with the very first PPM
output frame, where correct pulse polarity was not always set 
until the second call to setupPulses, from within the PPM mode 
pulse train interrupt handler.

I tested proper function in PPM mode on the logic analyser 
before committing.
2012-11-11 03:31:45 +00:00
gruvin@gmail.com 340043a73e [gruvin9x] Just some added comments to help clarify some ifdef blocks. No functional changes. 2012-11-11 00:25:44 +00:00
bernet.andre@gmail.com 087f4e3276 Issue 156 fixed 2012-11-10 23:36:52 +00:00
bernet.andre@gmail.com 327b8f78dd Full, updated German translations
French translations
2012-11-10 19:50:51 +00:00
f.aguerre@wanadoo.fr 0a411ea12f FR manual update (better synoptic) 2012-11-10 19:13:53 +00:00
bsongis 0a029ab3ff Issue 153 fixed 2012-11-10 17:21:45 +00:00
f.aguerre@wanadoo.fr 8e3d389e99 FR manual update 2012-11-09 22:48:30 +00:00
ztrojanek@gmail.com 8845ae57f3 Manual update: Revised Telemetry Chapter, changed manual licence and redirecting donations to MSF 2012-11-09 22:32:21 +00:00
ztrojanek@gmail.com e3d8ea1117 CZ Manual update: Added Telemetry Chapter, changed manual licence and redirecting donations to MSF 2012-11-09 22:30:30 +00:00
bsongis dfa697d47c [SD] Wrong message in status bar when backuping a model! 2012-11-09 11:03:59 +00:00
bsongis 839bad199e Simu sky9x compile errors 2012-11-09 10:17:53 +00:00
bsongis cedb966958 Better alignment in FunctionSwitches 2012-11-09 10:14:46 +00:00
bsongis 7d63dbf226 [gruvin9x] DSM2-PPM better timings 2012-11-09 10:00:28 +00:00
gruvin@gmail.com fa28b67db6 [g9xv4] Mixer interrupt synchronised with setupPulses timing. Tested good.
Thanks Bertrand.
2012-11-09 04:20:37 +00:00
f.aguerre@wanadoo.fr 63e6edc5af Fr manual (small corrections, thanks André !) 2012-11-08 19:11:21 +00:00
bsongis 91747475c8 [rotenc] Many little enhancements
[sky9x] General Menu Alarms misaligned
2012-11-08 17:36:56 +00:00
bsongis ba65591076 FSPLASH bug fixed
Rotary Encoders Navigation bugs fixed
2012-11-08 11:30:27 +00:00
bernet.andre@gmail.com eb4bfffc33 ADCW -> ADC as required by newer avr-gcc versions 2012-11-07 22:04:31 +00:00
f.aguerre@wanadoo.fr 0d6b19e350 FR manual updated 2012-11-07 21:58:53 +00:00
bsongis 6cffbed503 [jeti] Wrong screen title 2012-11-07 13:25:29 +00:00
gruvin@gmail.com 172820b4ae [avr/dsm_ppm] Testing of a stock unit reveals that DSM2=PPM bit timing
adjustment is NOT required for the stock board. Thus, all the problems Cam and
I have witnessed appear to apply only to the ATmega2560 chip -- bringing the
total number of design bugs in said chip that we alone have now found to 3.

I do not have any ATmega128 based boards to runs tests there-on.

The only change here is to the code comment on the same topic.
2012-11-06 10:14:52 +00:00
mhotar@gmail.com 10416db062 CZ translations, TR_MENULIMITS back to "LIMITY" 2012-11-04 19:01:39 +00:00
bsongis 0126797857 [all] Fix for helping to add new curves into open9x 2012-11-04 05:41:00 +00:00
bsongis 5113a3f5d3 [all] Fix for helping to add new curves into open9x 2012-11-03 22:24:19 +00:00
bsongis 0d591c748f Issue 152 fixed 2012-11-03 15:50:21 +00:00
bsongis fdc0ff334d [sky9x] EEPROM automatic conversion now ok 2012-11-02 21:03:37 +00:00
bsongis 55b242c96b [all] Telemetry display bug fixes
[X9D] Some more work on screens
2012-11-02 16:53:44 +00:00
bsongis 1080514bd9 [all] Telemetry display bug fixes 2012-11-02 16:17:13 +00:00
bsongis abcc80b266 [all] More precision for the telemetry bars
[fr] TTS script updated
2012-11-02 15:04:42 +00:00
bsongis 81aedf9ecd [FrSky] Wrong units and ranges in bars / custom switches for some telemetry values 2012-11-02 13:46:56 +00:00
mhotar@gmail.com 18317070f2 Czech translations 2012-11-02 10:55:51 +00:00
mhotar@gmail.com 1a7449b227 tts_cz & tts_sk updated. No new sound files needed.
CZ translations updated
2012-11-01 21:48:41 +00:00
bsongis 2e96ba10b1 Issue 150 fixed (thanks Kilrah!) 2012-11-01 19:26:51 +00:00
gruvin@gmail.com c4aca143a0 G9X / stock boards -- last THREE commits in error! (Thanks Bertrand).
Good grief. This time!
2012-11-01 10:37:31 +00:00
gruvin@gmail.com 631079ff1b G9X / stock boards -- last commit was in error, again :'(. Fixed here. Need to sleep. 2012-11-01 10:28:35 +00:00
gruvin@gmail.com 495c67406c G9X / stock boards: Restricted minor recent change to G9X board
only, until more timing tests on stock board can be done.

In case you're wondering, I'm planning on using the PB7 back-light 
conection on an otherwise unmodified board, for those tests --
since PORTH isn't available and all. ;-)
2012-11-01 10:11:05 +00:00
gruvin@gmail.com 37387f91fd GTRUVIN9XPCB: DSM2=PPM mode -- Implemented hardware switching of PPM_OUT pin
and compensated for main clock synchronisation to get accurate 8us bit 
lengths, as measured on the logic analsyser. 

Specifically, all 1 and 0 bits now measure 8.000us in length, instead of 
varyting from 6.250us to 10.750us, as before.

NOTE: A similar len-5 / len+3 compensation is almost certainly required
      to improve bit timing on the stock board, in software bit-bang mode,
      but I did not want to commit such a change to trunk without being
      able to bench test it first. The values might differ slightly, due
      to the number of instruction cycles executed before the actual
      PORT B bit toggle code is reached. But it will NOT be the same for 
      both 1 and 0 bits.
2012-11-01 08:44:14 +00:00
bsongis d02ef1b603 Compilation should be ok now
PORTH_TIMING option now included in DEBUG=YES
2012-11-01 06:58:22 +00:00
gruvin@gmail.com c71ee46e5f Makefile addition for GRUVIN9X PCB PORTH real-time diagnostics.
$ make ... PORTH_TIMING=YES

See code comments for details. This is used to analyse real-world timing of
mixer interrupt, setupPulses and PPM or DSM=SERIAL or DSM2=PPM data output
streams.

NOTE: Not compatible to SOUND=YES (SOMO14)
2012-10-31 23:40:21 +00:00
bernet.andre@gmail.com 21f3e4395a French translations 2012-10-31 21:48:57 +00:00
romolo.manfredini@gmail.com c130f48f2d Italian translations 2012-10-31 19:11:34 +00:00
romolo.manfredini@gmail.com 6305fd84d2 Italian translations 2012-10-31 18:55:27 +00:00
bsongis 42650540ca [all] Function Switches renamed to Custom Functions
[voice] No more PREC2 in prompts (optimization done - 50bytes flash - for en and fr, not other languages!)
2012-10-31 16:38:49 +00:00
bsongis 721e64c993 Issue 148 fixed (translated strings) 2012-10-30 23:21:30 +00:00
bsongis b8a040606b [sky9x] Compilation problem (thanks Hendrix!) 2012-10-30 20:29:44 +00:00
bsongis dc5bf21171 [!stock] No variant displayed as it is not needed 2012-10-30 17:46:19 +00:00
bsongis 00390a6fd4 [stock128] No variant there! 2012-10-30 17:38:44 +00:00
bernet.andre@gmail.com 4ae4850820 French translations 2012-10-29 22:19:07 +00:00
bsongis 8144b42a6d sky9x and gruvin9x args (instead of arm and v4) in tts.py 2012-10-29 22:12:07 +00:00
bsongis 3875bf981d [stock] Custom prompts shifted (thanks Martin for the tests!) 2012-10-29 22:06:15 +00:00
bsongis a5ba6ff463 VARIANT is not available on VS++ 2012-10-29 21:06:16 +00:00
bsongis 09a7cc5e03 [stock] Custom prompts not working (thanks Martin for the test!) 2012-10-29 20:30:35 +00:00
bsongis bc3539d777 [all] FSPLASH option added
[stock] +100bytes saved on Voice / Stock board
2012-10-29 19:21:43 +00:00
bsongis c8b51eb063 [all] Silence suppression at begin and end of TTS generated prompts 2012-10-29 19:20:00 +00:00
mhotar@gmail.com 0a531d258f tts_EN - ".0" to ".9" wavs added to all board types
tts_SK(Slovak) added
2012-10-29 18:51:15 +00:00
bsongis 0b01665112 Compilation problem 2012-10-29 14:27:01 +00:00
bsongis bf8bddb147 Python not any more mandatory to compile open9x 2012-10-29 11:03:43 +00:00
mhotar@gmail.com 90dd3e45cd [stock tts_en] decimal point numbers reduced to only one
[stock tts_en] added ".1" to ".9" wavs do reduce delays
2012-10-27 23:48:00 +00:00
ztrojanek@gmail.com 3516845bef Opraveno cislovani potenciometru 2012-10-27 21:07:45 +00:00
ztrojanek@gmail.com 1515062bcf Pots numbering corrected 2012-10-27 20:59:57 +00:00
kjell.kernen@gmail.com bfd95c0345 Fixed error in mode selection string.
Fixed further format problems
2012-10-25 00:27:41 +00:00
kjell.kernen@gmail.com fbd4c1b204 Fixed formating. Increased indent to 2 steps. 2012-10-24 23:14:22 +00:00
kjell.kernen@gmail.com fe81dd7f54 Fixed two problems with missing citation marks. There might be more... 2012-10-24 22:58:00 +00:00
kjell.kernen@gmail.com 36d937e5b3 Update that introduces indentation function and fixes formating that made the file hard to read.
se.h is now row-aligned to en.h i.e. every definition is now found on the same row in both files, which makes it possible to find missing definitions (there were a few).
2012-10-24 22:31:41 +00:00
bsongis 76f7813329 [stock / M128 / gruvin9x] Problem when displaying GVx on AVR 2012-10-24 22:12:02 +00:00
bsongis e144f12cd7 [stock / M128 / gruvin9x] Problem when displaying GVx on AVR 2012-10-24 21:52:50 +00:00
bsongis 30ce636008 [sky9x] Automatic conversion from EEPROM v212 to v213 (not tested) 2012-10-24 20:50:51 +00:00
bsongis 795b48e7c5 [sky9x] Automatic conversion from EEPROM v212 to v213 (not tested) 2012-10-24 20:40:50 +00:00
mhotar@gmail.com 87532ac457 CZ translations - INDENTs 2012-10-24 13:48:45 +00:00
bsongis 20894baf69 Code maintainability 2012-10-24 12:44:57 +00:00
bsongis 6a35d36c0a [stock] Around 110bytes flash saved
[all] EXIT now closes the popup on main views when a GVAR is modified
2012-10-24 07:55:58 +00:00
bsongis f9e64eb2ab GVars in the range -1000 => +1000 2012-10-24 06:13:03 +00:00
bsongis 9e9a273081 es lbm files commited for those who don't have python installed 2012-10-24 05:46:38 +00:00
gruvin@gmail.com 13c867e122 Sorry, I was wrong. I should have test compiled first -- but I can't get it working.
Ignore me please. *sigh*
2012-10-24 04:01:45 +00:00
gruvin@gmail.com 8e772f18b0 SOMEONE CHECK ME ON THIS PLEASE.
I can't compile the current trunk code, due to some Python error. But the fix here is important.

An #ifdefined was found to be in the wrong place in pulses_avr.cpp -- 99.999% certain. Am I right?
2012-10-24 04:00:01 +00:00
bsongis 527517207e Undefined behavior when pressing [MENU] on DR/Expo line 0 2012-10-23 21:11:37 +00:00
bernet.andre@gmail.com c704e7ad12 Promised, I'll check better next time... 2012-10-23 21:01:54 +00:00
bernet.andre@gmail.com a946c0206d Formatting... finally reindented french translation file correctly 2012-10-23 20:58:33 +00:00
bernet.andre@gmail.com 14d58c8d8b Search/replace gone wrong 2012-10-23 20:48:13 +00:00
bernet.andre@gmail.com 8d775abd8b French translations
Some corrections on English strings
2012-10-23 20:44:30 +00:00
bsongis 2565f22cf8 Problème d'affichage à la modification des GVARS 2012-10-23 19:26:23 +00:00
bsongis e4f45398df [all] Spanish language added
[all] Groups / Indentation added in Radio Settings
[all] Rework on GVARS
2012-10-23 17:21:02 +00:00
bsongis 93eafc667a [sky9x] 3 Telemetry screens
[all] Variants
[stock] Around 50bytes flash saved
[sky9x] Date/Time setting problem
2012-10-19 18:48:10 +00:00
bsongis 99283c6ed6 [all] MODS strings removed (unused)
[all] EEPROM variants
2012-10-18 17:45:34 +00:00
bsongis f497c4f9d2 [all] FrSky Telemetry Screen dynamic type
[stock] Popup on main screen when a global variable is modified (in flight)
[all] EEPROM version changed
2012-10-17 19:55:07 +00:00
bsongis b5d110b8ce [all] FrSky Telemetry Screen dynamic type
[stock] Popup on main screen when a global variable is modified (in flight)
[all] EEPROM version changed
2012-10-17 19:45:30 +00:00
bsongis f0d3d9e5dc [all] FrSky Telemetry Screen dynamic type
[stock] Popup on main screen when a global variable is modified (in flight)
[all] EEPROM version changed
2012-10-17 19:37:55 +00:00
bsongis 2f4bc4990f [sky9x] Popup on screen when Global Variables modified
[stock] Flash saving
[gruvin9x] Inflight parameters modification feature removed (replaced by Global Variables, more powerful)
2012-10-16 18:10:40 +00:00
bsongis 7526f4f5b4 [all] Another Global Variables bug fixed (thanks again Gabriel!) 2012-10-16 08:30:19 +00:00
bsongis e52ef22269 [all] Another Global Variables bug fixed (thanks again Gabriel!) 2012-10-16 08:06:57 +00:00
bsongis a57dbf9411 [all] Some Global Variables bugs fixed (thanks again Gabriel!) 2012-10-16 07:59:10 +00:00
bsongis 7663968e44 Assert removed. We don't use this flag for AssignGVx functions 2012-10-15 20:56:08 +00:00
bsongis bca4660742 [all] Now 5 Global Variables available on all boards 2012-10-15 20:13:06 +00:00
bsongis cd995aa975 [all] Global Variables
[X9D] Scroll Bar in all menus
2012-10-15 19:41:19 +00:00
bernet.andre@gmail.com 08c7b2898f French translations 2012-10-15 07:51:00 +00:00
bsongis 993948a521 cz / se translations were badly merged 2012-10-14 08:08:16 +00:00
bsongis 2ce7ac1b2a [all] Registers implementation started (make REGISTERS=YES)
[sky9x / gruvin9x] Date / Time setting splitted into 2 lines (General Setup Menu)
[sky9x] Baudrate moved to the Hardware screen
[sky9x / gruvin9x] SD Manager better implementation
[sky9x] Short / Long switch press used in Function Switches
[sky9x] Bg Music Pause / Resume
2012-10-13 17:55:48 +00:00
romolo.manfredini@gmail.com 63890d63bd Fix issue with backlight in c9x 2012-10-09 23:49:04 +00:00
bsongis e02dd7a751 [sky9x] Issue 142 fixed
[sky9x] Tada was cut
[sky9x] Issue 99 fixed
[sky9x / gruvin9x] Menu popup has now a scrollbar on the right
[sky9x] WDT was not working at all
2012-10-08 21:16:00 +00:00
romolo.manfredini@gmail.com acb7822712 Small fix for coproc read 2012-10-08 15:35:44 +00:00
bsongis d737e314ea Little display error on Jeti 2012-10-07 14:08:34 +00:00
bsongis d7e3c1251e [sky9x/gruvin9x] Lists within Restore Models and Tracks for Function Switches are now sorted in alphabetical order. 2012-10-06 12:17:56 +00:00
bsongis 01e2bcbf3b [stock] Flash saving
[sky9x] Timer > 1hour fixed
2012-10-06 09:52:12 +00:00
bsongis 50616680fa [stock] Flash saving
[sky9x] Timer > 1hour fixed
2012-10-06 09:11:00 +00:00
gbirkus@gmail.com 1085b8b7b2 Manual update 2012-10-05 15:54:55 +00:00
romolo.manfredini@gmail.com e919ffdc6a More coproc info 2012-10-05 12:24:56 +00:00
mhotar@gmail.com fc3dcda4d4 CZ SKY9X related translations 2012-10-05 10:26:50 +00:00
kjell.kernen@gmail.com 7dfcdecb1f Translated latest strings.
Shortened Tidslängd and Fördröjning to fit on screen.
2012-10-05 06:56:02 +00:00
mhotar@gmail.com 2e59961319 Czech translations 2012-10-04 22:01:01 +00:00
bsongis b4b00ecddc [all] Throttle Trace resetted when changing Model
[sky9x] Background music stopped when changing Model
2012-10-04 19:24:16 +00:00
bsongis 2b78b499f4 Some refactoring 2012-10-04 17:24:27 +00:00
bsongis 6ecf3375c2 [stock] 6 bytes flash saving 2012-10-04 15:49:09 +00:00
bsongis 6f395c2563 [all] New translations
[sky9x] More task-stacks sizes
2012-10-04 14:53:12 +00:00
bsongis 28e6e0bd95 [all] Cosmetics 2012-10-04 13:40:30 +00:00
bsongis 580a3c88f5 [all] Cosmetics 2012-10-04 13:38:24 +00:00
romolo.manfredini@gmail.com 48b350a8c2 Coproc related info relocated 2012-10-04 13:22:30 +00:00
bsongis b5a030c9df [all] Code refactoring 2012-10-04 12:41:07 +00:00
bsongis 2efdcf51f0 [all] Menus almost all renamed
[sky9x] Audio refactoring
[sky9x] No hex compiled, it's not needed
2012-10-04 12:08:59 +00:00
bsongis 5d20400f86 [sky9x] Background music 2012-10-03 21:27:32 +00:00
romolo.manfredini@gmail.com fa97e9366d Better coprocessor temperature support 2012-10-03 21:05:56 +00:00
romolo.manfredini@gmail.com b4a9d62b22 Sources for Coprocessor Application 2012-10-03 16:03:25 +00:00
romolo.manfredini@gmail.com 3179dd1d41 Coprocessor temperature support 2012-10-03 15:55:22 +00:00
bsongis f2154feda1 [sky9x] Stack probe
[sky9x] No sprintf (needed heap)
[sky9x] Bug when retrieving available SD audio files
2012-10-02 19:11:22 +00:00
bsongis 36bd3a5caf [gruvin9x] WSHH, FrSky alarms sending was not working. 2012-10-02 17:57:16 +00:00
bsongis f8cfa99547 Warning fixed 2012-10-02 12:25:02 +00:00
bsongis f5d794e4ca Companion9x compilation 2012-10-02 10:26:35 +00:00
bsongis 81c6bb1ba7 Make PCB args are now SKY9X and GRUVIN9X instead of ARM and V4
[sky9x] Temperature calibration
[sky9x] RTC modifications
2012-10-02 10:07:19 +00:00
romolo.manfredini@gmail.com 194c9b7978 init rtc twice to be sure to read current time 2012-10-01 23:31:23 +00:00
romolo.manfredini@gmail.com 190c47e1f4 Add coprocessor info in diagnostic 2012-10-01 22:57:59 +00:00
romolo.manfredini@gmail.com 0ca5c21e6b RTC Support (improved for V4) 2012-10-01 21:42:44 +00:00
romolo.manfredini@gmail.com 8fac78d446 RTC Support 2012-10-01 21:16:24 +00:00
bsongis 002447dbb5 [sky9x] RTC Clock on FAT (not tested)
[gruvin9x] RTC Menu redesigned
[stock] ~50bytes flash saved
2012-10-01 19:58:10 +00:00
romolo.manfredini@gmail.com 18f06e8395 bug fix for date in general menus 2012-10-01 01:45:01 +00:00
bsongis ba9831f52e Cosmetics 2012-09-30 17:49:02 +00:00
romolo.manfredini@gmail.com 32b5f47992 Add coprocessor support 2012-09-30 14:17:22 +00:00
bsongis 5e402bb5a5 Signature in backups was wrong! 2012-09-29 05:15:17 +00:00
bsongis 702b956a2d [simu] SD Card Manager hanged 2012-09-28 22:28:15 +00:00
bsongis 733682a51a Compilation errors fixed 2012-09-28 22:02:35 +00:00
romolo.manfredini@gmail.com 81d37a96dd Fix compilation issues in companion 2012-09-28 19:20:57 +00:00
bsongis deabf40080 [sky9x] SD Info showed a wrong size 2012-09-28 17:33:22 +00:00
bsongis c40191d3bc [sky9x / gruvin9x] Popup during format 2012-09-28 17:22:49 +00:00
bsongis 121c41719d [sky9x] All fields in SD info submenu now displayed
[sky9x] Model Backup / Restore should be ok
[sky9x] SD unmounted when USB masstorage
[sky9x / gruvin9x] Header added to Model Backups
[sky9x / gruvin9x] Log file closed when Logging function stopped
+ Cleaning session
2012-09-28 16:02:13 +00:00
bsongis d8be36e2f4 [sky9x] SD speed should be better 2012-09-27 21:13:25 +00:00
bsongis ad4f4e7e09 [gruvin9x] Didn't compile since last changes 2012-09-27 20:42:21 +00:00
bsongis f66f016c0d [sky9x] SD and Masstorage for testing ... 2012-09-27 20:41:13 +00:00
romolo.manfredini@gmail.com dc53114edf Log WSHH altitude 2012-09-26 22:23:33 +00:00
bsongis 0986ecd66d [sky9x] Warning when format fails 2012-09-26 05:10:12 +00:00
bsongis fd31fc1dd5 Simu compilation error 2012-09-26 05:09:30 +00:00
bsongis 9327d5d2c0 [sky9x / gruvin9x] SD File Manager bugs 2012-09-25 17:56:23 +00:00
bsongis fa10615077 [sky9x] SD Format working? 2012-09-25 14:03:00 +00:00
bsongis b19386d8a7 [sky9x] SD Mutex again 2012-09-25 13:39:33 +00:00
bsongis b2818b6b22 [sky9x] Logs closed when model changed 2012-09-25 10:15:43 +00:00
bsongis 6d3bec464a [sky9x] Initialization of log file added for tests 2012-09-25 10:14:53 +00:00
bsongis a046a8723e [sky9x / gruvin9x] Files in SD Manager sorted alphabetically
[sky9x / gruvin9x] Format function added into SD Manager
2012-09-25 09:16:09 +00:00
bsongis 5522b7ca78 [sky9x / gruvin9x] Issue 141 fixed 2012-09-25 07:40:46 +00:00
bsongis c5903d2689 [sky9x] Revert to r1398 for Peter's tests 2012-09-24 20:01:42 +00:00
bsongis b332e0d287 [sky9x] Revert to r1398 for Peter's tests 2012-09-24 19:49:19 +00:00
bsongis 1d71b15914 [sky9x] Revert to r1398 for Peter's tests 2012-09-24 19:34:57 +00:00
bsongis 9cc2ee171c [sky9x] Revert to r1398 for Peter's tests 2012-09-24 19:12:32 +00:00
bsongis 51491381ce [sky9x] Rotary encoder should be enable 2012-09-24 06:28:14 +00:00
bsongis 22ee458db5 Logs on simu 2012-09-24 06:18:20 +00:00
bsongis fd546d3370 Cosmetics 2012-09-24 06:17:49 +00:00
romolo.manfredini@gmail.com 0d4c3d761b fix shift in strings 2012-09-21 23:33:46 +00:00
bsongis bfa043a175 [all] Remaining printf (thanks Peter!) 2012-09-20 18:05:34 +00:00
bsongis b3f2197371 [all] Remaining printf (thanks Peter!) 2012-09-20 18:04:08 +00:00
bsongis 77c87e5da3 [stock] around 200bytes flash saving
[all] WSHH used for vario - not tested at all
[all] correction for d>=ofs used with timers
[sky9x/gruvin9x] SD needs 2/3 files opened in the same time
[sky9x] low speed SD when high speed not allowed
2012-09-20 17:50:52 +00:00
bsongis 2fa4a6bb3f [sky9x] Problem on Backup of (old) models whose size is greater than actual size 2012-09-20 07:38:06 +00:00
bsongis 3a9c375908 [sky9x] Revert to last version where massstorage was ok for all SDs!
[stock] Flash saving
[stock] Voice mod port from er9x
2012-09-19 22:15:20 +00:00
gruvin@gmail.com 9a7976cf6e Issue 133 resolved. (DBLKEYS now working on G9Xv4 board.) 2012-09-19 09:12:18 +00:00
gruvin@gmail.com 3cfed9b80c Corrected IN_P* references to correct names, INP_L* (G9X v4 board).
No other changes.
2012-09-19 07:10:06 +00:00
bsongis 77bfa1dc2a Issue 135 fixed (to be tested!) 2012-09-18 21:52:26 +00:00
bsongis 324a0c4b77 [all] Issue 140 fixed 2012-09-18 21:42:31 +00:00
bsongis 03ff032ec7 [sky9x] SD Init moved after USB detection for bootloader 2012-09-18 21:30:04 +00:00
bsongis 622bc9bef0 companion9x compilation with latest open9x changes 2012-09-18 21:10:39 +00:00
bsongis 3c095ad5e9 companion9x compilation with latest open9x changes 2012-09-18 20:57:47 +00:00
bsongis 7c3a4d3863 [sky9x] Massstorage again!
[sky9x] More SD cards allowed
[X9D] Makefile for simu with 192x64 LCD
2012-09-18 19:45:24 +00:00
mhotar@gmail.com b2e29e911f Minor CZ translations fix 2012-09-18 19:42:11 +00:00
mhotar@gmail.com 92d45358e3 tts.py - milliamp-hours corrected
Mixer menu- separated label for DR/Expo added
DE,SE -2nd collumn shifted in Mixer layout
2012-09-17 21:19:03 +00:00
kjell.kernen@gmail.com a2b404090a Translated latest strings to Swedish.
Made minor adjustment to abreviation of FlygFaser
2012-09-17 14:25:15 +00:00
bsongis 3245de0446 [sky9x] Massstorage: status bar 2012-09-16 12:10:30 +00:00
bsongis 548953623b [sky9x] Massstorage: command 0x1B added (quick & dirty) 2012-09-15 17:38:45 +00:00
bsongis 0b70b3c052 Companion9x warning 2012-09-15 12:41:45 +00:00
romolo.manfredini@gmail.com 6cdb3b7b2c Fix issue 90 in companion 2012-09-14 23:57:26 +00:00
bsongis dd87ac6514 [sky9x] SBC commands were not packed under gcc. A test is needed! 2012-09-14 21:29:56 +00:00
bsongis bed2f6eb5e [sky9x] Massstorage again (format / umount still not ok) 2012-09-14 18:44:56 +00:00
bsongis 0a1fa6bd7d [all] Menus fix (some parameters not correctly saved in EEPROM since last flash saving) 2012-09-14 18:43:02 +00:00
bsongis 89cf4016b7 [sky9x] When alarms raise (temperature and consumption), it's displayed on main screen in place of voltage 2012-09-14 18:41:58 +00:00
bsongis 1e69cfa94a [stock] Volume mod: volume was not set at Tx startup 2012-09-14 18:38:32 +00:00
bsongis 956d034fdc [sky9x] Some cleaning 2012-09-13 06:58:00 +00:00
bsongis 4283acac4f Issue 134 fixed 2012-09-13 06:44:27 +00:00
bsongis 2e0a7a293e [sky9x] Massstorage (read seems ok, write has bugs) 2012-09-12 18:31:11 +00:00
bsongis 46a0fe8533 [sky9x] Massstorage (still not working, but we see the drive) 2012-09-12 05:30:06 +00:00
bsongis fcf6f436b0 [sky9x] Massstorage (not finished at all!)
[stock] 180bytes flash saved
2012-09-11 19:58:49 +00:00
bsongis 91fbcb94d7 2012-09-11 19:37:58 +00:00
gruvin@gmail.com aedc89fccd Changed " RANGE<range" to simply "RANGErange". It looks better and its still
pretty obvious that the 'lower' case range indicates 'low' range.
2012-09-09 20:44:03 +00:00
bsongis 65cb5ec9e6 Simu compilation problem 2012-09-09 18:39:58 +00:00
bsongis f72926fb74 [sky9x] Compilation problem 2012-09-09 17:36:25 +00:00
romolo.manfredini@gmail.com 993eba0af5 Fix string shifting 2012-09-09 13:17:48 +00:00
romolo.manfredini@gmail.com 2b27f24260 Some bytes saving 2012-09-09 12:48:59 +00:00
bsongis 9144776fba [stock]14bytes saved 2012-09-08 22:10:30 +00:00
bsongis 95bb18a311 [stock]6bytes saved 2012-09-08 21:53:21 +00:00
bsongis 60eecd928d [stock]20bytes saved 2012-09-08 21:42:08 +00:00
bsongis 7f401d9155 Around 30bytes saved 2012-09-08 21:29:35 +00:00
bsongis 3b319d1aa5 [stock] 10bytes saved ... 2012-09-08 19:49:52 +00:00
bsongis e9fe881c17 More delay for SD-CARD 2012-09-08 14:20:37 +00:00
bsongis 18f1c6e620 Weak USBD_IRQHandler 2012-09-08 14:16:49 +00:00
bsongis 60936211ae MASSSTORAGE was enabled! 2012-09-08 14:09:23 +00:00
bsongis 03a1517531 [sky9x + gruvin9x] Remanent timers
[sky9x] Timer since last charge
[sky9x] Massstorage (not working at this moment)
[sky9x] Debug Thread
[stock] Flash saving
2012-09-08 13:49:51 +00:00
romolo.manfredini@gmail.com fdb2b937f1 fix compilation issues for PXX protocol 2012-09-08 12:46:49 +00:00
romolo.manfredini@gmail.com 772b8318ec Byte save when PPM_LIMITS_SYMETRICAL is not defined 2012-09-08 09:05:09 +00:00
gbirkus@gmail.com 1185443850 fix for TH% in issue 121 2012-09-07 14:14:30 +00:00
bsongis f22f207242 [stock] Voice mode: more delay before checking for busy 2012-09-07 10:39:46 +00:00
mhotar@gmail.com 3ab2e20a5e tts.py - foot/feet corrected 2012-09-05 06:29:36 +00:00
mhotar@gmail.com a24a8736b1 TTS_EN - floats and units added. New EN wavs required! 2012-09-04 20:57:55 +00:00
gbirkus@gmail.com 6e3152633b copy paste translation fix for issue 69
Fr an Se translation need to be updated
2012-09-04 20:40:56 +00:00
gbirkus@gmail.com ad54506f86 issue 69 T-Cut template replaced to Sticky-T-Cut 2012-09-04 20:31:23 +00:00
bsongis d7226f5e61 Trims/Keys should be correctly displayed in DIAG screen 2012-09-04 16:17:24 +00:00
bsongis 485a96745d Issue 82 fixed (partially, I don't like too much the vertical lines, the screen is too little for that) 2012-09-04 15:29:25 +00:00
bsongis c0577e77df Issue 125 fixed. Only english done. Translations responsibles will decide what they prefer to do in their own language ;) 2012-09-04 15:02:06 +00:00
bsongis e42fb6da31 Issue 121 fixed 2012-09-04 14:51:32 +00:00
bsongis 7a6e800c8a [sky9x] Compilation problem 2012-09-04 14:28:18 +00:00
bsongis efe50710c4 Issue 91 fixed 2012-09-04 12:37:18 +00:00
bsongis bd341d1590 DBLKEYS again 2012-09-04 12:32:38 +00:00
bsongis 5f8ddf88e4 DBLKEYS again 2012-09-04 10:39:40 +00:00
bsongis 9fc5401ff2 DBLKEYS again 2012-09-04 10:19:59 +00:00
bsongis bd2def4d4d [sky9x] Issue 111 fixed
[stock] 120bytes saved with DBLKEYS option
2012-09-04 10:09:35 +00:00
bsongis fddbe300a1 Issue 127 fixed 2012-09-04 08:54:27 +00:00
bernet.andre@gmail.com 9ee908957b Missing strings for issue 91 2012-09-04 08:35:27 +00:00
bsongis eac6950994 c9x compilation problem 2012-09-04 08:06:52 +00:00
bsongis 05a55c728b Issue 96 fixed 2012-09-03 23:26:05 +00:00
bsongis c7228194df [sky9x] It was impossible to select UpperCase in names 2012-09-03 23:19:48 +00:00
bsongis 0df8509289 Issue 120 fixed 2012-09-03 22:39:14 +00:00
bsongis 9da2ce3ac4 Issue 91 fixed
[sky9x] More than 256 lines allowed in menus (SD files list)
2012-09-03 22:25:20 +00:00
bsongis acfb88ac7b Issue 34 better fix
Issue 126 fixed
2012-09-03 20:52:39 +00:00
bsongis 88b5b8f82c Issue 101 fixed 2012-09-03 18:26:53 +00:00
bsongis d9cb411c12 Issue 34 fixed
Issue 101 fixed
2012-09-03 18:13:55 +00:00
bsongis 9dc1a1fa53 [all] Current consumption measured from A1/A2 was wrong 2012-09-03 08:55:36 +00:00
bsongis f4c52723d7 Dead test code removed 2012-09-03 06:23:24 +00:00
bsongis 1bd590195f [sky9x] Bug in SD Init fixed. Temperature alarm added. 2012-09-02 21:00:22 +00:00
bernet.andre@gmail.com 5ddc88d8a4 svn oddity? - shows it in the changes on google code, but isn't in the file... 2012-08-31 14:21:07 +00:00
bsongis 5712b03bca Atmega 128 support 2012-08-31 13:21:09 +00:00
mhotar@gmail.com fee65d8ae5 Czech translations
Mixer layout 3rd column
2012-08-31 12:56:14 +00:00
bsongis 57f4a5ff97 Issue 123 fixed 2012-08-31 12:04:31 +00:00
romolo.manfredini@gmail.com 97f3d832ac Fix for bugs in italian voices 2012-08-31 00:43:16 +00:00
romolo.manfredini@gmail.com 02c6edacbe Fix for TTS=IT 2012-08-30 23:42:59 +00:00
bsongis 461ed960ce Issue 122 fixed 2012-08-30 17:13:26 +00:00
bsongis d6b3416f7b Inactivity alarm not quick enough 2012-08-30 14:46:24 +00:00
rob@marotori.com c4149407e3 fix to beep sounds. 2012-08-30 10:49:09 +00:00
rob@marotori.com 8be25ddbc7 Compile time ifdefs to allow ARM to compile with SDCARD disabled. 2012-08-30 10:27:18 +00:00
bernet.andre@gmail.com a5602535aa French translations 2012-08-30 07:40:12 +00:00
bsongis 64d5bba3d7 16bits are needed on sky9x for the freq of audio tones! 2012-08-29 22:42:46 +00:00
bsongis 665830cf82 [sky9x] SD initialization reworked! 2012-08-29 21:56:28 +00:00
bsongis 3223b890ad Problem with d>ofs A1 [negative ofs] 2012-08-29 15:18:32 +00:00
bsongis 60c3d2f3ae [sky9x] System files not played (not retrieved during initialization) 2012-08-29 15:02:27 +00:00
bsongis e54ba36d4c [stock with voice mod] 1.5s initialization time for the module 2012-08-29 14:38:30 +00:00
bsongis 50360ee6a7 [sky9x] Problem with Flight Phases selection Mixer Edition 2012-08-29 14:37:49 +00:00
bsongis eeb150f377 Cosmetics 2012-08-29 12:49:44 +00:00
rob@marotori.com 6b660b4af7 Update to work around issue 80 - better solution to be proposed shortly. 2012-08-29 12:39:31 +00:00
mhotar@gmail.com 4407071146 tts_cz UNIT_DB to UNIT_DBM 2012-08-29 06:35:25 +00:00
bsongis db3bd97935 Code factorization 2012-08-28 20:54:36 +00:00
bsongis ce34047e12 [ersky9x] Bluetooth FrSky proxy added (ported from ersky9x, still untested, not part of the release) 2012-08-28 18:42:46 +00:00
mhotar@gmail.com 6606ed07d1 tts_cz case M/Z/S 2012-08-28 17:27:10 +00:00
bsongis 401ec8d370 The Radio Setup Menu was badly displayed when STOCK board + VOICE Mod (problem with the cursor in the last lines) 2012-08-28 17:11:25 +00:00
bsongis 0c43ff8882 Issue 118 fixed
Another fix for SDcard setup on ersky9x board which should be quicker to initialize.
2012-08-28 13:39:22 +00:00
mhotar@gmail.com 839ee83a6b Czech lang. updated tts.py and tts_cz.cpp 2012-08-28 12:54:15 +00:00
bsongis fbc95a04da ONm on stock board fixed
2s initialization time for voice module on stock board
2012-08-28 12:38:35 +00:00
bsongis 642b3bf2a9 Issue 109 fixed 2012-08-28 10:40:25 +00:00
bsongis 323329eeca Issue 109 fixed 2012-08-28 10:39:39 +00:00
bsongis 0dac1386ec Problem with timers after 10 seconds
Warning removed
2012-08-28 10:14:24 +00:00
bsongis c08302ecb5 RX, TX say dB
Rpm say "turns per minutes"
AccXYZ say "g"
Hdg say degrees
VSpd say  m/s
Alt- say meters
Alt+ say meters
Rpm+ say "turns/minure"
A1/A2 and A1-/A2- say the chosen unit
A1- and A2- say the right value
2012-08-28 08:10:46 +00:00
bsongis b8449a42db Issue 110 fixed 2012-08-28 06:44:03 +00:00
gruvin 43542c9d9f Makefile -- hopefully this time I did it way that will work for every one.
(Thanks yet again Bertrand for telling me how.)
2012-08-28 03:10:58 +00:00
romolo.manfredini@gmail.com f1abf9a8c8 Italian tts fixes 2012-08-27 22:39:47 +00:00
bsongis dd230b7e5a Issue 117 part 2 fixed 2012-08-27 21:40:38 +00:00
bsongis d8ba7a577b Issue 117 fixed 2012-08-27 21:17:23 +00:00
bsongis f47692a258 All python file(...) converted to open(...) 2012-08-27 20:26:21 +00:00
mhotar@gmail.com 2fac92a843 tts.py system prompts added to EN,CZ 2012-08-27 20:14:40 +00:00
bsongis 6c323f6f0c Compilation problem with ARM board 2012-08-27 19:43:04 +00:00
mhotar@gmail.com c3ef8e7d44 tts.py cz system sound fix 2012-08-27 17:42:01 +00:00
bsongis 295bd75b96 Issue 113 fixed (size of TMP file not written correctly) 2012-08-27 16:31:07 +00:00
mhotar@gmail.com 7aff9f1077 tts_cz float numbers <0 2012-08-27 16:07:22 +00:00
bsongis 1a34b150e8 Use of the pcm_u8 codec for stock board with voice module
Instead of "ad4" option there are now arm / v4 / [stock]
2012-08-27 15:46:54 +00:00
gbirkus@gmail.com 6e857556f5 PlayTrack values from 256 to 511
documentatinon and wiki update
2012-08-27 15:41:29 +00:00
bsongis 606619910f Italian system sounds were wrong 2012-08-27 15:33:31 +00:00
bsongis 2fcc6a36ef Negative float numbers badly played in french (thanks Martin!) 2012-08-27 15:11:32 +00:00
bsongis ef65a16850 Issue 114 fixed 2012-08-27 14:38:15 +00:00
bsongis 6cd1d6283b Issue 116 fixed 2012-08-27 13:49:26 +00:00
bsongis 6829a94516 Volume not adjusted using a custom prompt on SOMO-14D 2012-08-27 13:29:21 +00:00
bsongis c14da4fdbe [MENU long] on a switch in Function Switches screen converts a screen to his correspondant momentary switch (THR <=> THRm, !THR <=> !THRm) 2012-08-27 13:27:07 +00:00
bsongis 77571bd9cd Associate an ID to each set of prompts played by Function Switches so that if the ID is present in the prompts queue, it is not queued again. 2012-08-27 13:24:45 +00:00
bsongis 9960e84d2d Some parts reverted in pulses_avr.cpp
Bryan would you confirm it's ok on v4?
2012-08-27 09:49:00 +00:00
mhotar@gmail.com d5bf3a6b82 tts_cz FP numbers <0 not played correctly 2012-08-27 09:09:02 +00:00
gruvin@gmail.com 2f7f0806dc IMPORTANT: PPM/DSM2 protocols BROKEN for several revisioins before this one.
WARNING: All protocols shoul dbe testing on stock board again.

Fixed a number of problems relating to the (dis)enabling of hardware 
switched PPM_OUT for the G9XV4 board. I also broke a lot of stuff along 
the way over several previous commits, as I slowly learned how all the 
code went together and the 'whys' for some stuff. My bad.

In other words, this commit finally has DSM2=PPM mode working on the 
G9XV4 board without breaking a bunch of other stuff -- hopefully.

!! STOCK BOARD TESTING NEEDED !!
I am pretty sure I have not broken anything for the stock board code -- 
BUT it MUST be tested before the next release, because I have made quite 
a few changes in and around that code.
2012-08-26 23:18:44 +00:00
bsongis 2bd7cfae95 Issue 108 fixed 2012-08-26 20:47:03 +00:00
bsongis 0c20942573 Issue 112 fixed (thanks Baptiste!) 2012-08-26 20:42:19 +00:00
bsongis 403c36e35e Companion9x compilation 2012-08-26 12:05:49 +00:00
gruvin@gmail.com 2bb2654e05 Revised some of my code comment is all. No code changes. 2012-08-26 10:38:13 +00:00
mhotar@gmail.com 007f15b1ee CZ translations updated 2012-08-26 07:53:31 +00:00
gbirkus@gmail.com 9a73530bb7 English user guide update by Zdenek Trojanek 2012-08-24 20:20:30 +00:00
gruvin@gmail.com dd09df994c Changes to DSM2=PPM code to hopefully fix bind and rangecheck lock-on bugs. 2012-08-24 09:08:28 +00:00
gruvin@gmail.com bdf5ef4e0d Fixed bug in DSM2=SERIAL, introduced in previous commit. Does not affect DSM2=PPM.
(Tested it properly this time before committing! Sheesh.)
2012-08-24 02:31:09 +00:00
gruvin@gmail.com e193963c93 LPXDSM2, DSM2only, DSMX protocol differences taken from DSM2=PPM code and
added to DSM2=SERIAL code.

Hopefully also fixed DSMX mode bind omission from previous commit. 

IMPORTANT: I do not have a DSMX module for testing -- only DSM2. Can someone 
with DSM2=PPM mode and DSMX please test and confirm that both bind and range 
check mode are working. Thanks.
2012-08-24 02:10:43 +00:00
gruvin@gmail.com 51b297b46f re r1260 comments (bernet.andre) DSM2=PPM needs testing BIND & RANGECHECK.
I have modified the DSM2=PPM code to implelent bind and range check the
same way as for DSM2=SERIAL.

NOTE: I have checked for clean compile but do not have hardware to test
that the protocol is working correctly. PLEASE TEST. Thanks.
2012-08-24 01:57:00 +00:00
bsongis 04b90dd9d2 sdInit() called inside a CoOS thread. 2012-08-23 22:00:33 +00:00
bsongis 894f78427e [sky9x] Protection against USB detection in flight due to temperature... 2012-08-23 21:40:29 +00:00
gruvin@gmail.com c16af175aa Nope. That's still wrong. I suck at this.
Reverted to original.
2012-08-23 04:46:58 +00:00
gruvin@gmail.com 328e322edf My Makefile logic last commit was wrong. Now fixed.
"When I grow up, I'm gonna be a _real_ programmer! :P"
2012-08-23 04:44:38 +00:00
gruvin@gmail.com d4685c9e4e A better way to cancel DSM2 range-check mode on [EXIT long]. Thanks Bertrand (again!). 2012-08-23 01:53:25 +00:00
gruvin@gmail.com 3b4c9412a1 A better Makefile fix for my LLVM compiler. Thanks Bertrand. 2012-08-23 01:47:38 +00:00
gruvin@gmail.com 55dc92a6f2 IMPORTANT: Someone needs to double-check stock board PPM/16/sim still works!
Tidied up Timer1 ISR code -- numerous little issues resolved, comments corrected.

Obviously, anything to do with this ISR requires thorough physical testing.
I have tested DSM2_SERIAL and the PCBV4 PPM_out is working properly. Someone
should double-check PPM/16/sim and I guess DSM2=PPM, on the stock board.
Thanks.
2012-08-23 00:51:35 +00:00
gruvin 65591dda63 Removed debug comment. My bad. G9XV4 SD card functions working again. 2012-08-22 13:14:06 +00:00
bsongis 00bb1e70e4 Compilation issue (ARM) 2012-08-22 11:43:07 +00:00
gruvin@gmail.com 84513c8c0e So I don't accidentally forget that I've edited Makefile and
commit it broken.
2012-08-22 11:33:45 +00:00
gruvin@gmail.com 12cb97b88c Mostly just comment edits and a little code tidying. 2012-08-22 11:23:08 +00:00
bsongis 0727523472 Issue 87 fixed 2012-08-22 10:38:54 +00:00
romolo.manfredini@gmail.com bd56fcab06 fix for compiling in companion 2012-08-22 09:08:09 +00:00
gruvin@gmail.com 80b63a9d37 Issue 105 -- DSM2 range check mode completed.
However, I don't like that the only place I could find to turn off range check mode when the SETUP menus is exited, was in popMenu ...

void popMenu()
{
  if (g_menuStackPtr>0) {
#ifdef DSM2
    s_rangecheck_mode = 0;
#endif
    ...
}

It was the only way I could find to trap the event of [EXIT long] being pressed 
while in the RANGE field and s_editMode==true. But this solution gets executed
for all menu exits -- not just menuProcModels. It works, but there must be a
more eloquent method?
2012-08-22 07:09:27 +00:00
gruvin@gmail.com d6690cbb01 Finally figured out how to add a warning tone for DSM2 range check mode.
(It only took me about an hour and a half! :-/)

Also increased max filename length handled by "Restore Model" to 16 chars
(only when long filename support is configured in FatFs/ffconf.h)

Bertrand: I had to comment out a call to sdPollmS() as it doesn't seem to exist.
Hopefully the system freeze when I try to select "Restore Model" is
just a symptom of this same issue ... though I fear not.
2012-08-22 05:18:20 +00:00
bsongis bf2055e1ad Issue 83 fixed
Problem with wav files played twice when loading a model
Different EEPROM format for Expos/DRs on ARM
Issue 102 fixed
2012-08-21 20:54:48 +00:00
bsongis 223c0645e8 Different EEPROM format for Expos/DRs on ARM 2012-08-21 12:15:01 +00:00
bsongis 76ea24e62c Better correction for issue 95 2012-08-21 11:45:04 +00:00
romolo.manfredini@gmail.com 0e7c08ba15 Fix overflow in calculations 2012-08-20 23:27:56 +00:00
mhotar@gmail.com 196de34b27 Czech prompts added to tts.py
I had to change encoding from latin-1 to utf-8 in subprocess.Popen
Can someone check it please?
2012-08-20 21:26:04 +00:00
bsongis ae5d7c8952 Fix simu compilation errors
Issue 82 first try with #define FRANCK in main_views.cpp
2012-08-20 20:44:43 +00:00
bsongis 511f5b8338 Fix compilation errors 2012-08-20 18:57:50 +00:00
bsongis c2563ca816 Custom prompts now start at 256 (stock / gruvin boards) 2012-08-20 15:56:36 +00:00
bsongis f9a2cec8b1 Issue 100 fixed 2012-08-20 15:45:58 +00:00
bsongis a4238e0b11 Flight phases inverted in DR/Expos calculations 2012-08-20 15:45:37 +00:00
bsongis 96a2f9a32a Issue 95 fixed (but I still don't know why it works with this fix...) 2012-08-20 15:44:51 +00:00
mhotar@gmail.com 346f4b4c20 Voice for custom board - sound volume 0x1F0-0x1F7
PROMPT_CUSTOM_BASE changed to 256
Sound volume menu shifted below SPEAKER_PITCH
2012-08-20 12:40:15 +00:00
bsongis 2fcad17aaa FrSky flash saving 2012-08-20 12:31:15 +00:00
bsongis 2f423f73a0 Issue 92 fixed (saves 114bytes flash) 2012-08-20 11:56:23 +00:00
gruvin@gmail.com 01fcc62e64 DSM2 Range Check (half) implemented in model SETUP protocol setting.
Half -- because I don't yet know how to make warning sounds in this 
new code. HELP! :P

... otherwise it's working. I have confirmed that
the range check bit appears on the scope, while watching the DSM2
data stream.
2012-08-20 07:42:31 +00:00
gruvin@gmail.com 5b26647c30 Wordy comments replaced by issue reference. 2012-08-20 05:35:36 +00:00
gruvin@gmail.com de7a8c800b DSM2 Bind Mode Fix -- Issue 98
Some DSM2 modules take longer than others to power up. Thus, sending a 
single BIND packet is not sufficient in some cases. I have implemented
here an approimately 4 second period (after power-up) during which
time the trainer swtich can activate BIND mode.

This is in fact not strictly needed, since the DSM module will by
itself reject bind packets after a short time. (I have confirmed this
    again with my DSM2 module today.) However, we like to be sure, so the
limited time window for BIND activation remains.

The word "BIND" also now appears as confirmation in upper-right of 
the main view, whenever bind packets are being sent to the DSM module.

(I did not consider it important to add this "BIND" word to the 
 language files. Please feel free to do so though, if warranted.)

Gruvin.
2012-08-20 05:06:31 +00:00
mhotar@gmail.com 14598e9d59 Voice on stock- 0xF0 to 0xF7 changes sound volume only so countdown sounds works
CZ translation fix for mix slowdowns
2012-08-19 21:48:09 +00:00
bsongis a4e7ecca55 Differential now have a 1-step instead of 2-steps! 2012-08-19 19:51:08 +00:00
bsongis 6bba0a5311 New option DBLKEYS
Flash saving
Issue 86 fixed (could be made an option in the future)
2012-08-19 16:56:43 +00:00
bsongis de18436cda Issue 93 fixed
Flash saving.
2012-08-18 21:10:51 +00:00
romolo.manfredini@gmail.com 08c24d0ffb fix small switch bug in flight phases 2012-08-18 19:37:11 +00:00
romolo.manfredini@gmail.com 7f630f4781 recover 2 bytes of flash (better than nothing) 2012-08-18 19:06:24 +00:00
bsongis f824c6c83c Bug fixes + volume on stock board with VOICE mod
Flash savings
FrSky alarms sending now ok on ARM board
2012-08-18 16:57:18 +00:00
bernet.andre@gmail.com cae265b05c French translations 2012-08-18 12:26:44 +00:00
romolo.manfredini@gmail.com fd2ad2121f Memory save 2012-08-18 11:36:41 +00:00
gruvin bec173556d Stripped ^M (CR's) from end of all lines in board_gruvin9x.cpp
(Serves as first test commit for me, also.)
2012-08-18 11:35:08 +00:00
bsongis 640a4c21dc Correction for M$ VC++ which doesn't like mixing 16bits and 8bits bitfields... 2012-08-18 10:21:08 +00:00
gbirkus@gmail.com 7d520e08af Power divided by 10 when voltage is A1 or A2. 2012-08-17 19:40:25 +00:00
bsongis a46a2c8756 Telemetry bug fixes 2012-08-17 16:55:56 +00:00
bsongis 83fe77fa8e MixData phases is now inverted to save some flash (thanks Romolo)
Comment on DSM2 fixed in Makefile (thanks Bryan)
Bug fixed in TELEMETRY menu
2012-08-17 09:34:38 +00:00
bsongis 36c981d55f Issue 65 fixed
Flash saving
2012-08-16 20:33:55 +00:00
bsongis dc091c121f Templates with curves broken 2012-08-16 18:51:54 +00:00
bsongis 0faa35ab97 Bug in differential / ersky9x 2012-08-16 15:23:20 +00:00
bsongis debbff51e0 Issue 66 fixed: PPM_LIMITS_SYMETRICAL Makefile option added (pls tell me if not the right name)
RSSI Tx and Rx before A1 and A2
Rotary Encoder on ersky9x board
A Mix may be defined in many Phases (idea from Romolo, thanks!)
Differential is now a Curve (private Curve of a Mix)
Issue 56 fixed (native stick as Mix input)
EEPROM saving (LimitData structure)
Issue 79 fixed (Audio Queue)
Trims now working in ersky9x simu
2012-08-16 14:06:38 +00:00
bsongis 78823788b4 Issue 81 fixed 2012-08-14 20:00:17 +00:00
mhotar@gmail.com eda268518b putVoiceQueueUpper cleanup for TTS_CZ 2012-08-14 19:40:18 +00:00
gbirkus@gmail.com 8c8b40f5a8 English manual thanks to Zdeněk Trojánek 2012-08-14 19:07:41 +00:00
bsongis ea112520ea tts python script updated for the new prompt numbers 2012-08-14 17:41:59 +00:00
bsongis 24c36f3184 Code cleaning around KILRAH_OFS / FRANCK #define for one of the next code change.
Now we need to decide:
- a compile option?
- a per model option?
- a per channel option?
The per channel option is ok, we have one bit left per channel in limits (we even will save 8bits for each channel if this is the chosen option)
2012-08-14 17:41:20 +00:00
bsongis 8f103ecee3 Different numbers for Voice Prompts
Diff functions in Custom Switches
2012-08-14 17:09:03 +00:00
romolo.manfredini@gmail.com b94b11d466 Fix for rotary encoder button on ARM board 2012-08-14 10:26:45 +00:00
mhotar@gmail.com ec1df22130 TTS_language defined
tts_cz fixed to play 0.0x numbers correctly
CZ system and custom promts shifted to 260+
2012-08-13 20:15:44 +00:00
bernet.andre@gmail.com ddfc9f9e17 Issue 77
Label change for clarity
2012-08-13 10:34:20 +00:00
bernet.andre@gmail.com 9186bfa3af Alternative test code for subtrim behavior, see first lines of open9x.cpp 2012-08-13 09:48:06 +00:00
bernet.andre@gmail.com 961fa24faa "Franck code" bug 2012-08-13 08:35:03 +00:00
bsongis 8c5dd2b0d9 Small fix for Mix delays when the switch is toggled before the delay is expired
Test code for Franck (have a look to open9x.cpp, in the first lines)
2012-08-13 07:49:56 +00:00
bernet.andre@gmail.com 0f5e855849 PPM +/- polarity display was swapped 2012-08-12 08:57:35 +00:00
bsongis 0eee68144d Issue 53 fixed
Issue 75 fixed
2012-08-11 20:08:58 +00:00
bernet.andre@gmail.com 5697f4aa72 French translations 2012-08-11 18:33:21 +00:00
bsongis 3fd77ab737 Issue 73 fixed
Issue 74 fixed
2012-08-11 13:22:55 +00:00
bsongis e84ece8055 Issue 67 fixed (comma missing!)
Issue 63 fixed (InstantTrim, Trims2Ofs to double check before release)
Issue 68 fixed (better names for vario sources)
[gruvin] 2 digits for voltage calibration
2012-08-10 20:34:33 +00:00
bsongis 9574eadd44 Another warning removed (thanks Bryan!) 2012-08-07 10:26:13 +00:00
bsongis 86c127b5f4 Warning removed (thanks Bryan!) 2012-08-07 10:22:10 +00:00
mhotar@gmail.com bcec714aa0 tts_cz base numbers extended to 0-99,100,200 .. 900 2012-08-02 19:26:41 +00:00
mhotar@gmail.com ab1a87ecbf tts_cz Units , zero and decimal values 2012-08-01 22:19:32 +00:00
bsongis 50234fde13 Safety function was wrong with negative numbers 2012-08-01 14:15:21 +00:00
kjell.kernen@gmail.com 9510721ef4 Translated the newest string entries into Swedish 2012-08-01 07:53:08 +00:00
romolo.manfredini@gmail.com 0796cda8c9 comment cleanup 2012-07-31 22:10:06 +00:00
romolo.manfredini@gmail.com 9f0f9f93a2 small fixes 2012-07-31 22:02:25 +00:00
mhotar@gmail.com 1cfffd8d45 tts_cz modified
Numbers and Duration work, Units still needs to be finished
2012-07-31 18:40:47 +00:00
bsongis 07ddcd1758 Issue 59 fixed 2012-07-31 16:48:04 +00:00
bsongis bedce98a14 companion9x compilation pb on the mac 2012-07-28 21:23:40 +00:00
mwm@mired.org 3d6a1dd621 Add install target to Makefile. 2012-07-28 21:14:49 +00:00
bernet.andre@gmail.com a62cfe7016 French translations 2012-07-28 16:11:37 +00:00
romolo.manfredini@gmail.com abd3917bc8 Italian translations 2012-07-28 10:34:15 +00:00
bsongis 386be4c44b [ersky9x] Powering with USB with an invalid EEPROM erased parts of the EEPROM ... 2012-07-28 08:39:15 +00:00
bsongis 36c1e9cb1d Ignore list updated 2012-07-27 19:59:17 +00:00
bsongis 0674958659 c9x compilation error 2012-07-27 18:11:30 +00:00
bsongis 2a73d29b4b Bug in expo curves 5-8 2012-07-27 18:08:39 +00:00
bsongis 45a570fb86 Ignore list updated 2012-07-27 18:06:17 +00:00
bsongis 174a7b29d9 [ersky9x] Radio blocked on start when playing a sound before SD card initialization end. 2012-07-27 17:52:03 +00:00
bsongis d2fabe2b2e No curve drawn when cursor on page selection 2012-07-27 17:49:26 +00:00
mhotar@gmail.com c515db3610 tts_cz corrected 2012-07-27 13:05:56 +00:00
bsongis a2f5158c79 Compilation pb in c9x 2012-07-27 12:31:49 +00:00
bsongis 2f033ff455 A few new changes in EEPROM which were in the TODO list 2012-07-27 12:26:39 +00:00
mhotar@gmail.com 66ea773f5f tts_cz.cpp added
CZ translations updated
2012-07-26 22:04:56 +00:00
bsongis 71f71357c2 Voice corrections for stock / gruvin9x board
Minor corrections for curves
Changes in Function Switches to allow a duration there. It allows again a +1/-1 step in Safety functions
2012-07-26 18:51:59 +00:00
bsongis 6ed367834b Possibility to remove completely the CURVES Menu and calculations (CURVES=NO Makefile option) 2012-07-26 10:31:33 +00:00
bsongis 55e0b5d241 Small flash saving 2012-07-26 08:51:38 +00:00
bsongis 3c8c213ce3 Issue with looping mixes (thanks Gabriel for reporting it) 2012-07-26 08:44:48 +00:00
bsongis 9c20efb6ef No more TADA (when no VOICE / SD card of course) 2012-07-26 07:35:52 +00:00
bsongis 92071b9643 TTS for SOMO-14D 2012-07-25 16:13:10 +00:00
bsongis d27ae57b4a companion9x compilation 2012-07-25 14:32:02 +00:00
bsongis bfdc66635d XCURVES option removed. There will be only one EEPROM format. And some functionnality will be removed later (no custom curves) when XCURVES will be disabled. For now it's always enabled. 2012-07-25 14:27:38 +00:00
bsongis 7111fcfb82 Issue 51 fixed 2012-07-25 08:49:55 +00:00
bsongis e5ddc1c430 Let's reserve a bit for FrSky FAS-100 2012-07-24 21:14:02 +00:00
bsongis a5112d2463 Numbers with digits (A1/A2) were not played correctly with TTS (done only french) 2012-07-24 20:53:01 +00:00
bsongis effdd542ca Remaining trace 2012-07-24 17:49:43 +00:00
bsongis 08eb59147c Translations 2012-07-24 17:37:16 +00:00
bsongis a10f725a0a Voice added on stock (completely untested)
Issue 50 fixed
Tada sound added
Corrections on expos curves
2012-07-24 17:33:43 +00:00
mhotar@gmail.com 7c2fb0e460 Czech translations 2012-07-24 16:15:09 +00:00
bsongis 10265a90ca New curves system (XCURVES Makefile option)
SmartieParts board v2.2 support (SP22 Makefile option)
2012-07-24 15:11:00 +00:00
romolo.manfredini@gmail.com 176cd898a0 fix strexh strexb compilation error 2012-07-22 10:05:13 +00:00
bsongis 16ea2616bd 4bytes saved 2012-07-21 17:27:04 +00:00
bsongis 78bae1357d Lower frequency for updating the contrast on splash screen 2012-07-21 09:24:05 +00:00
bsongis 533fd05414 [ersky9x] SDCard logs
New wav sounds for alerts
2012-07-20 20:36:18 +00:00
bsongis 201d7d095e No more momentary switches with Safety Function 2012-07-20 10:11:13 +00:00
bsongis 1675bfc42a !momentary switches ko when used in timers 2012-07-20 09:17:56 +00:00
bsongis 3718efd9d8 Backlight ON on Tx startup 2012-07-20 07:58:04 +00:00
bsongis 391f211015 Restore Model didn't work on gruvin9x board (cast missing on EEPROM version check) 2012-07-20 06:40:39 +00:00
romolo.manfredini@gmail.com 9dd2b9b1b1 Italian translations 2012-07-19 23:32:54 +00:00
bsongis 4a8f0979fd Flash saving
Momentary switches a little bit modified (depending of the function) in Function Switches
New trigger ONm in Function Switches
2012-07-19 19:06:55 +00:00
bsongis 6cc287b4eb Some work ready for translators 2012-07-18 16:01:40 +00:00
bsongis f881418fe4 [ersky9x] compilation error when no FRSKY and SDCARD enabled 2012-07-18 14:03:54 +00:00
bsongis 9e8ef373b0 Makefile simplification 2012-07-18 13:06:28 +00:00
bsongis ee0521981b [ersky9x] CSW bugs 2012-07-18 09:28:28 +00:00
bsongis 688660228a Batt evaluated instantaneously in Anas Diag screen (without alarm there) 2012-07-18 09:17:32 +00:00
bsongis 3d737e3eb1 Backlight function switch
No batt volts averaging during calib
Flight phase in bold in Phase One when enabled
Flash savings
[ersky9x] Delay / Duration in custom switches
2012-07-18 08:12:26 +00:00
romolo.manfredini@gmail.com 50d21a4c72 small typos fix 2012-07-18 07:57:11 +00:00
bsongis e8b41de152 [ersky9x] PPM-in problem 2012-07-18 07:34:52 +00:00
bsongis 06b2a1f0e4 When missing TTS files tts_en.cpp is used 2012-07-18 07:31:08 +00:00
romolo.manfredini@gmail.com cda34966fe italian tts 2012-07-17 18:40:03 +00:00
romolo.manfredini@gmail.com 64886eec04 italian tts 2012-07-17 18:31:47 +00:00
romolo.manfredini@gmail.com e5169e1ef5 better espeak and mbrola voices 2012-07-17 14:08:57 +00:00
bsongis bdf409ea5c Option -mstrict-X only available starting of avr-gcc 4.7.0 2012-07-17 13:38:15 +00:00
bsongis 314bda18cb simplification of tts.py 2012-07-17 10:34:22 +00:00
romolo.manfredini@gmail.com 1c0a1cf777 fixup for linux and italian language 2012-07-17 10:28:08 +00:00
bsongis ffee72c649 tts.py compatibility with espeak 2012-07-17 10:16:38 +00:00
bsongis 1953eb4cfe tts.py compatibility with espeak 2012-07-17 09:55:42 +00:00
bsongis 25e980e231 tts.py now able to generate csv files 2012-07-17 09:25:19 +00:00
bsongis be7338fa11 tts.py indentation 2012-07-15 12:52:33 +00:00
bsongis 326dc07834 +700bytes saved thanks to Mike on stock board 2012-07-15 07:51:16 +00:00
bsongis 73e1dd761a It's my FAS-100 which is not good. Let's make things ok for others then :( 2012-07-14 09:38:49 +00:00
rob@marotori.com 23add71329 English wav additions. 2012-07-13 16:07:34 +00:00
bsongis b1123dfbfe tts.py indentation 2012-07-13 15:57:21 +00:00
rob@marotori.com 974860ffef Update to tts generation..
bug fix and option to choose alternative voice file.
2012-07-13 10:49:46 +00:00
rob@marotori.com b86c0b4aaa update to allow sox to be used as an option! 2012-07-13 10:03:05 +00:00
bsongis 7ca6a733c8 More TTS work:
French numbers now ok with gender.
200ms removed at the start and the end of all prompts
2012-07-12 21:00:05 +00:00
rob@marotori.com 17945fc24f Instructions and software requirements added to header of script. 2012-07-12 14:47:29 +00:00
bsongis b9a74b0f89 TTS script 2012-07-12 14:36:44 +00:00
bsongis 0ac6582225 [ersky9x] Inflight Parameters Modification with Rotary Encoder
TTS script for SAPI voice engine
2012-07-12 14:22:49 +00:00
bsongis 228d934b88 Backlight ON when stick movements 2012-07-11 22:02:35 +00:00
bsongis b4f61dea80 Little modification for siren sound 2012-07-11 21:53:39 +00:00
bsongis 09c1ad284b [ersky9x] The siren had a problem with the nose 2012-07-11 20:16:03 +00:00
bsongis 866ed66a9e Rotary encoder in SD menu 2012-07-11 19:13:00 +00:00
bsongis 5d659c359c [ersky9x] Inflight Parameters modification disable for now 2012-07-11 18:08:42 +00:00
bsongis 955767669e The sticky key bug reported by Rob!
SURROUNDED again here (for Rotary Encoder parameters inflight modification)
2012-07-11 17:38:22 +00:00
bsongis 95170b5930 [ersky9x] rotary encoders inversion
RE1 and RE2 renamed as REa and REb (will be needed for Flight Phases uses)
2012-07-11 13:21:03 +00:00
rob@marotori.com d1425e77a9 Fix so encoder works on ARM & PCB4 board. 2012-07-11 11:31:51 +00:00
bsongis da2d1fd8a0 [ersky9x] Rotary Encoder Makefile issue 2012-07-11 10:47:52 +00:00
bsongis 0beaadc2e5 Free EEPROM = available + temp - current model
Low EEPROM warning displayed on model change
[ersky9x] Rotary Encoder
2012-07-11 10:40:20 +00:00
bsongis 7fd2f1d571 Forgot a file in my last commit! 2012-07-11 08:26:08 +00:00
bsongis 9a83ed8017 Issue 46 fixed 2012-07-11 05:54:35 +00:00
kjell.kernen@gmail.com 978aef3279 Translated a couple of new strings. Left a few telemetry strings that I simply do not know the meaning of :-) 2012-07-10 22:32:15 +00:00
bsongis 846d0a6114 Reboot when EEPROM overflow in some cases 2012-07-10 19:38:18 +00:00
bsongis 82fbc66388 Free EEPROM was not updated after a model DELETE / COPY operation 2012-07-10 17:59:28 +00:00
bsongis 45fa6eadd0 Delay and Duration added to Custom Switches for ARM (only added in EEPROM to avoid another conversion) 2012-07-10 13:57:44 +00:00
bsongis fa4e1e4fc0 No more alert for EEPROM overflow
Trims buttons don't modify trim position on release
[ersky9x] Audio stopped sometimes without reason
2012-07-10 13:37:55 +00:00
rob@marotori.com dba6841815 Fix to random stop of audio queue.
Issue caused by 'random' deny on reading sdcard causing queue to exit in 'dead' state.
2012-07-09 10:59:48 +00:00
bsongis c95ff048d8 Another STUPID bug on audio / ersky9x 2012-07-08 17:44:16 +00:00
bsongis 89dd6aaf47 Audio ersky9x bugs fixed 2012-07-08 09:37:03 +00:00
bsongis dece55d558 Audio ersky9x bugs fixed 2012-07-08 09:31:37 +00:00
bsongis c6b2a1f815 c9x compil 2012-07-08 08:52:22 +00:00
bsongis 4ffd5115d3 Infinite loop in pushPrompt 2012-07-07 22:17:24 +00:00
bsongis 6585294321 When A1 or A2 are current sources they have to be / 10 for power calculations 2012-07-07 08:36:26 +00:00
bsongis 536f032a15 Play Telemetry on ersky9x board 2012-07-07 07:12:30 +00:00
bsongis f10b2f7b14 VFAS for Watts was not implemented 2012-07-06 22:05:55 +00:00
bsongis d2c1706825 Problem with current used for watts / mAh 2012-07-06 21:01:16 +00:00
bsongis 34e412d4b2 Yet Another Voltages Telemetry Screen 2012-07-06 20:26:37 +00:00
bsongis 0e5c1b9498 5 blades max 2012-07-06 18:21:57 +00:00
bsongis 356933f0bf simu compilation broken 2012-07-06 18:08:16 +00:00
bernet.andre@gmail.com 177d3739d4 Cell display was wrong 2012-07-06 16:43:20 +00:00
bernet.andre@gmail.com 2fc645486d VFAS calculation/display now OK 2012-07-06 15:24:15 +00:00
bsongis 9573976c7a simu compilation broken 2012-07-06 14:32:13 +00:00
bsongis 4b7cc132b1 FrSky VFAS first commit for Kilrah's tests ... 2012-07-06 14:19:32 +00:00
bsongis a3c768e899 simu compilation broken 2012-07-06 13:29:35 +00:00
mhotar@gmail.com 23db0a9587 CZ translations - Telemetry layout 2012-07-06 13:14:02 +00:00
bsongis cb073fa549 Audio system on ersky9x ... another rewrite
Some flash saved on stock
GPS calculations flash saving (around 100bytes, needs to be tested)
2012-07-06 13:09:29 +00:00
bernet.andre@gmail.com e94db55b27 Text overlap in FR version 2012-07-05 17:08:48 +00:00
bsongis 3cb83df6cd 6 bytes saved in flash (pulled from er9x) 2012-07-05 10:31:26 +00:00
bsongis a761db40a2 simu compilation 2012-07-04 12:57:35 +00:00
bsongis 602ff6ca46 Audio wav files may not be queued and repeated as others. 2012-07-04 10:33:17 +00:00
rob@marotori.com 8989ce4e6c Upload of windows batch file that will take any sound and push it to maximum volume. Usefull when creating wav files! 2012-07-04 09:03:40 +00:00
bsongis b78533f86c Mutex to protect the audio functions 2012-07-03 19:41:53 +00:00
bsongis 4b3fad5266 PCM alaw codec support 2012-07-03 18:33:43 +00:00
bsongis 095b38a076 Around 40bytes saved on stock (from one of the last commits) 2012-07-03 18:31:31 +00:00
rob@marotori.com 6b9ee4ec76 Volume Leveling so wav files and system beeps are similar in end volume! 2012-07-03 15:35:23 +00:00
rob@marotori.com d762b150b0 Fix to only issue trim center audio when actually at trim center! (used to issue at trim max too! 2012-07-03 14:31:00 +00:00
bsongis ed89675f78 Momentary switches should not be bold
Memory overwrite in function switches (ersky9x)
2012-07-03 07:31:39 +00:00
bsongis 91e2c8222b No more scratch at the end of wav files playback 2012-07-02 22:20:17 +00:00
mhotar@gmail.com 79fd273755 constant changed to X*FW 2012-07-02 20:41:01 +00:00
mhotar@gmail.com 6a09f6fdb7 CZ translations FP_EDIT, HELI 2012-07-02 19:50:40 +00:00
bsongis 67b774cc47 Protection against too many read / write errors on SD 2012-07-02 17:54:24 +00:00
bsongis d08c172860 Don't increase stock flash! 2012-07-02 17:18:38 +00:00
rob@marotori.com 6636bf90c8 Update to enable different sound event for trim centres, and trim end points. 2012-07-02 16:55:06 +00:00
bsongis 190aafa1ef /9XSOUNDS/SYSTEM directory for system wav files 2012-07-02 16:23:55 +00:00
bsongis 9c4b9d7f1b /9XSOUNDS/SYSTEM directory for system wav files 2012-07-02 16:11:47 +00:00
bsongis 2e29aaa96b audio state not resetted after playing a wav file 2012-07-02 11:16:02 +00:00
bernet.andre@gmail.com d5eff9481d French translations 2012-07-02 11:10:54 +00:00
bsongis b0e13cde89 ---- displayed when no track in function switch 2012-07-01 20:55:02 +00:00
bsongis 85f7a85f98 BOLD = YES / NO option
Because this option costs around 400bytes
2012-07-01 20:42:04 +00:00
bsongis da024aad74 Issue 44 2012-07-01 19:44:34 +00:00
mhotar@gmail.com 236c3539d1 CZ translations 2012-07-01 19:34:35 +00:00
bsongis 68dce1bc92 Delays multiple of 0.5s as Speed 2012-07-01 19:24:23 +00:00
bsongis a125a3866a Regression brought by r1048 (thanks Gabriel again!) 2012-07-01 19:20:47 +00:00
bsongis 1c7f8c2457 Issue 43 2012-07-01 15:51:15 +00:00
bsongis c0ccef70c8 Issue 42 partly solved 2012-07-01 15:37:35 +00:00
bsongis fcf93ad789 Little pause ;) Using unions in EEPROM is not a very good idea for Linux / Windows interoperability 2012-07-01 15:02:00 +00:00
bsongis 4505d886f6 [UP] + [DOWN] = default value
[UP] + [RIGHT] = max value
[LEFT] + [DOWN] = min value
If KILRAH defined in menus.cpp
2012-06-30 09:00:01 +00:00
bernet.andre@gmail.com c6f7ba0b55 French translations updated 2012-06-30 08:15:57 +00:00
mhotar@gmail.com 51dc2fbc1b CZ translations updated 2012-06-30 07:51:29 +00:00
bsongis 34697da8d2 Replace in Mixes unbolds all replaced Mixes 2012-06-30 06:29:11 +00:00
romolo.manfredini@gmail.com b541cb5c3a fix companion9x compilation errors 2012-06-30 00:09:40 +00:00
bsongis 2d99899bce Problem with bars thresholds 2012-06-29 21:32:37 +00:00
bsongis 133a52473d Problem with bars thresholds 2012-06-29 21:27:00 +00:00
bsongis 5831148201 Safety switches not bold when not enabled 2012-06-29 20:50:28 +00:00
bsongis 86195a1841 Power 10 times too low 2012-06-29 20:41:20 +00:00
bsongis e95af52d98 Small flash saving (36bytes) 2012-06-29 20:37:07 +00:00
bsongis 221826f457 TWO_DOTS option was wrong as well 2012-06-29 20:28:32 +00:00
bsongis 30378b111a Condensed letters display bug 2012-06-29 20:25:54 +00:00
bsongis 250281884b Cells total voltage fixed 2012-06-29 20:12:02 +00:00
bsongis eb61944c0a Tx Low Battery sound was a simple error 2012-06-29 19:58:51 +00:00
bsongis 0da5214a11 Some TODOs removed 2012-06-29 19:23:42 +00:00
bsongis 6b6c945f59 Bold introduced in many menus
PlayTrack for ersky9x
Volume for ersky9x
Names for Mixes and Expos
2012-06-29 17:17:48 +00:00
bsongis 48e3a2ebf4 Audio problem on ersky9x board 2012-06-27 20:09:09 +00:00
bsongis d44a0a126e Sirens again on ersky9x board. Length were not good. 2012-06-26 20:37:28 +00:00
bsongis 7b000b376d Possible division per 0 2012-06-26 20:14:12 +00:00
bsongis 5eb81c5853 MaxCurrent always 0 2012-06-26 20:05:47 +00:00
bsongis 99a6b32421 Consumption 10 times too big 2012-06-26 19:34:27 +00:00
bsongis 3ca8834d44 PREC1 for current 2012-06-26 19:33:19 +00:00
bsongis 03e89f382e Slow / Delays were broken!
Some variables renamed
2012-06-26 19:09:10 +00:00
bsongis d69af0cafc Audio wav files playing was already broken! 2012-06-26 17:48:19 +00:00
bsongis 8f2e3732a2 companion9x compilation 2012-06-26 12:55:16 +00:00
bsongis 8a34c2d51e companion9x compilation 2012-06-26 12:39:22 +00:00
bsongis d46c65c8fd companion9x compilation 2012-06-26 12:30:46 +00:00
bsongis 7911dd927f companion9x compilation 2012-06-26 10:18:48 +00:00
bsongis 0ab16b6734 companion9x compilation 2012-06-26 10:16:24 +00:00
bsongis 5dd7c105b6 Current consumption may depend on 3 different sources
Flash saving in FrSky code
SD card wav player (still read as raw 12000Hz 16bit samples)
2012-06-26 10:09:31 +00:00
romolo.manfredini@gmail.com 61bbfd6e7c Add support for FAS100 sensor 2012-06-26 07:17:17 +00:00
bsongis 6c28032e9b companion9x windows compilation 2012-06-24 10:45:28 +00:00
bsongis f6a8ff9f2a SD File Manager 2012-06-24 08:17:42 +00:00
bsongis dcde118437 SD File Manager 2012-06-23 21:38:56 +00:00
bsongis 9b25e154e5 SD File Manager 2012-06-23 20:06:31 +00:00
bsongis fa667dbc78 SD File Manager 2012-06-23 19:44:53 +00:00
bsongis ef141403bc companion9x compilation 2012-06-22 19:45:23 +00:00
bsongis 5158ed5dc4 companion9x compilation 2012-06-22 19:42:38 +00:00
bsongis 971a44feeb SD-HC support on ersky9x 2012-06-22 18:06:10 +00:00
bsongis c9a8934e06 Stupid SD backup bug on ARM 2012-06-21 22:05:55 +00:00
bsongis fb493b5415 SD-Card corrections on ersky9x board
Status line
FatFs on simu
2012-06-21 18:40:55 +00:00
rob@marotori.com 476eb4c2d5 Fixed SDCARD Write on SDHC cards.. just commenting out two calls 2012-06-20 12:10:09 +00:00
bsongis 777f48121b CooCox on ARM
New option THR_TRACE to save flash and RAM on Stock board
DMA used for SD-Card
CMD16 command added for block length = 512 bytes
2012-06-19 22:49:48 +00:00
bsongis 0d1496dbcd companion9x compilation 2012-06-19 12:36:51 +00:00
bsongis f9edbd453d companion9x compilation 2012-06-19 12:36:17 +00:00
bsongis 831541bd61 Bug fix on gruvin9x board (strange sound / no [Menu] key) 2012-06-19 12:22:34 +00:00
bsongis cb24c1e46e companion9x compilation 2012-06-19 10:13:58 +00:00
bsongis d8f6b5b643 Simu compilation 2012-06-19 09:50:40 +00:00
bsongis 6314541f66 SD-card / ersky9x corrections 2012-06-19 09:18:20 +00:00
bsongis 471f294f07 "No SDCARD" / "SDCARD OK" in "VERSION" screen 2012-06-19 07:10:59 +00:00
bsongis 342b643661 mixer_interrupt branch merged to trunk
timers on stock board should be more accurate
2012-06-18 13:38:31 +00:00
bsongis 963b07439b Some cleaning was needed. FatFs now shared between gruvin9x and ersky9x boards. 2012-06-18 10:01:59 +00:00
bsongis f935757503 30 seconds (by steps of 0.5s) for delay and speed in Mixers 2012-06-18 07:41:37 +00:00
bsongis f3d040af69 Slow Down / Slow Up was 30 seconds long instead of 7.5 seconds (thanks Gabriel again!) 2012-06-18 06:40:23 +00:00
bsongis 33e2588f00 companion9x compilation 2012-06-17 22:02:27 +00:00
bsongis 6eca03264a companion9x compilation 2012-06-17 21:24:51 +00:00
bsongis 3a5c07703e companion9x compilation 2012-06-17 21:18:19 +00:00
bsongis a5600847e2 Simu now ok on MAC (with the official compiler) 2012-06-17 21:11:23 +00:00
bsongis c715aa2557 SD card support on ersky9x board
Little animation at Tx start
Backlight support for simu
Mixes slow down / up now go 2 times faster
2012-06-17 21:01:07 +00:00
bsongis 06b5a2903d It now runs inside an RTOS task! Still a lot to do, but it's a good start! 2012-06-12 18:29:56 +00:00
bsongis 8dee4218f7 Last CooCox version
Some handlers were defined twice in vectors_sam3s.c, perhaps some others need to be checked ... later!
2012-06-11 18:32:11 +00:00
bsongis 65167cf315 Revert to the hand as an asterisk 2012-06-11 07:52:52 +00:00
bsongis 38d5ca9236 First commit CooCox 2012-06-10 21:02:43 +00:00
bsongis a45b03ded3 New branch for RTOS CooCox first try 2012-06-10 20:25:10 +00:00
kjell.kernen@gmail.com f0c9202e6d Translated new strings for "play value". 2012-06-09 19:28:50 +00:00
bsongis eb648e4cb5 SD-Card menu correction for ARM 2012-06-08 20:35:40 +00:00
bsongis 75acac5f4c SD-CARD work on the ersky9x board 2012-06-08 15:25:03 +00:00
bsongis 640b5fe668 ADC filtered and OSMP were inverted
TTS script for .AD4 english prompts generation
2012-06-08 10:00:54 +00:00
flyingframes.film@gmail.com f2dcecc059 Removed checkboxes from german translation graphics. New warning icon. 2012-06-07 20:43:44 +00:00
bsongis 17409f04ed Port from ppm42ms branch 2012-06-07 09:56:11 +00:00
bsongis 88cd8e4027 First SOMO-14D tests 2012-06-06 20:17:17 +00:00
bsongis 1570814b45 First SOMO-14D tests 2012-06-06 20:14:40 +00:00
bsongis 1d430c1296 Byte saving in PPM pulses (thanks Paul!) 2012-06-06 15:44:43 +00:00
bsongis b0f0bac3e2 SOMO-14D again for french 2012-06-06 15:38:00 +00:00
mhotar@gmail.com 94742f38b8 CZ translations updated 2012-06-06 15:27:49 +00:00
bsongis c6886c63eb Make companion9x compile again since last open9x changes 2012-06-06 10:27:21 +00:00
bsongis 71e1283508 Somo14D interrupt was blocking. pushPrompt needs a CLI to write TIMSK4 2012-06-06 10:24:05 +00:00
bsongis 82fe7c61b1 SOMO-14D work for the gruvin9x board 2012-06-06 10:06:36 +00:00
bsongis 214332fbb9 Cells Voltage in CSW should be ok when increasing (could only decrease before) 2012-06-05 08:24:01 +00:00
mhotar@gmail.com ef1c7db957 CZ translations update 2012-06-04 20:49:21 +00:00
kjell.kernen@gmail.com d6927be07b Translated both "inverted throttle" and "reversed throttle" (which are the same) to "Reverserad Gas" 2012-06-04 10:54:15 +00:00
bsongis 25fa42b0f0 Confirmation screen when inverting the Thr channel in LIMITS menu. 2012-06-04 10:39:59 +00:00
bsongis ae372abeaa THR warning when changing Stick Mode 2012-06-04 10:34:03 +00:00
bsongis 99766e97a8 40ms instead of 42ms is enough 2012-06-01 20:59:32 +00:00
bsongis 57fb4d41f3 200bytes flash saved in pulses 2012-06-01 20:47:44 +00:00
bsongis a834931c4d One comment removed, as it doesn't help too much :) 2012-06-01 19:53:44 +00:00
bsongis 4711ca4c91 PPM frame should now go up to 42ms 2012-06-01 19:46:00 +00:00
bsongis ef5441df09 PPM frame > 32.5ms 2012-06-01 18:49:03 +00:00
bsongis e80339aadd Double THR / Switches check on simu & companion9x 2012-06-01 17:17:45 +00:00
bsongis 3d02551e6a make simu PCB=ARM compilation error 2012-05-30 15:02:50 +00:00
bsongis 2221cce51a Some pulses correction on V4 2012-05-30 14:46:51 +00:00
bsongis 54cf0a40f9 Simulator always starts with Main Views 2012-05-30 13:40:18 +00:00
bsongis ed8379c44b Hand in place of the asterisk
Work on SD-card logs. No more f_open and f_close in flight (could take up to 400ms!)
SD-card logs now closed on shutdown
2012-05-30 11:28:14 +00:00
bsongis 68d8fa7794 img2lbm script restored 2012-05-30 07:47:12 +00:00
bsongis 46634e1ff3 FrSky Hub only logged if USR proto is Frsky Hub.
Rud, Ele, Thr, Ail, P1, P2, P3 values logged
2012-05-29 20:53:54 +00:00
bsongis 33daf76a9b RTC now dumped in Logs (1st and 2nd columns) 2012-05-29 20:29:03 +00:00
bsongis 948f3a78c1 Logs filenames were wrong! 2012-05-29 20:05:31 +00:00
bsongis 571b877a8d If lightOffCounter running and a beep occurs, the counter is erased with the flash duration 2012-05-29 18:55:55 +00:00
bsongis 15ed275cf4 More SD card bugs fixed on gruvin9x 2012-05-29 18:13:54 +00:00
bsongis 249e6f2e63 Flash saving. SD card work (for gruvin9x / ersky9x boards) 2012-05-29 17:06:40 +00:00
mhotar@gmail.com a462949bc2 asterisk image added to stock 9x firmware if none extension selected 2012-05-29 08:59:55 +00:00
kjell.kernen@gmail.com c61f643332 Corrected that I had left a binary Swedish character in the text (oups).
Changed length of a number of strings to fit the display better.
Some naming tweaks to improve clarity.
2012-05-28 21:38:52 +00:00
bsongis dde599fdd6 Temporary traces added for Kilrah and MAC debuggers ... 2012-05-25 21:59:04 +00:00
bsongis 2fb32eb9cc Temporary traces added for Kilrah and MAC debuggers ... 2012-05-25 21:30:54 +00:00
romolo.manfredini@gmail.com 4d3c4e4ecf Italian translations update 2012-05-25 21:18:47 +00:00
bsongis 7fe4fc8491 Missing include 2012-05-25 20:27:02 +00:00
bsongis 1784409df0 Temporary traces added for Kilrah and MAC debuggers ... 2012-05-25 20:20:56 +00:00
bsongis 3e9bb483dc Temporary traces added for Kilrah and MAC debuggers ... 2012-05-25 19:32:52 +00:00
bsongis 34d7db24b2 Temporary traces added for Kilrah and MAC debuggers ... 2012-05-25 18:30:26 +00:00
bsongis 77f518874e Applets pulled from ersky9x 2012-05-25 18:24:34 +00:00
bsongis 6eec97aa23 Could cause a reboot in certain conditions. Bug also present in er9x / gruvin9x! 2012-05-25 17:06:29 +00:00
bsongis 235c578a9c Better handling of keys in simu. Switches / THR warnings on simu now ok. 2012-05-25 16:52:37 +00:00
bsongis 251ce1d69c To fix DSM2 regression from last commit 2012-05-25 15:03:33 +00:00
bsongis 181ced12fc Simu compilation error 2012-05-25 14:59:31 +00:00
bsongis 9ef47a1e63 Switch and Throttle Warnings when loading a model. To be tested and re-tested ... 2012-05-25 13:52:39 +00:00
bsongis d3b14ea3e2 Revert changes for image compression while companion9x is not ready for this feature 2012-05-25 07:34:56 +00:00
bsongis 3dd8338028 lbm files added again, needed for companion9x 2012-05-25 07:18:08 +00:00
bsongis d810537125 lbm files not any more on svn. Python + pyQt now needed to compile open9x 2012-05-25 07:00:39 +00:00
romolo.manfredini@gmail.com cc91c5e399 stamp-open9x.h is needed for simu 2012-05-24 22:05:28 +00:00
mihlit@mihlit.cz 6a0114d612 save flash through image compression
For default make configuration, 574 bytes saved with primitive
compression algorithm.
2012-05-24 20:33:35 +00:00
mhotar@gmail.com c1e61fdd38 CZ translations update - warnings 2012-05-24 18:42:57 +00:00
maxim.karban@gmail.com 29f91b4024 asterisk sign little smoother now 2012-05-24 18:12:18 +00:00
maxim.karban@gmail.com 1ab87150d8 EXTRA_ROTARY_ENCODERS: redefined some variables, cosmetic 2012-05-24 18:07:27 +00:00
maxim.karban@gmail.com 0e44200b9c tick sign changed to be bold 2012-05-24 14:19:49 +00:00
bernet.andre@gmail.com 9941bc12a7 Swapped words on warning screen for French and Italian - Please add other languages if applicable, German is OK but I know no Czech or Swedish! 2012-05-24 10:50:55 +00:00
bsongis c47a380c0e No REe with EXTRA_ROTARY_ENCODERS 2012-05-24 07:41:53 +00:00
bsongis 521f7fc2f4 Issue 31 solved 2012-05-24 07:38:40 +00:00
maxim.karban@gmail.com 0f9036f00d PXX for V4 fixed, tests need 2012-05-24 06:13:10 +00:00
bernet.andre@gmail.com d88cd7d95f One char too much in French translation... dang 2012-05-23 21:36:59 +00:00
bernet.andre@gmail.com 84add995ce More French translations 2012-05-23 21:34:19 +00:00
kjell.kernen@gmail.com 975cb17612 Translated strings for new warning screens 2012-05-23 21:16:53 +00:00
bsongis a377326c6e Unused strings removed 2012-05-23 21:14:50 +00:00
bernet.andre@gmail.com 091885090f New warning screen translations 2012-05-23 21:08:51 +00:00
romolo.manfredini@gmail.com fcabcf8f9f Italian translation 2012-05-23 20:35:40 +00:00
bsongis b7860b3363 New warning screens 2012-05-23 20:28:20 +00:00
bsongis 40341b20ee New warning screens 2012-05-23 20:25:02 +00:00
bsongis 925d661640 New warning screens 2012-05-23 20:15:12 +00:00
bsongis 090a74369a Wrong display on SIMU when creating a model 2012-05-23 14:50:28 +00:00
bsongis b5e76c186c Space chars forbidden on FAT32 2012-05-23 13:41:02 +00:00
bsongis e32eeec487 SD-card Model Backup bug when model name greater than 8 chars 2012-05-23 12:18:24 +00:00
maxim.karban@gmail.com f9673e3b8b EXTRA_ROTARY_ENCODERS changed as:
REb - left on same place - not moving to REa
REa reused as UART function
3 encoders from daughter board becomes as REa, REc, REd
push buttons sending from all 3 additional encoders
but decodes only from REa
2012-05-23 09:12:06 +00:00
bsongis 714bbf4fa2 Some low level for SD-CARD 2012-05-22 18:57:30 +00:00
bsongis 28337362f9 Some low level for SD-CARD 2012-05-22 18:45:59 +00:00
bsongis b4a3f2038d Some SD-card work for the ARM board (high level) 2012-05-22 18:24:48 +00:00
maxim.karban@gmail.com b4e881f1c0 EXTRA_ROTARY_ENCODERS all buttons transmitting and REb button receiving now 2012-05-22 14:27:03 +00:00
bsongis f94a25b22e No PPM was sent on protocol change (PPMSIM => any other) 2012-05-22 14:07:47 +00:00
kjell.kernen@gmail.com e84f291724 Translated "Switch on" to "Brytare på" 2012-05-22 13:38:35 +00:00
bsongis 93b8251338 One space removed in Switch Warning 2012-05-22 08:44:11 +00:00
gbirkus@gmail.com 3b02b184cf ON/OFF shifted in FSw 2012-05-22 08:33:34 +00:00
bernet.andre@gmail.com 18718f0ec1 Switch names reverted to Fnglish in French translation to match the labels on the TX case. 2012-05-22 08:16:31 +00:00
bsongis dceec43442 Option GRAPHICS=YES/NO introduced for checkboxes and sliders (today it uses 144bytes) 2012-05-22 07:33:35 +00:00
mhotar@gmail.com ecf7831af5 CZ translations -custom checkbox removed 2012-05-21 21:59:12 +00:00
bsongis a4a91dcd72 Cosmetic problem in LIMITS menu (PPM_CENTER_ADJUSTABLE=NO and PPM_LIMITS_UNIT=US) 2012-05-21 21:08:05 +00:00
bsongis 20a7e91796 Grrrrrrrr.
v4 didn't compile without the EXTRA_ROTARY_ENCODERS option
companion9x didn't compile
2012-05-21 20:47:06 +00:00
bernet.andre@gmail.com 72d8d5e255 French translation updated with contributions from Alex and adapted to one extra available column in model setup page
"EEPROM Formatting" -> "Formatting EEPROM"
2012-05-21 20:20:42 +00:00
bsongis bc0958f436 Checkboxes instead of OFF / ON 2012-05-21 20:09:58 +00:00
bsongis 3be919b20c French translation updated 2012-05-21 19:30:20 +00:00
bsongis 11c9e23550 Another indentation problem 2012-05-21 19:23:10 +00:00
bsongis b4b615303e Indentation problem. Standard is: 1 tab = 8 spaces. Thanks for updating your editor settings! 2012-05-21 19:17:02 +00:00
bsongis 735e272d36 Bug with PPM center: it was displayed a pulses value when on "Trims => Offsets" line ... 2012-05-21 19:13:26 +00:00
maxim.karban@gmail.com 0682da0ff1 /branches/extra_encoders_rework merged 2012-05-21 19:08:21 +00:00
bsongis 8a62c195d2 In MODEL SETUP screen the 2nd column is shifted to the right by one char 2012-05-21 18:46:42 +00:00
flyingframes.film@gmail.com 7bce71ef64 Added checkbox graphic to german translation. 2012-05-21 17:39:33 +00:00
mhotar@gmail.com 1400fdddbb CZ extra chars into translate.py 2012-05-21 07:29:35 +00:00
bernet.andre@gmail.com 1b800f6e53 String too long for available space 2012-05-20 22:08:42 +00:00
romolo.manfredini@gmail.com a1e9920799 Unterminated c++ string 2012-05-20 21:08:00 +00:00
bsongis 926528e17f Traductions françaises par Kilrah 2012-05-20 20:14:03 +00:00
bsongis 4f0a102ccf French extra chars 2012-05-20 14:42:07 +00:00
mhotar@gmail.com 6d98f9f7ae CZ updated + checkbox 2012-05-20 11:38:21 +00:00
bsongis 168a3bc1eb Cosmetics on simu 2012-05-20 10:56:06 +00:00
bsongis f05f28c5fe French extra chars 2012-05-20 10:03:36 +00:00
bsongis 99b8e1e398 French extra chars 2012-05-20 08:56:55 +00:00
bsongis d64c4710e7 Some code for NODATA alarm still remaining 2012-05-20 08:31:09 +00:00
bsongis bb871ce6cf ID0 is default for 3POS switch 2012-05-20 01:00:22 +00:00
bsongis 02f135a596 Switches warning rewritten
NODATA alarm removed
2012-05-19 17:16:43 +00:00
bsongis 1e8219e110 Bug when displaying Max GPS speed in Custom Telemetry View. Also should fix a bug when WSHH used with IMPERIAL option. 2012-05-19 10:32:44 +00:00
bsongis a4be1f9177 RSSI gauges were not beautiful when sometimes RSSI goes over 99% 2012-05-18 11:41:34 +00:00
mhotar@gmail.com 5b580bf59c CZ fonts added 2012-05-18 11:38:59 +00:00
bsongis 9fc9cd18be Better averaging for FrSky A1/A2/RSSI 2012-05-18 10:35:21 +00:00
bsongis 1272f34ccb Cosmetics 2012-05-17 20:04:08 +00:00
bsongis 22562a2d60 Better averaging of voltage. Uses 1 byte RAM more, 70bytes flash less. 2012-05-17 19:48:08 +00:00
flyingframes.film@gmail.com d976a34736 - Fixed wrong Switch-Names
- Translation improvements
- New font graphics with different character order (äÄöÖüÜß)
2012-05-17 19:17:03 +00:00
bsongis dcd2a57cf5 Blink when edit mode in General Menus 2012-05-17 15:07:17 +00:00
bsongis aaa6367ac0 German font extra chars added 2012-05-17 14:54:53 +00:00
bsongis 7904888162 German font extra chars added 2012-05-17 14:50:48 +00:00
bsongis 2d57bc4d18 German font extra chars added 2012-05-17 14:48:20 +00:00
bsongis cc791bd880 General Menus broken on V4 (when no SD-Card) 2012-05-17 14:41:40 +00:00
romolo.manfredini@gmail.com a46b06714f Thr Trace items not displayed correctly 2012-05-17 13:05:49 +00:00
bsongis b9032878a7 German translations 2012-05-17 11:11:09 +00:00
bsongis ab259ab135 Cosmetic on the slider (Thanks Max) 2012-05-17 10:05:09 +00:00
mhotar@gmail.com 1ef129829b SafetySwitch translation fix -SE 2012-05-16 20:54:25 +00:00
mhotar@gmail.com 099e48080c SafetySwitch translation fix -CZ 2012-05-16 20:32:56 +00:00
bsongis 38fd7921e5 Wrong label for Haptic Length 2012-05-16 20:01:12 +00:00
bsongis 14f8d3e968 SafetySwich function redesigned 2012-05-16 17:59:11 +00:00
mhotar@gmail.com 8e3345c019 CZ translations -RadioSetup 2012-05-16 17:30:32 +00:00
bsongis 14f0f7ca10 Slider for beep length and haptic length. Thanks dvogonen for the idea and the screenshot! 2012-05-16 15:16:52 +00:00
mhotar@gmail.com 32ce85fc20 CZ translations updated 2012-05-16 11:19:58 +00:00
bsongis f035d089b2 CZ cosmetics 2012-05-16 09:45:29 +00:00
bsongis 082186b67a CZ cosmetics 2012-05-16 09:34:36 +00:00
bsongis ad95946378 Minor bug fixes 2012-05-16 09:20:04 +00:00
kjell.kernen@gmail.com 14f1e30287 Translated new strings.
Added dot for clarity of abbreviation.
2012-05-16 00:24:17 +00:00
romolo.manfredini@gmail.com a66b7730c2 italian Translation (again) 2012-05-16 00:21:06 +00:00
bsongis 45bdef6b3a TrmR / TrmE / TrmT / TrmA sources added to mixers and custom switches
The choice for Trim in mixers will be: OFF / ON / Rud / Ele / Thr / Ail
EEPROM formatted on ARM when invalid EEPROM
No EEPROM format when ARM board USB powered
2012-05-15 21:00:57 +00:00
romolo.manfredini@gmail.com 0e5360f07f Italian translations 2012-05-15 19:57:56 +00:00
mhotar@gmail.com 945c4b8528 CZ language specific layout fix (DR/EXPO) 2012-05-15 13:08:05 +00:00
romolo.manfredini@gmail.com b02ff17828 Fix for templates menu 2012-05-14 22:44:23 +00:00
bsongis 99eeee6fef Someone modified english CYC with CYK? 2012-05-14 20:51:29 +00:00
bsongis 0da63ae049 companion9x compilation 2012-05-14 20:43:23 +00:00
bsongis 5081f4ab0c companion9x compilation 2012-05-14 19:33:37 +00:00
bsongis ab2c65b9f2 SD card for ARM board (first part) 2012-05-14 17:36:18 +00:00
mhotar@gmail.com 7b16972636 Czech translations updated 2012-05-14 15:18:26 +00:00
kjell.kernen@gmail.com d403da541f Further corrections of Swedish translations after testing in simulator. 2012-05-14 13:14:43 +00:00
kjell.kernen@gmail.com b790953846 Quality improvements of Swedish translation.
Shortened strings for nicer display.
Replaced the strange "Trims => Offsets" string with meaningful text.
2012-05-14 11:28:53 +00:00
kjell.kernen@gmail.com 994e702b2d Brought Swedish translation up to date with the latest changes. 2012-05-14 10:28:57 +00:00
bsongis e989e22fbd Left Vertical Trim Slider now aligned left
Scrollbar on the Outputs Main Screen
4 screens for Outputs Main Screen on ARM board
Virtual Switches Main Screen redesigned
Saves 200bytes flash on stock board!
2012-05-14 10:21:17 +00:00
romolo.manfredini@gmail.com 97bbcbc4b9 Italian translation (WIP) 2012-05-14 09:50:58 +00:00
romolo.manfredini@gmail.com caef4a460f mmissing italian dblsize fonts 2012-05-14 08:42:37 +00:00
bsongis 1641572377 Cz translations. [C1] - [C3] used when HELI option disabled. 2012-05-14 07:42:49 +00:00
bsongis 3e4677f0b8 Warnings removed 2012-05-14 06:33:52 +00:00
bsongis e3c81400bc Issue 28 solved 2012-05-14 05:36:36 +00:00
romolo.manfredini@gmail.com 43c6b7cbb9 Italian translations (to be finished) 2012-05-13 22:56:52 +00:00
bsongis e5b9dec07e Another 168bytes saved 2012-05-13 21:54:13 +00:00
bsongis bd7f2d7669 80bytes saved 2012-05-13 18:43:36 +00:00
bsongis 830d1ffd90 Revert the latest flash saving. Was wrong. 2012-05-13 18:10:10 +00:00
maxim.karban@gmail.com 1504870094 Cosmetic bug fixed in DR/EXPO model menu 2012-05-13 17:35:25 +00:00
bsongis 9c0d231085 Little flash saving in DR/EXPOS and cosmetics 2012-05-13 16:09:33 +00:00
bsongis d5411a4f87 [Simu] THR warning was not working 2012-05-11 21:20:16 +00:00
bsongis 18804873b6 Issue 26 fixed 2012-05-11 20:43:14 +00:00
bsongis ff878bf884 THR Warn bug fixed. 2012-05-11 19:21:27 +00:00
bsongis b4645560f6 [SDCARD] refresh problem on Model Restore 2012-05-11 18:05:46 +00:00
bsongis b210b7f83f Last changes compile on V4 2012-05-11 17:37:42 +00:00
bsongis 2bb11cd2eb MODELSEL menu now accepts trimming at a normal speed 2012-05-11 17:11:41 +00:00
bsongis 9c0d89a9b0 Issue 10 solved: new script to help with special chars in translations (Thanks Kjell) 2012-05-11 16:38:12 +00:00
bsongis 782466cc73 Cosmeticsonly: I miserabily failed at saving a single byte flash here ;) 2012-05-11 12:25:42 +00:00
rob@marotori.com fe45498199 Post pause feature from previous update ported to stock/gruvin board.
Have tested on stock - can a gruvin board user test?
2012-05-11 11:37:29 +00:00
rob@marotori.com aacca8434a Update to introduce post tone sequence pausing on audio events. ARM Only at the moment. 2012-05-11 11:13:47 +00:00
bsongis 88dcfdcf30 Typo fix 2012-05-11 10:12:44 +00:00
gbirkus@gmail.com 3d9a020178 typo fix 2012-05-11 10:03:28 +00:00
bsongis 7eded397f7 Better handling of Protocols and Functions which are not chosen at compilation time. Now they are proposed as [Vario] / [PXX] when not available 2012-05-11 08:57:06 +00:00
bsongis 8a7dc4d009 Issue 25 solved 2012-05-10 21:16:44 +00:00
bsongis aabe510663 VARIO option introduced 2012-05-10 16:57:41 +00:00
rob@marotori.com 0f780eca35 Prevent haptic being enabled when usb plugged in on the ARM board. 2012-05-10 11:48:35 +00:00
rob@marotori.com 91dd67204b Two fixes:
1x Added a rate limit on the ARM board to prevent speaker getting over-run on sound requests.  This limit has two parameters in the audio.h to set the length.  Value of 10 seems to work ok for now.   The fix resolves the broken sound when the vario limit was set to 0.
2x Adjusted all tonePause and toneLen for the events to suit the ARM board.  Issue is simply that the audio is processed much faster.. so the tunes where happening too fast!
2012-05-10 09:03:34 +00:00
bsongis e9e6cfd19b FrSky A1/A2 averaged only if unit is volts 2012-05-10 07:13:23 +00:00
bsongis d2413055e3 Vario now tested and ok on stock board (Thanks Gabriel for the bug tracking!) 2012-05-09 21:08:43 +00:00
bsongis d5d902d05e 2bytes flash saved :) 2012-05-09 20:35:15 +00:00
mihlit@mihlit.cz 12c014d79f different fix for "there are no lines to go on trainer:slave_mode"
Perhaps not the best solution from nice code point of view, but
from three ways I tried, it adds the least amount of bytes :)
2012-05-09 19:43:58 +00:00
bsongis 6472138b54 If you change the selected model with MENU long the up/down buttons don't work anymore until you exit/reenter the model selection screen (Bug reported by Kilrah) 2012-05-09 19:28:37 +00:00
bsongis 4e1218e191 The radio didn't skip the splash and the checks on reboot due to WDT 2012-05-09 19:16:30 +00:00
maxim.karban@gmail.com cb1d384a03 VARIO_EXTENDED variables renamed 2012-05-09 17:21:10 +00:00
maxim.karban@gmail.com 57ab818538 VARIO_EXTENDED
removed bug around zero vspeeds
2012-05-09 17:17:15 +00:00
maxim.karban@gmail.com 10f017275d commented lines removed 2012-05-09 12:35:26 +00:00
maxim.karban@gmail.com 7e6eccfbc9 VARIO_EXTENDED A1/A2 sources fix 2012-05-09 12:11:04 +00:00
bsongis d29e2e25b2 Flash saving (78bytes) 2012-05-09 07:50:53 +00:00
bsongis 44b3e31d5a Throttle Warning based on Model parameters 2012-05-09 07:08:25 +00:00
bsongis 0b356b1886 Vario flash saving (8bytes)
A1 and A2 values displayed in TELEMETRY menu (to avoid switching screen for calibration)
2012-05-08 21:58:24 +00:00
bsongis 1a5a89e3d1 core in set_volume on Simu (ARM) 2012-05-08 21:47:19 +00:00
bsongis 571be5bf77 Vario fix 2012-05-08 21:08:12 +00:00
bsongis a96785cca7 In CUSTOM SWITCHES screen, enabled switches are displayed with INVERS (Idea from Cam, thanks!) 2012-05-08 21:01:47 +00:00
maxim.karban@gmail.com 547aa3fede VARIO_EXTENDED
Up speed limit range is -1.0..+2.0, especially for BaroV1 source
2012-05-08 20:13:19 +00:00
maxim.karban@gmail.com fe61a4fe7f Variometer sources now:
BaroV1: uses altitude before point only multiplied by 100
BaroV2: uses filtered altitude provided better than frsky hub source
A1/A2: uses winged shadow thermal scout connected to A1/A2 inputs on receiver
2012-05-08 20:07:57 +00:00
bsongis 176ee13455 PXX compiles on V4 2012-05-08 19:29:43 +00:00
bsongis 50b6a95fee Another TODO removed 2012-05-08 13:39:26 +00:00
bsongis 8f06ef1645 One TODO removed with a ten bytes flash saving 2012-05-08 13:29:43 +00:00
bsongis 3fc27a627f TODOs removed 2012-05-08 13:24:26 +00:00
bsongis a47cebfdd5 AutoSwitch adjustment for TRN 2012-05-08 12:05:13 +00:00
bsongis c8e8a4aba7 Compilation problem when PXX and not DSM2 2012-05-07 21:15:17 +00:00
bsongis 46d6a8196b Idea from Kilrah. To be discussed. For AutoSwitch is not bad. 2012-05-07 19:19:20 +00:00
bsongis 8b225699c9 Changelog updated 2012-05-07 18:35:48 +00:00
bsongis 69d19c868c Mix Beep was not perfectly regular (especially the 3rd one) 2012-05-07 17:53:34 +00:00
bsongis 943f7969c0 Compilation error when DSM2 and not PXX 2012-05-07 15:54:03 +00:00
mihlit@mihlit.cz 4724ccc780 rotary encoder used in menu did not keep light on 2012-05-07 11:30:07 +00:00
mihlit@mihlit.cz 71685e582c there are no lines to go on trainer:slave_mode
Originally, screen showed only "Slave", but cursor could
disappear when going down to seven non-existant lines
from master mode.
2012-05-07 10:10:26 +00:00
bsongis e27629ca98 AutoSwitch function in Function Switches, Mixer and Expo.
Small flash saving
2012-05-07 07:28:14 +00:00
bsongis 8f2a091fbe Bug with ID2 on simu for ARM 2012-05-07 07:06:17 +00:00
bsongis 4d953a8452 AutoSwitch corrections 2012-05-06 22:13:25 +00:00
bsongis 99a8e85bed Auto Switch is FALSE by default 2012-05-06 21:42:19 +00:00
bsongis 597d201b30 Auto Switch function (only in Flight Phases now) 2012-05-06 21:41:41 +00:00
bsongis 809e45c1e2 simu compilation for ARM 2012-05-06 20:30:19 +00:00
bsongis ca4b1b6ba3 getSwitch() was wrong on the ersky9x board (because the uint16_t is not enough for 32 virtual switches) 2012-05-06 20:26:36 +00:00
bsongis 1b2eda66d3 Switch movement detection function added 2012-05-06 17:39:58 +00:00
bsongis 9a4f9b373a Now options are stored in EEPROM 2012-05-06 16:56:05 +00:00
bsongis 801c0c2a52 Now options are stored in EEPROM 2012-05-06 14:47:18 +00:00
bsongis 2c8c1f856b KTS to KMH conversion was going over int16_t limits 2012-05-06 10:33:03 +00:00
bsongis 71daab636d Speed range was not good (1000km/h). Now 500km/h as a max. 2012-05-05 17:27:22 +00:00
bsongis 532109ba8c We were storing Min Gps speed instead of Max 2012-05-05 16:54:16 +00:00
bsongis 0174cb94d3 No Progress Bar in Main Views (Kilrah request) 2012-05-05 16:53:29 +00:00
bsongis b9c24d8ac3 Some ARM SDcard files 2012-05-05 14:17:17 +00:00
bsongis 3708915dc8 Trims audio little change 2012-05-04 22:18:34 +00:00
bsongis 9d6efd2dbd Trims now beep even when NoKey mode 2012-05-04 21:57:50 +00:00
bsongis 5321dae917 Now Haptic is as quick as on the gruvin9x v4 board! 2012-05-04 21:38:10 +00:00
bsongis 6d014ea291 ChangeLog updated 2012-05-04 20:47:14 +00:00
bsongis 5c9f7f4db8 Momentary switches bug 2012-05-04 20:38:36 +00:00
bsongis 7fa73b64bc Momentary switches bug 2012-05-04 20:25:16 +00:00
bsongis 43e675761c Test function updated 2012-05-04 18:49:59 +00:00
bsongis dc7270598c Momentary Switches fix 2012-05-04 18:39:24 +00:00
bsongis 910c44f4f3 New options added 2012-05-04 17:51:21 +00:00
bsongis 0ea75845af Momentary switches enabled in Function Switches 2012-05-04 13:36:51 +00:00
rob@marotori.com 0eb4f84ad8 Fixed small bug preventing audio pitch changing on vario on arm board. 2012-05-04 13:15:40 +00:00
gbirkus@gmail.com 0d4911a0d4 Haptic 0,1,2,3 2012-05-04 10:24:04 +00:00
bsongis 2eeedf6c55 Some more refactoring in audio / haptic 2012-05-04 10:20:59 +00:00
bsongis 82dbdb523b Haptic events 2012-05-03 20:51:14 +00:00
bsongis 65c6dddf98 Fix for companion9x 2012-05-03 19:45:27 +00:00
maxim.karban@gmail.com d033378784 comments for r685 fixed 2012-05-03 18:43:28 +00:00
maxim.karban@gmail.com fe2a5b461d VARIO_EXTENDED new feature
Limits changed:
Down speed min in range OFF,[-10.0:0] in 0.1 steps
OFF means no sound at all, this variant useful if pilot/model is aerobatic
Up speed min in range [-1.5:1.5] in 0.1 steps
strange negative values for positive vertical speeds means next:
in normal fly glider model has negative speed always, for example -1m/s
if any weak thermal flows found then vertical speed can be reduced but still negative, but it is symptom of thermal flow which can be very close!
now it is possible to detect if negative Up speed limit is set.
2012-05-03 18:35:56 +00:00
bsongis 5383549e2a SD-card more options 2012-05-03 18:23:37 +00:00
bsongis 344cf5c308 Warning on companion9x 2012-05-03 17:53:24 +00:00
bsongis 388d7eb772 Fix for companion9x 2012-05-03 17:42:22 +00:00
bsongis 9c8c447f54 Fix for companion9x 2012-05-03 17:37:02 +00:00
bsongis 523f988b16 Merge of the 2 sound_5ms() and audio.heartbeat() functions. Perhaps will be reverted, depending on what Mike thinks of it... 2012-05-03 17:28:22 +00:00
bsongis 6e201bc4b6 Some Haptic corrections 2012-05-03 17:19:06 +00:00
bsongis 8188c48d5b uint8_t again but 5+3 and 8 2012-05-03 15:05:28 +00:00
bsongis 9d2e875501 uint16_t is needed here 2012-05-03 14:59:12 +00:00
maxim.karban@gmail.com 8f20e423f6 VARIO_EXTENDED cosmetic changes
Limits are:
Down speed OFF, -10.0:0.0 in 0.1m step
Up speed 0.0:+1.5 in 0.1m step
to be continued...
2012-05-03 14:50:34 +00:00
bsongis df1107b2ea Shift in General Menus 2012-05-03 09:56:45 +00:00
bsongis 6afc680d93 Split Haptic from Audio
Vario from Max added
Tests needed on all boards!
2012-05-03 09:19:20 +00:00
bsongis b0ee619d0a Timer problem on ARM (thanks Mike!) and simu on all versions (because compiled on 32bits architectures) 2012-05-03 06:17:12 +00:00
bsongis a9243dddb9 Flash saving (844bytes!) 2012-05-02 12:58:14 +00:00
bsongis 18e6803eda Bug when moving to the top models in MODELSEL screen (v4 and ersky9x boards) 2012-05-02 07:44:18 +00:00
bsongis b4937b5e25 getGpsDistance() bug fix (thanks Mike!) 2012-05-01 21:02:52 +00:00
bsongis 14e446497d Stamps generation bug 2012-05-01 20:41:25 +00:00
bsongis f45ae2da51 Min & Max Altitude on WSHH 2012-05-01 20:20:39 +00:00
bsongis 940bb7b351 Too little array for FrSky Bars Thresholds 2012-05-01 19:50:20 +00:00
bsongis 2cc208f8a1 Missing cast in getGpsDistance() 2012-05-01 09:03:39 +00:00
bsongis 530c0f5a05 open9x compilation problem inside companion9x 2012-04-30 06:25:20 +00:00
bsongis 0937e11c2d PPM16 / PPMSIM on v4. Not tested! 2012-04-29 17:32:58 +00:00
bsongis cbdb623321 Compilation script updated 2012-04-29 14:53:36 +00:00
bsongis 76e3999de2 Compilation error 2012-04-29 14:52:25 +00:00
bsongis 021f31186a We don't use GPS for maxAltitude and minAltitude if the Baro sensor is used. 2012-04-29 14:11:31 +00:00
bsongis 9bc161e4b1 WSHH bug (conversion from meters to feet when source was feet!) 2012-04-29 13:23:17 +00:00
bsongis 94d344765d Filesystem marked as dirty on unexpected shutdown (v4.1 / ersky9x). By Michal, Thanks!
Protocol FAAST (FUTABA) removed. I will add later a configuration parameter.
PPMsim ported from er9x
2012-04-29 09:36:12 +00:00
maxim.karban@gmail.com 8868ee2686 previous version rolled back as it works with negative altitude values
which is possible at sea level and high atmospheric pressure or in Holland for example
2012-04-28 15:21:51 +00:00
maxim.karban@gmail.com 3a981ef490 evalVario() optimized 2012-04-28 14:34:16 +00:00
maxim.karban@gmail.com b813908493 VSpd bug fixed 2012-04-28 10:12:47 +00:00
bsongis d5793858b0 VSpeed displayed with PREC2 2012-04-28 07:53:13 +00:00
romolo.manfredini@gmail.com 3303846fce Save flash and cpu time 2012-04-27 23:45:55 +00:00
bsongis a84e72f4ff 6bytes flash saved 2012-04-27 23:39:47 +00:00
bsongis 5e9485b7c5 Baro Altitude Offsets were calculated on _bp when receiving _ap values. Now offsets are calculated when _bp is received and vario when _ap is received. 2012-04-27 23:27:16 +00:00
maxim.karban@gmail.com 87597c206d Alt on telemetry screen blinking fix 2012-04-27 17:49:29 +00:00
maxim.karban@gmail.com 0ca2a879af evalVario(...); before altitude offset applied, fixes VSpd jumping numbers 2012-04-27 17:23:57 +00:00
bsongis 124db1cc7f No more vario on GPS. Too poor precision. Too poor update frequency. It cannot work. 2012-04-27 16:05:04 +00:00
bsongis dc85a648d2 Vario on A1/A2 implemented 2012-04-27 15:46:55 +00:00
bsongis a2ade445ac Vario. Port from unstable branch. Part 1. 2012-04-27 15:36:17 +00:00
bsongis d39c35439a EEPROM version 208: 12bits for storing FrSky A1/A2 offset 2012-04-27 11:05:10 +00:00
maxim.karban@gmail.com 33c4363c93 SDCARD backup with empty model name works now 2012-04-27 09:02:26 +00:00
bsongis 0aa0f96346 r632 continued. Still needs tests. 2012-04-27 08:12:56 +00:00
romolo.manfredini@gmail.com 075fed796b Cut&Paste problem solved 2012-04-26 21:11:48 +00:00
maxim.karban@gmail.com cdd862f261 bugfix about SDCARD ERROR if no folder on FAT system for models
folder will be created now
if no model name assigned then an "MODELXX" hardcoded string used as name
2012-04-26 17:18:19 +00:00
bsongis 30be30212c Merge of ARM branch 2012-04-26 14:43:52 +00:00
maxim.karban@gmail.com ea53713580 Another one workaround about soft_power_off function, same as in unstable branch 2012-04-25 12:21:38 +00:00
bsongis e44dce029e Trick applied to avoid hardcoded strings 2012-04-22 13:04:44 +00:00
bsongis 802fc6e77e Warning removed 2012-04-22 13:01:54 +00:00
bsongis 9a53a256de Compile script for only v4 / stock 2012-04-21 17:54:42 +00:00
bsongis 7023c18c65 TODO list updated 2012-04-21 17:52:06 +00:00
bsongis e100ddfd8c SD card Models storage now complete, including scroll in Models List! 2012-04-21 17:50:47 +00:00
bsongis a7596c3499 SD card Models Restore now working! 2012-04-21 16:19:27 +00:00
bsongis aeca178de7 Compile script didn't unflate the Zip! 2012-04-21 14:09:51 +00:00
bsongis 4796acbd49 Bug in Rotary Encoders navigation (when choosing the Rotary Encoder with the Rotary Encoder ...) 2012-04-21 14:08:12 +00:00
maxim.karban@gmail.com 3d44f10989 bugfix about soft_power_off functionality.
never return from main() - there is no code to return back, if any daelays
occurs in physical power it does dead loop.
2012-04-21 13:56:01 +00:00
bsongis 5c675a8e0b Compile script updated 2012-04-21 10:37:19 +00:00
bsongis e7c03fa587 Bug in compile script (wrong extensions) 2012-04-21 07:15:11 +00:00
bsongis e80cd15112 Issue 20 solved 2012-04-21 06:25:34 +00:00
bsongis cf18753986 All strings shifted 2012-04-20 22:16:17 +00:00
bsongis 1a18d51869 All strings shifted 2012-04-20 22:12:51 +00:00
bsongis c50859fe62 VC++ compilation in companion9x 2012-04-20 21:58:58 +00:00
bsongis 29700853fd Compilation issue on companion9x 2012-04-20 18:24:55 +00:00
bsongis d3f6d6ea4d Compilation issue on companion9x 2012-04-20 18:22:34 +00:00
bsongis 640e5d1ed2 Compilation issue on ARM 2012-04-20 17:31:11 +00:00
bsongis 9bc18d1888 400bytes flash saved in GeneralMenus + ModelMenus
On V4.1 board both Rotary Encoder may be used for navigation
TX/RX RSSI set to 0 when no telemetry received since too long
2012-04-20 17:03:16 +00:00
bsongis f33c110340 Compile script updated 2012-04-20 10:33:11 +00:00
bsongis 7d7736703f No more binaries and stamps on svn 2012-04-20 06:58:51 +00:00
bsongis d573b1ba33 Upload on freehosting.com 2012-04-20 06:16:57 +00:00
bsongis 9deddaaecd Small corrections 2012-04-20 06:16:22 +00:00
bsongis 98e1c57db3 Multithreading added in the compile script 2012-04-19 17:04:39 +00:00
bsongis 3967d82a28 Option UNITS=IMPERIAL added
SD card archive function continued (doesn't delete the model until function finished)
Alternate view for outputs in Main Views (Bars and Numbers)
GPS speed was badly displayed (ap instead of bp)
2012-04-19 17:03:51 +00:00
bsongis 35f60e9899 Compile script bug fix 2012-04-19 06:53:21 +00:00
bsongis edc8c4cbb3 Compile script should now upload files on the FTP server 2012-04-18 20:41:46 +00:00
gbirkus@gmail.com c0cd43a250 audio change 30,20,10 sec count down timer to 3x,2x,1x beep 2012-04-18 19:52:00 +00:00
bsongis 9f378d1342 Suggestion from Cam in r559 comments now implemented:
Only if the user has the centre set at 1500us can limits past 512us be used.
AND
Only if the limit is set at 512us or lower can a centre other than 1500us be used.
2012-04-18 13:14:17 +00:00
bsongis ac38c6b0a0 Compilation error and warning with nmea and ardupilot options 2012-04-18 12:47:56 +00:00
bsongis 148f64cca1 Compilation on v4 + SD card failed 2012-04-18 08:36:53 +00:00
bsongis 1d2de3d3e0 Massive revert of the trunk to return to the last known stable version. I would like a new release soon. 2012-04-18 08:24:33 +00:00
maxim.karban@gmail.com 090b111b7a Compile fix
missed one option
2012-04-18 08:01:29 +00:00
maxim.karban@gmail.com ddc1899b71 Makefile options and letters added
# Enable Extended vario functions (V4 board only)
# Values = YES, NO
VARIO_EXTENDED = NO

and
${MODS}V
2012-04-18 07:51:39 +00:00
maxim.karban@gmail.com 91afbf2347 VARIO mod complete
returned back all previous features if without -DVARIO_EXTENDED
2012-04-18 07:20:40 +00:00
bsongis 1c9802f9ce Snapshots commited by mistake 2012-04-18 06:36:14 +00:00
bsongis c3ddf66058 Small flash saving in General Menus (60bytes)
Backlight brightness now supported on ARM
SD card archive function continued
Simu backlight support for v4
2012-04-18 06:00:03 +00:00
maxim.karban@gmail.com b3113fbcbc now it compiles as rev 556
new option in code VARIO_EXTENDED
2012-04-17 20:02:31 +00:00
maxim.karban@gmail.com 85540e1ef4 2012-04-17 18:47:49 +00:00
maxim.karban@gmail.com bb47626b67 most of previous data fields in frskyData rolled back and new prepared to pack into holes/spares
getValue() function mostly rolled back except return frskyHubData.baroAltitude_bp; changed to return frskyHubData.Altitude_show;

new variable need to remove flicks of altitude on telemetry screen, which appears on any data deleays
2012-04-17 17:53:42 +00:00
bsongis a9e4e885a1 Compilation fixed for the ARM 2012-04-17 17:24:30 +00:00
rob@marotori.com 1552a5bb51 Small update to audio to sort issues on count down timer - not tested yet as compile currently failing on sky9x board for me. Please check and let me know if sorted. 2012-04-17 17:11:35 +00:00
maxim.karban@gmail.com e4c59f402d Barometric Vario function changed
new menu items added to handle new function
sound function changed for Vario
sound driver changed to remove crisps on continues sound
frsky data structure changed to fit new variables, some spares reused
2012-04-17 16:08:54 +00:00
rob@marotori.com bcfc573312 Bug fix in audio - playASAP sending 1 to many events. So a request for 3 beeps would play 4 etc..
Fix in haptic to do correct number of vibrations on time count down.
2012-04-17 10:33:56 +00:00
bsongis 224bed6872 LIMITS menu adjustments 2012-04-17 09:20:42 +00:00
bsongis 2a4158d878 Compilation broken on the ARM 2012-04-17 08:06:42 +00:00
bsongis e0002b36bb Update of Makefile options 2012-04-16 21:08:33 +00:00
bsongis a34652e99c Revert last 2 commits 2012-04-16 18:56:34 +00:00
maxim.karban@gmail.com 938e907322 Cosmetic changes about Vario variables display/edit 2012-04-16 18:40:44 +00:00
maxim.karban@gmail.com 3aa1f1d3ed barometric Vario function changed
new menu items added to handle new function
sound function changed for Vario
frsky data structure changed to fit new variables, some spares reused
2012-04-16 18:15:08 +00:00
bsongis ec96505709 simu compilation 2012-04-16 18:11:17 +00:00
bsongis fe9afeb6a2 Haptic function by Rob should now be finished. SD card Model archive function. 2012-04-16 17:35:54 +00:00
gbirkus@gmail.com 8c6bf54cf9 LIMITS_US for offset, small wiki change 2012-04-16 15:46:27 +00:00
bsongis 4d07444bc4 New Makefile option to display the limits in us 2012-04-16 09:32:18 +00:00
gbirkus@gmail.com 25ce47aa06 or does not compile on vc++ 2012-04-16 08:23:28 +00:00
gbirkus@gmail.com 347292ca3c changing order of DOWN/UP in mix delay and slow to UP/DOWN 2012-04-15 22:43:09 +00:00
bsongis abd4de973b Makefile option renamed (EXTRA_ROTARY_ENCODERS)
Fixed a bug with option EXTRA_ROTARY_ENCODERS: mixes shifted after REb
30 models when open9x / gruvin9x board
LIMITS min and max range fixed
2012-04-15 22:34:39 +00:00
bsongis d5b386d5db New compile option FLIGHT_PHASES added. Enabled by default of course. 2012-04-14 18:30:18 +00:00
bsongis 6bc2ddc3d4 Issue 19 solved
Revert the last Haptic changes (was unfinished, no more spare time during the week-end, sorry!)
Revert my last modification on main views (offset not displayed in Bar Graphs, I was wrong)
PPM Center now configurable for each servo
No mean on the Batt voltage when in the calibration menu to have a faster response when calibrating
SD card Backup / Restore Models feature started
Some french translations fixed
2012-04-14 11:32:40 +00:00
romolo.manfredini@gmail.com bedc673b98 General menu fixup 2012-04-13 20:46:10 +00:00
romolo.manfredini@gmail.com 1da0ad3926 Fix Makefile for haptic 2012-04-13 20:17:20 +00:00
romolo.manfredini@gmail.com 7553ec4dd4 Reverted Makefile to stock board 2012-04-13 19:20:56 +00:00
romolo.manfredini@gmail.com 2af7e34ee2 Reversed Makefile to stock board 2012-04-13 18:58:02 +00:00
romolo.manfredini@gmail.com f7e1d86949 wrong variable type 2012-04-13 15:11:29 +00:00
maxim.karban@gmail.com ec5363abbc Inverse switch values starting timers now as well as normal values 2012-04-13 13:40:59 +00:00
rob@marotori.com 304a7018d3 Compiler fix 2012-04-13 13:24:59 +00:00
rob@marotori.com f632dd11fa Commit again as files did not go up! 2012-04-13 13:01:47 +00:00
rob@marotori.com 223677c7ff Files missed in last commit! 2012-04-13 12:55:26 +00:00
rob@marotori.com f7b1754257 Major patch to split haptic and audio queues into separate systems.
Patch is testing and working on the sky9xboard and the stock board.  I dont have a gruvin board to test on.

Currently only events that trigger haptic alerts are WARNING1-3 and TRIM MIDDLE.  

Next step is for bertrand to use the hooks to enable a per alert option to choose enable haptic.

Also... translations are added but the menu file does not use the translation yet - as I have not got my head round how this works!
2012-04-13 12:22:04 +00:00
bsongis f59d7a3836 A MOD char is really needed for the Extra Rotary Encoders Mod! 2012-04-13 07:11:04 +00:00
bsongis 46e7f90b34 One #ifdef less ... 2012-04-13 07:05:19 +00:00
bsongis 22bed6212b PPM Pulses small flash saving by Mike 2012-04-12 22:23:55 +00:00
maxim.karban@gmail.com 8b11cbe549 Beep on center fixed for rotation encoders 2012-04-12 20:48:57 +00:00
maxim.karban@gmail.com 80ab800ec3 2012-04-12 14:00:55 +00:00
rob@marotori.com f9bacfd453 delay on haptic shutdown to allow motor time to spinup! 2012-04-12 12:17:39 +00:00
maxim.karban@gmail.com 6cacc7f2c7 Init of MOD_EXTRA_ROTARY_ENCODERS and ISR(USART2_RX_vect) code moved to board_gruvin9x.cpp 2012-04-12 10:29:53 +00:00
maxim.karban@gmail.com f350666920 Final MOD_EXTRA_ROTARY_ENCODERS patch applied 2012-04-12 07:31:12 +00:00
bsongis b87f321cae Offsets should not be taken into account in Bars / Values in the Main Views (idea from Cam, thanks!) 2012-04-12 06:50:01 +00:00
gbirkus@gmail.com 3279b2ef67 shade RX/TX to use only first RSSI alarm, Inverting Temrerature DOTTED bars, correcting TELEM_TM1 to TELEM_TM2 2012-04-11 20:09:54 +00:00
bsongis 80867a9b3b Cosmetics 2012-04-11 19:23:40 +00:00
bsongis ddcf6db9f7 FrSky flash saving (64bytes)
Condensed display of Mixers lines in MIXER menu (by Max)
MOD_EXTRA_ROTARY_ENCODERS added (by Max): on v4.1 it adds the support of an extension board for 3 more rotary encoders
2012-04-11 18:38:59 +00:00
bsongis 9de279b819 TODO added to not forget ... 2012-04-11 14:40:59 +00:00
gbirkus@gmail.com 6eb5a47cdb DOTTED RSSI bars 2012-04-11 13:56:40 +00:00
bsongis 96cf8df98e Corrections by Max 2012-04-11 13:33:46 +00:00
bsongis d057d1f441 NMEA warning removed 2012-04-11 13:30:32 +00:00
romolo.manfredini@gmail.com 16cf012583 Stamp for new binaries 2012-04-11 08:49:22 +00:00
romolo.manfredini@gmail.com 7807afa13d New binaries 2012-04-11 07:47:50 +00:00
bsongis 0ccedb4f42 New ARM binaries 2012-04-10 22:55:50 +00:00
bsongis 80d36a783f Slave mode was always enable (ersky9x board) 2012-04-10 22:45:55 +00:00
bsongis c49f31748c companion9x VC++ compilation 2012-04-10 22:07:21 +00:00
bsongis 2c14066675 DSM2 pulses throws adjusted when DSM2_SERIAL as DSM2_PPM 2012-04-10 20:55:11 +00:00
bsongis 039b76179a DSM2 pulses throws adjusted 2012-04-10 20:02:17 +00:00
bsongis 7b969e2f62 DSM2 pulses throws adjusted 2012-04-10 19:12:49 +00:00
bsongis 7647fea036 Batt calib on all boards ... 2012-04-10 18:56:30 +00:00
bsongis 49a828877a PPM Pulses adjustment by Cam 2012-04-10 18:35:09 +00:00
bsongis 395ecaff7e zip commited by error 2012-04-10 18:21:47 +00:00
bsongis 10a29a676e Bug in Mixer when offset used with a switch + slow down
GPS displayed as ---- when there has no fixed received since beginning
No Custom telemetry screen displayed when nothing to display
Marks at -100 and +100 when editing a value
RSSI alarms 1 + 2 labels were wrong
ANAS menu redesigned
60 models on ersky9x board
Current calibration on ersky9x board
2012-04-10 18:20:51 +00:00
kjell.kernen@gmail.com 41cafa4d98 Translated new strings and telemitry changes. 2012-04-10 08:53:07 +00:00
bsongis 8933184c2d New arm binaries 2012-04-09 15:04:57 +00:00
bsongis 3b2a05016e Speaker Volume and backlight Bright now configurable 2012-04-09 14:21:57 +00:00
bsongis c344bfd6ce The Minutes in Time contained in the stamp was wrong (%I instead of %M) 2012-04-08 14:26:29 +00:00
bsongis 3a0f5b155e No error during make stamp on ARM 2012-04-07 22:26:01 +00:00
bsongis 15987815a8 Ignore list updated 2012-04-07 10:58:26 +00:00
bsongis d91bd29d58 New ARM binaries and stamp 2012-04-07 10:53:45 +00:00
bsongis ccce2d88b8 Stick mode bug on ARM 2012-04-07 10:40:32 +00:00
bsongis ebf2f86eb5 New ARM binaries and stamp 2012-04-07 09:11:49 +00:00
bsongis 70fb17a9f4 Different stamp for ARM board 2012-04-07 08:31:22 +00:00
bsongis 6cae60940c 2012-04-07 08:22:53 +00:00
bsongis 8c0c30e371 New arm binaries 2012-04-07 07:53:41 +00:00
bsongis 54c1ed1997 Optrex LCD support 2012-04-07 07:35:23 +00:00
bsongis 5d5bfec63d Compilation problem in companion9x 2012-04-06 18:13:50 +00:00
bsongis 69b84d865c Compile script updated 2012-04-06 17:08:23 +00:00
bsongis 9a484408f6 Audio + Haptic port from ersky9x 2012-04-06 17:05:52 +00:00
gbirkus@gmail.com f08e201045 Haptic123 will be different. 2012-04-06 14:52:06 +00:00
bsongis af3f17a8ae First Arm binaries 2012-04-06 08:44:11 +00:00
bsongis 9448363b95 Compilation script updated 2012-04-06 07:42:33 +00:00
bsongis a5086a0e83 Companion9x / Simu bug 2012-04-06 06:46:45 +00:00
romolo.manfredini@gmail.com 8bb66b489b Stamp for new binaries 2012-04-05 22:50:17 +00:00
romolo.manfredini@gmail.com 9d9e69f22d New binaries 2012-04-05 21:47:34 +00:00
bsongis 1828d06122 Compilation problem on 64bits servers 2012-04-05 19:47:04 +00:00
bsongis 576c1ae47b Compilation problem on 64bits servers 2012-04-05 19:16:20 +00:00
bsongis ea4bba0dea Warning solved (thanks gbirkus)
Issue 18 (thanks Paul) fixed
2012-04-05 16:53:48 +00:00
bsongis 2623aa00ed Make companion9x compile with recent changes 2012-04-05 07:12:03 +00:00
bsongis e7d404fff4 Missing file 2012-04-03 21:09:01 +00:00
bsongis ab07e8d099 Wrong message displayed in checkSwitches 2012-04-03 20:35:19 +00:00
bsongis 5778f06b1f 6 bytes saved by Romolo 2012-04-03 20:30:53 +00:00
bsongis 0be7d4a671 Rotary encoders Beep Center should be ok now
More port from ersky9x
Problem in Telemetry labels for french and swedish
2012-04-03 18:01:05 +00:00
bsongis d970ddc9b4 Make companion9x compile with recent changes 2012-04-03 08:22:54 +00:00
bsongis 0a3f3d6c6b USB mode ok on ersky9x REVB 2012-04-03 07:22:02 +00:00
bsongis d0cb3bb51c Rotary encoders in Mixer 2012-04-02 19:46:48 +00:00
bsongis 8c6a2bdada Rotary encoders in Mixer 2012-04-02 19:45:31 +00:00
bsongis d311818604 Rotary encoders in Mixer 2012-04-02 19:40:36 +00:00
bsongis 531f093514 Compilation problem on ersky9x Rev A 2012-04-02 18:03:43 +00:00
bsongis e7c785105d EEPROM version needs to be incremented for V4 board 2012-04-02 18:03:07 +00:00
bsongis 01d05d7d96 Flash on Beep doesn't beep on Keys / Trims
TH% not inverted when throttle stick inverted
Rotary Encoders as Mixer Sources on v4 board
Pulses on ersky9x board port
Telemetry on ersky9x board port
2012-04-02 17:31:40 +00:00
romolo.manfredini@gmail.com b31b040903 Fix regression 2012-04-02 09:22:28 +00:00
romolo.manfredini@gmail.com 53040ba48a 10 bytes spared (46 on GCC 4.6.2) 2012-04-01 16:29:05 +00:00
romolo.manfredini@gmail.com 66b7c537c5 Flash lcd always on event if flash on beep is enabled (GBirkus suggestion) 2012-04-01 13:43:29 +00:00
romolo.manfredini@gmail.com 18879a301a Flash lcd only on playNOW to spare battery on battery warning 2012-04-01 10:52:36 +00:00
romolo.manfredini@gmail.com 736d0fa10e Better flash on beep for audio mod (saves bytes) 2012-04-01 10:29:09 +00:00
romolo.manfredini@gmail.com 1052e9f36c Flash on beep for audio mod 2012-04-01 10:24:53 +00:00
romolo.manfredini@gmail.com 426ceff2e9 Flash on beep mod and byte saving 2012-03-31 21:19:24 +00:00
romolo.manfredini@gmail.com 9199b7980f Disable gps indication when HUB Protocol=none 2012-03-31 00:01:58 +00:00
romolo.manfredini@gmail.com 95b77c1524 Better fix for compilation issues in companion 2012-03-30 18:28:51 +00:00
romolo.manfredini@gmail.com b18b6505f3 Fix compilation issue in companion 2012-03-30 17:41:51 +00:00
bsongis e7eaced156 Soft Power Switch on both v4.1 and ersky9x boards
Delay before effective EEPROM write on these boards
Current displayed
2012-03-30 16:03:43 +00:00
bsongis 6113420a02 EEPROM Swap / Copy / Delete model now Ok on ErSky9x
Simu target on ARM now ok
2012-03-29 18:29:49 +00:00
kjell.kernen@gmail.com 0cf23e266d Translated the new GPS Coordinates text string to Swedish 2012-03-29 14:01:13 +00:00
romolo.manfredini@gmail.com 3f4e5004a4 Missing binaries 2012-03-29 11:49:30 +00:00
romolo.manfredini@gmail.com d9a7ceeedd Stamp for new binaries 2012-03-29 08:08:52 +00:00
romolo.manfredini@gmail.com 7538153d0f New binaries 2012-03-29 07:31:13 +00:00
bsongis b39f5fcac2 Beeps on THR and SWITCH alerts 2012-03-28 19:24:17 +00:00
bsongis 2007b88ae1 Function rename 2012-03-28 18:51:03 +00:00
bsongis 9c16acb445 Badly displayed fields in Trainer Screen (thanks gbirkus!)
InstantTrim should work also in Telemetry View
Trims2Offsets function ok with Flight Phases
New Makefile option EEPROM_PROGRESS_BAR
Many flash savings ...
2012-03-28 17:01:58 +00:00
bsongis c63c467182 When not thrTrim, the throttle trim may be resetted 2012-03-27 20:09:14 +00:00
bsongis a211de6bc1 Missing translations 2012-03-27 19:26:48 +00:00
bsongis e2824aaec4 Light of after N seconds was broken (thanks gabriel again!) 2012-03-27 18:21:22 +00:00
bsongis 5f5fc14c19 [MENU SHORT] on Trims => Offsets line was entering into edit mode 2012-03-27 18:10:27 +00:00
bsongis 2acfb7df3d Trims to Offsets re-implemented (still untested)
FrSky flash saving
2012-03-27 17:56:43 +00:00
romolo.manfredini@gmail.com ee1bd73788 Add GPSCOORD to setup menu 2012-03-27 16:01:25 +00:00
romolo.manfredini@gmail.com bb0bdae2fd Missing strings 2012-03-27 15:38:16 +00:00
romolo.manfredini@gmail.com ec170cce04 Support for different GPS coordinates 2012-03-27 15:28:13 +00:00
romolo.manfredini@gmail.com 9a7861eaad Support for different GPS coordinates 2012-03-27 15:15:43 +00:00
romolo.manfredini@gmail.com c28f7bfc9a Support for different GPS coordinates 2012-03-27 12:27:17 +00:00
bsongis 0a292381e1 Bug in MixWarning when Switches are sources. Negative differential now allowed 2012-03-25 10:37:02 +00:00
bsongis 39f14cdaae Makefile simplification 2012-03-24 08:53:07 +00:00
bsongis ce3db201ff Mavlink compilation problem 2012-03-24 07:50:20 +00:00
bsongis 35ba45c1d5 Makefile now ok with the ersky9x board 2012-03-23 23:46:41 +00:00
bsongis bdda7c3ddf Makefile now ok with the ersky9x board 2012-03-23 23:03:27 +00:00
bsongis 3016192052 No stack_free on the ARM 2012-03-23 22:24:08 +00:00
romolo.manfredini@gmail.com 30b8497b1e Fix for reverse throttle tracing 2012-03-23 19:02:45 +00:00
bsongis e3d9a29765 Infinite loop on ARM in lcd_putcAtt 2012-03-23 18:00:07 +00:00
kjell.kernen@gmail.com 5ff76b29b9 Swedish translation of Latitude/Longitude.
Swedish tranlations of constant names for telemitry screens.
2012-03-22 16:25:14 +00:00
bsongis a26ae476ce Compilation problems in companion9x 2012-03-22 15:14:04 +00:00
bsongis 1ad8a84201 Make clean updated 2012-03-22 14:25:11 +00:00
bsongis 8d30efddc5 Refactoring 2012-03-22 14:22:57 +00:00
romolo.manfredini@gmail.com 9ef6e139f7 Open9x stamp 2012-03-22 13:01:30 +00:00
romolo.manfredini@gmail.com 9498debf6d New binaries 2012-03-22 08:03:44 +00:00
romolo.manfredini@gmail.com 21571b0050 Compilation fix for companion 2012-03-22 02:31:54 +00:00
romolo.manfredini@gmail.com dfdb4bbade Fix compilation issues 2012-03-22 00:59:36 +00:00
bsongis 629480d4ae VarioSpeed inverted! 2012-03-21 20:51:06 +00:00
bsongis abe7cb1366 Vario beeping even in NOKEY mode ... 2012-03-21 20:23:32 +00:00
bsongis 326ea5cfb8 Vario Speed 2012-03-21 20:13:14 +00:00
bsongis cdf61de493 Vario Speed 2012-03-21 20:00:54 +00:00
bsongis 2e5cf5a4f3 Small RAM saving.
Some code ported for the ersky9x board
Mavlink port commited
2012-03-21 18:31:00 +00:00
bsongis 45c685fab7 Vario is in centimeters / second 2012-03-20 22:09:07 +00:00
bsongis 15c73e1ece Dotted border around voltage on v4.1 2012-03-20 21:34:48 +00:00
bsongis da83ed3f34 Dotted border around voltage on v4.1 2012-03-20 21:27:15 +00:00
bsongis 9e7d832d38 Flash saving (especially for swedish!) 2012-03-20 20:47:42 +00:00
bsongis 0edbc8555b VSpd added to Telemetry Custom View 2012-03-20 19:22:59 +00:00
bsongis 25cd34ef29 VSpd added to Telemetry Custom View 2012-03-20 19:19:44 +00:00
bsongis 01fd9d719e Vario can be negative! 2012-03-20 19:03:06 +00:00
bsongis a7a530487b Vario (still untested). Flash savings. 2012-03-20 18:48:05 +00:00
bsongis 32b6726968 Temperature threshold missing 2012-03-19 21:51:52 +00:00
bsongis 16bf388c30 I revert my last change on pulses started as soon as the radio is on for FAAST and DSM2. Now only the splash screen is removed in these both cases. Security is saved. 2012-03-19 21:20:17 +00:00
bsongis 5f56761842 Small code adjutments 2012-03-19 21:11:29 +00:00
bsongis 61f56ab915 Temperature threshold missing
Time alignement for Bars
2012-03-19 20:47:31 +00:00
bsongis 4b3e743520 Temperature badly displayed in bars 2012-03-19 20:12:41 +00:00
bsongis f0dc2e9a8c New compile script 2012-03-19 18:09:44 +00:00
bsongis 0611c1de96 Mavlink introduction
Templates bug fix
2012-03-19 16:12:36 +00:00
bsongis 695ecf7a0d Telemetry Screens again! 2012-03-18 22:36:11 +00:00
bsongis 2b5eb64540 Bad display of 1.xx (the decimap point was inside the 1 before) 2012-03-17 15:20:14 +00:00
bsongis f12dcd7365 a1 and a2 correctly displayed 2012-03-17 14:09:45 +00:00
bsongis 1144d93c43 Timers in Status Bar of Custom Telemetry View now well displayed 2012-03-17 11:39:05 +00:00
bsongis 5961611dfe Timers in Custom Telemetry View 2012-03-17 08:16:49 +00:00
bsongis 31a5104730 Trick to avoid remaining printf in code ... 2012-03-17 00:01:53 +00:00
bsongis ccca6ed24f Flash saving 2012-03-16 23:52:25 +00:00
bsongis f281fcb920 Gauges Min and Max units were wrong 2012-03-16 23:34:48 +00:00
bsongis 7fa15005ab Cell value and negative Acc were wrong on Custom Telemetry View 2012-03-16 23:04:54 +00:00
bsongis 09caf6afae Vertical line sometimes missing in Custom Telemetry View 2012-03-16 22:05:31 +00:00
bsongis 43c3982d09 Correct maximums for Telemetry inputs in Custom Switches 2012-03-16 21:37:16 +00:00
bsongis 42f71da725 Now 6bits per field in Custom Telemetry View 2012-03-16 20:58:24 +00:00
bsongis 46cffb0660 Cell introduced in Custom Switches 2012-03-16 20:10:22 +00:00
bsongis 9add1b4326 Min Cell and Max Cell removed 2012-03-16 19:40:00 +00:00
bsongis f795510e0c Correct maximums for Gauges
Flash saving
2012-03-16 19:16:39 +00:00
bsongis 052252ae37 Bad alignement in the last Telemetry screen 2012-03-16 18:24:04 +00:00
bsongis d8ff75c147 Missing translations 2012-03-16 18:08:11 +00:00
bsongis f7b8eeeec5 More fields displayed in Custom Telemetry Screen
Vario Function Switch (first part)
2012-03-16 17:56:44 +00:00
bsongis 8477f99762 DSM2 protocol also starts pulses before the splash 2012-03-15 20:26:07 +00:00
bsongis daff24615a A1/A2 decimal point badly displayed in the new telemetry screen 2012-03-15 20:09:11 +00:00
bsongis b30216b4c0 TODO / Changelog updated 2012-03-15 19:26:15 +00:00
bsongis 66f12ab76b Compilation error 2012-03-15 18:51:32 +00:00
bsongis 8e696b222e Warning solved 2012-03-15 18:40:05 +00:00
bsongis 0fdb85067a Custom Telemetry View
FAAST protocol (start pulses before the splash)
Templates Confirmation
Used channels cleaned before applying a template
2012-03-15 18:37:18 +00:00
romolo.manfredini@gmail.com ba2a9d7f34 Todo updated 2012-03-15 18:29:43 +00:00
romolo.manfredini@gmail.com 9512053d69 Fix compilation issues on GCC 4.6.2 2012-03-15 18:05:07 +00:00
bsongis 3cb1ffc153 TODO list, first version 2012-03-15 06:35:37 +00:00
bsongis ce68d6d77d Potscroll option added 2012-03-15 06:22:50 +00:00
bsongis 357b87a281 Fix for gcc 4.7.0 memcpy alignment bug 2012-03-15 06:16:58 +00:00
bsongis d6828c284a Don't use the BUILD_DIR for SVN_STR. 2012-03-14 06:58:57 +00:00
romolo.manfredini@gmail.com e2658c9a1b stamp for open9x 2012-03-14 02:11:17 +00:00
romolo.manfredini@gmail.com 438255df43 Build r364 - Fix backup-restore warnings in companion 2012-03-14 01:46:31 +00:00
bsongis c493240343 Slow down and Delay in Mixers commited again 2012-03-13 21:50:38 +00:00
romolo.manfredini@gmail.com 8ca4750f0f Stamp for binary release 2012-03-13 20:17:13 +00:00
romolo.manfredini@gmail.com 4ea539e69d r361 binaries 2012-03-13 20:06:26 +00:00
bsongis c63fd0605f Cosmetics 2012-03-13 19:02:33 +00:00
bsongis b7bf67c057 FrSky Hub Data remained 0 2012-03-13 18:42:09 +00:00
bsongis 8704c61e81 Revert last modification to recompile everything 2012-03-13 06:40:07 +00:00
bsongis 555d478d94 Slow down and Delay in Mixers rewriten 2012-03-12 21:40:46 +00:00
romolo.manfredini@gmail.com c375ac0713 Revert compile.py to previous version 2012-03-12 20:15:05 +00:00
romolo.manfredini@gmail.com 685b637c37 Stamp for r353 binaries 2012-03-12 20:11:32 +00:00
romolo.manfredini@gmail.com 54b00d5966 r353 binaries 2012-03-12 19:44:42 +00:00
bsongis d83a755a21 Problem when deleting all mixes from a model 2012-03-12 17:08:23 +00:00
romolo.manfredini@gmail.com 2786a7f3ba Stamp for open9x 2012-03-11 23:57:07 +00:00
romolo.manfredini@gmail.com 44b761dc17 GCC 4.6.2 Build 2012-03-11 23:21:23 +00:00
bsongis ad1c06c392 12bytes saved 2012-03-11 14:06:51 +00:00
bsongis b6de4538fb Altitude may now be negative (because offset is added each time we receive a new value) 2012-03-11 14:04:55 +00:00
bsongis 74f5cba651 Altitude may now be negative (because offset is added each time we receive a new value) 2012-03-11 13:27:18 +00:00
bsongis d4fb419f4c Slave screen did allow editing everything even if nothing displayed 2012-03-10 10:16:02 +00:00
bsongis d3c15495c2 Stamps for open9x and companion9x 2012-03-10 10:08:13 +00:00
bsongis 8b6659b517 New binaries 2012-03-10 09:37:42 +00:00
bsongis cf68258531 Fix for slow / delayed mixes
Telemetry screens redesigned
2012-03-09 21:11:54 +00:00
bsongis 55de51acb9 TODO removed 2012-03-09 17:43:11 +00:00
bsongis 84b2d2b9ac Confirmed by Cam, no more TODO there 2012-03-09 17:42:28 +00:00
bsongis c27a086c5d Bug in decimal point display on numbers when blinking 2012-03-09 17:41:43 +00:00
bsongis 6f17631ae8 Bug with the "-" char in negative numbers 2012-03-08 20:55:33 +00:00
bsongis 26cdf24ca0 New "Test" function switch (make DEBUG=YES)
New "Reset" function switch
TimeZone for GPS
BLINK attribute may be used without INVERS
Wrong first frame sent when DSM2=SERIAL (by Cam)
Text in status line blinking when NO DATA on FrSky telemetry screen
2012-03-08 18:44:48 +00:00
bsongis ac83640093 Wrong uint16_t in FrSkyData struct making VC++ compiler produce wrong EEPROMS 2012-03-08 09:19:37 +00:00
bsongis 7614ff24ab Stamps for companion9x and open9x 2012-03-07 07:31:00 +00:00
bsongis cfdc8806f9 New binaries 2012-03-07 07:19:01 +00:00
bsongis f19e150bd0 New binaries 2012-03-07 06:47:08 +00:00
bsongis 8c311f9f40 Issue 12 (swedish translations) 2012-03-06 19:50:52 +00:00
bsongis 47a228611c Problem in recursive mixes 2012-03-06 19:20:52 +00:00
bsongis ab7fa5575e Swedish added in compile script 2012-03-05 17:13:57 +00:00
bsongis 5923ed5e1e Bug when using Switches as Mix inputs 2012-03-05 15:42:31 +00:00
bsongis 228fb38b67 Let's remove Telemetry from Mixer sources 2012-03-05 08:48:27 +00:00
bsongis 6415b50638 Fixed a bug in template "Servos test" 2012-03-05 07:02:12 +00:00
bsongis 3984e3cac5 Updated Swedish translations 2012-03-04 22:53:14 +00:00
bsongis d8f74f2c8e ChangeLog + I forgot to commit xbm2lbm 2012-03-04 19:49:55 +00:00
bsongis 402eb726d2 GPS distance fix 2012-03-04 17:59:12 +00:00
bsongis a180d836ae GPS distance now ok on simu / c9x 2012-03-04 17:54:52 +00:00
bsongis 040160efc9 New EEPROM format 205
Introduction of differential in Mixers
Introduction of Switches as Mixer Source (FULL now removed)
Negative curves in Mixers
Optimizations in Mixer
Extended chars for localization
Swedish translations
Beep length updated
2012-03-04 17:25:35 +00:00
mihlit@mihlit.cz ab6f9108b0 make gcc error reporting better readable
Originally, gcc would report that error is present on line 5432
in allsrc.cpp. This would not help much. We can use gcc preprocessor
marks to make it report line number of original file together with
its file name.
2012-03-03 09:07:20 +00:00
bsongis e5a949334d Changelog updated 2012-03-02 08:26:17 +00:00
bsongis 5b41b980f6 Label "MAX" for mixers source changed to "HALF". Idea pulled from er9x. 2012-03-02 08:15:51 +00:00
bsongis c03950c0fa Label "MAX" for mixers source changed to "HALF". Idea pulled from er9x. 2012-03-02 08:14:58 +00:00
bsongis 30cd6bf15d Mutliplier missing when trim used as a source (as if it was a slider). To use this feature, set MIXER source = THR and Trim = Offset for example. 2012-03-01 21:49:26 +00:00
bsongis bd7ab010ca FrSky did introduce 2us jitter since last optimization
Makefile minor update
Google tests fixed
Momentary switches in FUNC SWITCHES screen (not finished)
Trim parameter in Mixer is OFF if the source is not a stick
2012-03-01 21:10:18 +00:00
bsongis 71e2456371 New binaries 2012-03-01 06:46:37 +00:00
bsongis 834357fb4f Another Makefile cleaning 2012-02-29 21:50:13 +00:00
bsongis 68c7aa108a Some cleaning in the Makefile, and 616bytes flash saved, thanks to Michal idea! 2012-02-29 20:39:15 +00:00
bsongis b5dbe135e7 Center Beep was too long (Issue 4)
Inactivity Beep was too long
Vibrations now possible on key press
2012-02-29 19:10:13 +00:00
bsongis fcb678a11f Issue 4 solved (Beeps too long for MIX CENTER) 2012-02-29 07:36:05 +00:00
bsongis 8496624617 [FrSky] NO DATA displayed on the status line when needed 2012-02-29 07:12:12 +00:00
bsongis 46b17b8d91 Invert lines in EXPO submenu (in order to have conditions all together)
Translations updated
2012-02-28 22:44:26 +00:00
bsongis d1689d3e81 French documentation 2012-02-28 18:09:04 +00:00
bsongis cbd475cc30 Vibration when MIN / MIDDLE / MAX trim position reached 2012-02-27 21:19:31 +00:00
bsongis 10e62f5828 Changelog updated 2012-02-27 19:08:58 +00:00
bsongis 6c1d0cab8a Flash saving (idea from er9x)
Trims2Offsets function removed as it was as full of bugs than other firmwares (total = ~1000bytes flash saved)
A "Safety CHxx" function is not applied when it is currently edited
The Stick Mode needs confirmation before being used (now edited with [MENU] edit [MENU]).
2012-02-27 18:52:29 +00:00
bsongis 0826ceada1 [MENU] in FrSky views now resets telemetry data. 2012-02-27 08:10:53 +00:00
bsongis e9dc2e26aa Pat Mackenzie added to the coders list as suggested by Mike in 9xforums 2012-02-27 07:33:11 +00:00
bsongis 36c2991c2f New binaries 2012-02-26 09:31:29 +00:00
bsongis 3c40237cc6 moveTrimsToOffsets function did take into account the THR stick 2012-02-25 22:27:07 +00:00
bsongis 5c52b74574 Circular inclusions removed 2012-02-25 17:56:46 +00:00
bsongis 7e39ccf80c More efficiency in eeprom write on simu 2012-02-25 10:57:42 +00:00
bsongis e91ac3d7cf New way of dealing with recursive mixers and Flight Phases which saves ram... 2012-02-25 10:57:02 +00:00
bsongis a88e168b69 Circular inclusions removed 2012-02-25 00:04:10 +00:00
bsongis 01240715a7 Telem. Screen function removed. Too dangerous, may block the radio in this screen... 2012-02-24 18:11:42 +00:00
bsongis af677d03e4 Unused function declaration removed 2012-02-24 18:10:15 +00:00
bsongis 7de3ce7d13 Cosmetics 2012-02-24 18:09:20 +00:00
bsongis a094fd9ba2 Throttle trace with P1-3 should now be ok
Problem with recursive mixers and Flight Phases
2012-02-24 18:08:27 +00:00
bsongis 16d35bfd99 V4 BandGap should be initialized for alow the voltage to settle quickly 2012-02-23 22:09:45 +00:00
bsongis 983fb132e2 Bad voltages on simu V4 2012-02-23 21:33:54 +00:00
bsongis 4200c203b6 PXX updates + optimizations pulled from er9x
FrSky TELEMETRY menu is now moved to [DOWN long]
Function added to reach the TELEMETRY screen when a switch is enabled
Main view optimizations
2012-02-23 18:09:27 +00:00
bsongis 0a1b7a39bf Allow 4 blades 2012-02-22 21:03:48 +00:00
bsongis 76406f1f9c Some new fields now inflight modifiable: DR/EXPOS expo / weight, MIXER weight / offset 2012-02-22 17:56:38 +00:00
bsongis 1446ae8ada Make it compile on VC++ 2012-02-21 22:50:16 +00:00
bsongis eba1924a08 Make it compile on VC++ 2012-02-21 22:48:57 +00:00
bsongis cdc2beb202 Bug when editing phase names with Rotary Encoder 2012-02-21 21:47:46 +00:00
bsongis 6a1f12281c Batt voltage should be better on v4 2012-02-21 20:24:57 +00:00
bsongis b72f9ef1b8 Changelog updated 2012-02-21 19:30:16 +00:00
bsongis 4e484ad656 New binaries 2012-02-21 19:01:59 +00:00
bsongis 6f1f234b40 Logs port from gruvin9x
JETI ok on simu
Sticks mode problem in Trims2Offsets function
PXX bug fix pulled from er9x
Optimizations
2012-02-21 16:36:57 +00:00
bsongis 97723c5732 GPS last coords always displayed even if fix lost (in case model crashed) 2012-02-20 22:33:12 +00:00
bsongis e2088df620 Typo fixed 2012-02-19 23:16:20 +00:00
bsongis f71eb46023 Inflight parameters modification.
Last Telemetry parameters still displayed even if NO DATA (after something has been received)
2012-02-19 23:08:01 +00:00
bsongis 6cd32e7bd6 Cosmetics 2012-02-19 22:46:37 +00:00
bsongis 5d557c73e8 Double test removed 2012-02-19 22:30:42 +00:00
romolo.manfredini@gmail.com e5161c9622 Accel data displayed wrong 2012-02-18 22:31:15 +00:00
bsongis 5323106a1a Compilation problem 2012-02-18 09:02:40 +00:00
bsongis 33e30b8fef Inflight parameters modification using Rotary Encoder on v4 (not finished yet). 2012-02-18 08:58:05 +00:00
romolo.manfredini@gmail.com 9997b8c599 Frsky V2 HUB protocol variometer fix 2012-02-17 23:37:30 +00:00
romolo.manfredini@gmail.com 63edd26442 Fix compilation problems 2012-02-17 18:47:55 +00:00
romolo.manfredini@gmail.com b4870d1e04 Cell voltage reading fix 2012-02-17 18:37:53 +00:00
bsongis 26f1a5706b Another 100bytes flash saved + 16bytes RAM in LIMITS menu. 2012-02-17 18:12:01 +00:00
bsongis a5fef987df Flash saving: around 100bytes (saved in TRAINER menu). UNSTABLE_BANDGAP option removed (always used). Keys react a little better in simu. 2012-02-17 17:01:52 +00:00
bsongis a8167c5e0c A little commit between two snow balls fight to warm the hands: this is the way that Cam proposed to exit submenus with Rotary Encoders. Still remaining: the Curve submenu. Ideas needed ;) 2012-02-17 15:11:02 +00:00
bsongis b40aff1058 Warnings removed 2012-02-17 08:07:37 +00:00
bsongis 1ed8d7ca44 Compilation problem when !FRSKY
Rotary encoder navigation on v4
Some cleaning on code
2012-02-16 22:40:02 +00:00
bsongis 03fd1e3b01 RSSI alarms are now stored in ModelData. Alarms disabled on Quiet mode, re-enabled when not Quiet mode. 2012-02-16 17:55:23 +00:00
bsongis e7e7a6ca97 On stock board the Quiet mode was not working 2012-02-16 17:53:28 +00:00
bsongis 8057d13c22 No more FrSky alarms when radio is asked to be quiet 2012-02-16 13:14:31 +00:00
bsongis c4147980c9 Beeper mode is now splitted from beeper length. Haptic mode added. Haptic only sounds now ok on v4. 2012-02-16 13:12:35 +00:00
bsongis a021b66a9b GPS distance is uint16_t 2012-02-15 21:02:03 +00:00
bsongis f98585acbe Lipo cells voltage badly displayed. Some flash saved. 2012-02-15 21:00:57 +00:00
bsongis 4bd49938f3 Added a SOMO function with track number 0-255 2012-02-15 17:45:38 +00:00
bsongis 0c8cea428d No instantTrim on THR stick 2012-02-14 21:32:58 +00:00
bsongis cd057686ef Blades count for RPMs. Reordering of the TELEMETRY screen 2012-02-14 18:23:46 +00:00
romolo.manfredini@gmail.com 65621cae81 GPS Distance calculation fix 2012-02-14 15:41:22 +00:00
romolo.manfredini@gmail.com 99be733e29 GPS Distance calculation fix 2012-02-14 10:14:02 +00:00
bsongis 6e4a9ff05c SOMO header included in open9x.h 2012-02-14 09:15:46 +00:00
th9xer d8a5ee4e1d Fix haptic DDR error on V4 and fixing the SOMO14D code. 2012-02-14 00:45:36 +00:00
romolo.manfredini@gmail.com 5a28372850 GPS reported speed fix 2012-02-12 16:10:23 +00:00
romolo.manfredini@gmail.com 1219c9ca17 GPS distance calculation fix 2012-02-12 15:34:23 +00:00
bsongis 2204c7523a Copyright notice updated 2012-02-10 16:33:08 +00:00
bsongis 47955a3527 Latest binaries 2012-02-10 13:27:49 +00:00
bsongis 0e3675a1b6 GPS distance 2012-02-10 09:24:32 +00:00
bsongis 80ee43db71 GPS maths prepared on GPS fix. Still needs to be tested! 2012-02-09 23:04:08 +00:00
bsongis 8aee92218d GPS distance algorithm. To be used later. 2012-02-09 22:56:09 +00:00
bsongis f93bca77ce PXX compilation error on last gcc version 2012-02-09 11:25:21 +00:00
bsongis 11c8219f79 Multiplier added to FrSky telemetry A1/A2 ratio
Now it covers range 0V => 204.0V
2012-02-09 11:24:45 +00:00
bsongis a9ac3f2015 0=>51 instead of 0=>63 for bar min and bar max 2012-02-08 23:10:26 +00:00
bsongis 3f496b5028 Bars max > min, not >= 2012-02-08 23:02:53 +00:00
bsongis c6b55a8b47 Ignore list updated 2012-02-08 22:51:07 +00:00
bsongis 2e767943c4 Some texts misplaced on screen 2012-02-08 22:50:02 +00:00
bsongis 5da87a5f8d Changelog 2012-02-08 22:25:15 +00:00
bsongis d643917904 Rounding only for RSSI 2012-02-08 21:57:09 +00:00
bsongis 5d67f4ba65 25% bars not displayed on a dotted bar portion 2012-02-08 21:35:06 +00:00
bsongis 7fef74d041 Bad rounding for FRSKY values 2012-02-08 21:22:46 +00:00
bsongis 97e531dd95 One telemetry screen was missing 2012-02-08 21:05:38 +00:00
bsongis caa2aec727 New telemetry screens (bars)
New telemetry units for A1 / A2
Update to pgmtypes according to Michal patch (suggested by gcc developers!)
EEPROM v204
2012-02-08 20:56:36 +00:00
bsongis 2c64004e7c CC defined in the beginning of the Makefile 2012-02-06 08:58:14 +00:00
bsongis d2cc0a3f02 The second telemetry screen reworked 2012-02-05 22:19:17 +00:00
bsongis f42596a2a7 Another 16bytes flash saved 2012-02-05 19:01:28 +00:00
bsongis fa1ebafae4 New binaries 2012-02-05 17:33:53 +00:00
bsongis f2126a8aa6 More telemetry units. GPS screen rewritten. 2012-02-05 16:00:16 +00:00
bsongis 209589ccc7 90 bytes saved on the channel order array + access functions 2012-02-05 10:28:17 +00:00
bsongis a57727b028 Voltage ok on simu 2012-02-05 10:28:07 +00:00
bsongis d3c4cb2534 90 bytes saved on the channel order array + access functions 2012-02-05 10:27:21 +00:00
bsongis 8be03cd80d New open9x binaries 2012-02-04 22:23:38 +00:00
bsongis d2b44a87e6 Stamps for open9x and companion9x 2012-02-04 21:59:33 +00:00
bsongis 885e27cbbe Binaries 2012-02-04 21:51:47 +00:00
bsongis db76315506 Binaries 2012-02-04 21:41:06 +00:00
bsongis b122ba1545 DSM2 option added in compile script 2012-02-04 17:38:44 +00:00
bsongis 1d8fb1f6ee I change again my mind for telemetry: now Range and Offset. Audio sounds now have a name. Haptic sounds skipped when HAPTIC=NO 2012-02-04 17:34:25 +00:00
bsongis 064d0eeb20 Display of Min/Max for telemetry instead of an amplitude and a Calib value 2012-02-04 13:03:50 +00:00
bsongis 1f562bfda4 Makefile fixed for simu 2012-02-04 11:07:33 +00:00
bsongis 7449cfb5fb Compile script 2012-02-03 23:00:29 +00:00
bsongis d3bd550ed7 usrProto is now 8bits we will save bits if needed later 2012-02-03 23:00:04 +00:00
bsongis d399f9f9c4 Safety switches screen removed. Replaced by Function switches. 2012-02-03 22:28:56 +00:00
bsongis 51ef48b03e Cosmetics 2012-02-03 18:21:18 +00:00
bsongis d84b018c56 Changes for x86_64 arch, flto / combine flags, avr-size 2012-02-03 11:55:27 +00:00
bsongis 865c211d91 Issue 2 (french translations) 2012-02-03 06:53:44 +00:00
mihlit@mihlit.cz 14676ab361 make sure splash start and end markers have correct position
Compiler can change position of start/end splash markers or even optimize-out
them completely, because they are not used in the fw. 
Make them part of the splash data block, so their possition is always correct.
util/xbm2lbm was changed together with other c "images" to make it consitent.
2012-02-02 22:48:15 +00:00
bsongis 7f00d8c3dc Another optimizations on AUDIO 2012-02-02 22:25:59 +00:00
mihlit@mihlit.cz acd523e699 make code compatible with up-to-date build environment
These changes make it possible to compile open9x with old (avr-gcc 4.3.3, 
avr-libc 1.6.7) and up-to-date (avr-gcc 4.6.2, avr-libc 1.8.0) build
environments. See Issue 1 for more details.
2012-02-02 11:23:38 +00:00
rob@marotori.com 973b91cd3f Small audio bug fix.. 2012-02-02 07:20:05 +00:00
bsongis 3e009decfb HAPTIC is now able to work without AUDIO
New function in function switches to play an Audio track
Trims can be used to modify a mixer offset.
Offsets for Frsky can go from -128 to +127
Vibrations motor on v4 (HAPTIC option too)
2012-02-01 18:55:08 +00:00
rob@marotori.com 715c5967c7 Author name change 2012-02-01 15:04:20 +00:00
bsongis 55680a13fe No need for frskyeventSample which resets the AUDIO queue! 2012-02-01 14:07:32 +00:00
bsongis 1ef48ee323 Compilation problem. Optimizations. Sounds should not collide any more 2012-02-01 13:54:14 +00:00
rob@marotori.com 8d0265cd3e Audio updates... 2012-02-01 12:23:45 +00:00
bsongis da4b1e7007 Audio repeat was not working! 2012-02-01 11:18:22 +00:00
bsongis 3609f88c32 Haptic for v4 2012-02-01 11:11:15 +00:00
bsongis 010d8dce52 Temporary commit to avoid commiting open9x.h 2012-02-01 11:10:42 +00:00
bsongis d325076e61 Cosmetics 2012-02-01 11:07:36 +00:00
bsongis 4d459edcf8 Adjustments from Rob on all sounds to match the new algorithm.
Haptic strength bug
Haptic on v4
2012-02-01 11:07:10 +00:00
bsongis 3b49bc9d6a Bug in last AUDIO optimizations 2012-01-31 19:10:29 +00:00
bsongis 837eddf1df Haptic initialization 2012-01-31 11:22:23 +00:00
bsongis 088d2d88c8 Audio bug fixes + Haptic 2012-01-31 11:15:04 +00:00
bsongis 4c6cd51c26 Flash saved 2012-01-30 18:43:08 +00:00
bsongis 74e454cd0b Some more optimizations on AUDIO. AUDIO option set to false by default. 2012-01-30 18:42:14 +00:00
bsongis 3c8475636c Inactivity timer reset on Keys and Trims press 2012-01-29 21:56:19 +00:00
bsongis a6a7c516a6 No more BAR value displayed as it is not used yet 2012-01-29 21:17:30 +00:00
bsongis 6a5d21696e xShort was longer than Short... 2012-01-29 21:12:55 +00:00
bsongis 52d4d5721b AUDIO now ok on v4
Code refactoring using a circular buffer for the queue: 212bytes flash saved, 7bytes ram saved, no more copy loops
2012-01-29 18:43:21 +00:00
bsongis 7617d25501 Dead code removed 2012-01-29 18:34:04 +00:00
bsongis 59b0f62a6f New splash 2012-01-28 16:28:02 +00:00
bsongis 4776415c14 Problem with invalid EEPROMS 2012-01-28 15:32:08 +00:00
bsongis 0af7630523 Missing symbols in open9x simu v4 2012-01-28 15:17:00 +00:00
bsongis 3adb512e39 TCCR0A defined in simu 2012-01-28 15:01:50 +00:00
bsongis 3bcb1f6097 Speaker pitch mas modified by Haptic strength! 2012-01-28 08:32:19 +00:00
bsongis dea8c79811 Audio was completely broken on v4. Now better, we hear sounds, but ridiculous sounds... 2012-01-27 20:53:11 +00:00
bsongis 7d511b1e13 HAPTIC is now a compile option 2012-01-27 19:22:28 +00:00
bsongis e6d8648074 NMEA and ARDUPILOT code ported from er9x
DSM2(PPM) bug fixed
Flash saving
PCBV3 removed
One delay_us(7) removed
BEEPSPKR becomes AUDIO
2012-01-27 18:58:59 +00:00
bsongis 5b1bad8705 New binaries 2012-01-27 08:08:45 +00:00
bsongis 57bdc48e6d Small bug in compile.py script, templates were always YES 2012-01-27 08:02:14 +00:00
bsongis 6d138fe89f When DSM2 not included in the firmware and DSM2 chosen as a protocol, the Tx rebooted 2012-01-27 07:55:18 +00:00
bsongis db5ed2b1c1 New binaries for open9x 2012-01-26 20:31:37 +00:00
bsongis a8ec3ddaa7 Audio port from er9x (thanks Rob!) 2012-01-26 20:15:45 +00:00
bsongis be6385bf2f Wrong test for size of General data at load time 2012-01-26 18:40:39 +00:00
bsongis cf955a7a60 New hexes with last modifications 2012-01-25 21:07:08 +00:00
bsongis 104f0abf9b The script for compiling all versions 2012-01-25 20:57:17 +00:00
bsongis 31524e4eb4 g_time_per10 only needed in DEBUG mode 2012-01-25 20:56:21 +00:00
bsongis df063a7298 TODO removed 2012-01-25 18:36:42 +00:00
bsongis f40a5445c9 In case eeGeneral increases it's accepted 2012-01-25 18:33:12 +00:00
romolo.manfredini@gmail.com d3ebb51176 Pulse polarity reversed 2012-01-25 18:29:03 +00:00
bsongis 53ff8cc768 Some improvements when french translations used 2012-01-24 20:28:01 +00:00
bsongis 1ee27fb979 French translations fixes by suspect (modelisme.com) 2012-01-24 07:42:08 +00:00
bsongis 23a4080358 Some fixes in french translations 2012-01-23 22:15:54 +00:00
bsongis 358ec39304 Fixes for v4 board 2012-01-23 21:23:19 +00:00
bsongis 5de422d287 Changes on MCUSR / MCUCSR 2012-01-23 20:54:01 +00:00
bsongis 2064ae4235 French translations by suspect (modelisme.com) 2012-01-23 20:51:16 +00:00
bsongis 8f3a0a28cf PXX + PPM16 port from er9x
DSM2 model id for ModelMatch feature
2012-01-23 18:50:36 +00:00
bsongis ddc9a07eef TIFR / TIFR1 for DSM2 pulses 2012-01-22 18:14:41 +00:00
bsongis 7cc5a37c4b Compliation problem with option JETI 2012-01-22 11:51:00 +00:00
bsongis 1f84c10b50 TIFR disabled, we use async EEPROM write! 2012-01-22 11:28:42 +00:00
bsongis e4d0f37b14 DSM2 on PPM output ported to V4 board
Still remaining the TIFR lines to clear the interrupts
2012-01-22 11:27:25 +00:00
bsongis 59d3f9dd73 Downloads for open9x 2012-01-22 10:46:17 +00:00
bsongis dbbb31aa5e New binaries 2012-01-21 20:49:14 +00:00
bsongis 7ca995bf9f New stamp prepared 2012-01-21 15:30:12 +00:00
bsongis 05fcb5047f Bug in strings when HELI enabled 2012-01-21 14:21:45 +00:00
bsongis 9c658018f4 Optimization in pulses 2012-01-20 19:45:30 +00:00
bsongis 490e48123c Typo 2012-01-20 18:32:03 +00:00
bsongis d05b7bba21 Pulses array length 2012-01-20 18:31:17 +00:00
bsongis 63a5835db8 New MODS letters:
X=PXX
D=DSM2
W=Winged Shadow How High
2012-01-20 18:26:36 +00:00
bsongis 30f513d586 DSM2 (ppm mode) pulled from er9x 2012-01-20 18:23:17 +00:00
bsongis 80bfc11a83 PPM changes pulled from er9x (by Pat Mackenzie) 2012-01-20 18:19:58 +00:00
bsongis f9d3e11956 Some 1400bytes flash saved! 2012-01-20 18:15:29 +00:00
bsongis 0418cb318f Only a constant instead of a number 2012-01-20 18:13:49 +00:00
bsongis c7c9edc2dc MOD string updated 2012-01-19 21:34:03 +00:00
bsongis c4b622fcf5 MOD string updated 2012-01-19 21:21:29 +00:00
bsongis 48e0a262de Changes in stamp 2012-01-19 20:53:38 +00:00
bsongis 6266898738 Let's begin at version 2.0 2012-01-19 20:24:47 +00:00
bsongis 23e49d4f7c DSM2 serial wrong function switch used.
DSM2 ppm port start. Not ready yet.
2012-01-19 19:22:24 +00:00
bsongis c67ba218fa Port for DSM2 pulses,
Port for SOMO module,
ModelMatch function switch,
French translations.
2012-01-19 11:10:02 +00:00
bsongis ebff7a9d09 Open9x strings bugs solved 2012-01-18 23:06:48 +00:00
bsongis c651917da8 Some rename to open9x 2012-01-18 21:39:45 +00:00
bsongis 9cdf70f9d8 open9x translations 2012-01-18 20:24:15 +00:00
bsongis 40d418c007 I prefer that the default options are the ones for the stock board. 2012-01-17 20:29:39 +00:00
bsongis e92ed21627 Translations mechanism 2012-01-17 18:12:18 +00:00
bsongis a8c3125f00 Bug thrTrim applied on a wrong channel 2012-01-17 08:38:36 +00:00
bsongis 3e453ec236 Bug in channels order in templates 2012-01-16 13:51:18 +00:00
bsongis ba941f02bf Bug in channels order when displaying only one letter 2012-01-16 13:37:54 +00:00
bsongis 50816ba01b SPLASH is now a compile option 2012-01-15 20:59:56 +00:00
bsongis 45d56d4efc Bug in the sticks display in main views 2012-01-15 20:02:48 +00:00
bsongis 262458e1d0 Bug in the little square of the throttle trim 2012-01-15 18:13:20 +00:00
bsongis 5d8a717131 Bug in minute beeps 2012-01-15 09:26:45 +00:00
bsongis 8bac9c2784 Bug in trims (Tx modes)
Bug in telemetry display
Bug in timer2
2012-01-14 22:02:23 +00:00
bsongis b496e1fba8 Tx modes should be handled the right way
Throttle trace configuration
Timers updated
New splash
100% CPU in alert (SIMU)
RPM sensor used in custom switches
2012-01-13 17:55:23 +00:00
bsongis 8977d71d0a Warnings solved 2012-01-12 21:14:08 +00:00
bsongis 40d36bb0c5 Work on timers and the trace function.
The timer2 should be full featured now.
Markers around the splash.
2012-01-12 21:08:10 +00:00
bsongis e96b9d410e Who starred this project? I think I am spied ;) 2012-01-09 22:18:14 +00:00
bsongis 6b38d8f0ee TMR1 / TMR2 / ALT may now be used in custom switches! 2012-01-09 20:56:38 +00:00
bsongis 21328f75ea Visual C++ compilation error 2012-01-09 19:13:28 +00:00
bsongis a6e6a2dd12 Logs and Telemetry decorrelated. Telemetry helpers. Possibility to reset the altitude. Flash optimizations. 2012-01-09 18:52:22 +00:00
bsongis 9e0fd2a3d2 The er9x expos conversions were wrong. Thanks to gbirkus for his tests! 2012-01-05 18:43:36 +00:00
bsongis debda06f8e Winged Shadow How High. 2012-01-05 18:37:58 +00:00
bsongis 0115012eff Telemetry screens now visible on simu 2012-01-05 18:00:46 +00:00
bsongis 5fbec8a513 Functions for drawing horizontal lines may not have an int8_t width argument or the max size will be 127 when 128 is needed. 2012-01-05 17:59:54 +00:00
bsongis 29cc8a3529 gruvin9x issue 81 2012-01-03 18:22:14 +00:00
bsongis 26bfcae3e7 FRSKY + FRSKY HUB for open9x in companion9x 2012-01-02 21:08:48 +00:00
bsongis 64f8123987 gcc on MAC warnings 2011-12-29 20:57:39 +00:00
bsongis f88064273d Warnings on gcc (apple) compilation 2011-12-22 11:18:20 +00:00
bsongis 6e2ee25fee Cosmetics: .rule files added to svn:ignore + a warning removed 2011-12-21 18:02:35 +00:00
bsongis 492052e04e Stupid compilers don't like when we mix uint16_t:14 and uint8_t:1 in the same struct 2011-12-17 16:43:45 +00:00
bsongis 851950338d I commited the 0 division for c9x test ... 2011-12-16 20:51:47 +00:00
bsongis 43ccaa60e6 Now it compiles without a warning under Visual C++ ... Why? Only because I wanted to have exceptions catched under Windows as we have on Linux. Most users are Windows. They will be all testers :) 2011-12-16 19:06:28 +00:00
bsongis 88fca5135d Added a SIMU_EXCEPTIONS definition for allowing asserts (and on Linux all SIGFPE/SIGSGF ...) to be displayed in c9x as errors in a MessageBox. It's better than crashing the whole tool and will allow us to easily find the error thanks to the stack which will be displayed. No need to generate new hexes, nothing changed. 2011-12-14 18:34:53 +00:00
bsongis b72fb334d4 Warnings removed 2011-12-13 19:13:00 +00:00
bsongis b491bf5dfe Division per 0 in flight phases maths. 2011-12-13 07:30:07 +00:00
bsongis 423ca57f10 Non regression test for 0 division issue in flight phases switch 2011-12-12 18:53:36 +00:00
bsongis 8a2e035dc9 Last lines of SETUP 1/10 were buggy 2011-12-10 19:10:42 +00:00
bsongis 835d8dc0f4 svn::ignore updated 2011-12-08 22:59:08 +00:00
bsongis 934e176b47 Issue 80 solved. To be improved later in trunk. 2011-12-08 21:43:55 +00:00
bsongis f25c282249 Minor changes to avoid infinite loops inside companion9x 2011-12-08 19:48:40 +00:00
bsongis 9c40d8b9b3 Minor changes to avoid infinite loops inside companion9x 2011-12-08 19:02:38 +00:00
bsongis aefc409173 One ; removed 2011-12-08 19:00:22 +00:00
bsongis 53d9ddfacd Minor changes to be able to wrap everything into a simulation tool inside companion9x 2011-12-07 20:36:13 +00:00
bsongis 87dddbb773 Throttle expo feature removed. If really needed, there are plenty of other ways to achieve it. 2011-12-03 21:51:20 +00:00
bsongis 352b04302a Simu for V4. First draft of rotary encoders use in menus 2011-12-03 16:40:36 +00:00
bsongis 8faf304b14 Simu compilation error 2011-12-03 16:06:27 +00:00
bsongis 6a579226cd Simu async lcd display 2011-11-28 21:32:04 +00:00
bsongis a82d2346a8 The circles again, smoother especially with general settings 2011-11-27 21:33:52 +00:00
bsongis 7a525257bd And now the progress vertical bar. So 4 different pictos/anims select-able via a #define in the end of file.cpp. All comments / other ideas welcome! 2011-11-26 22:52:13 +00:00
bsongis c38cb2e0ff Progress circle in all menus 2011-11-26 22:30:00 +00:00
bsongis ab5de66405 Smoother with this formula 2011-11-26 16:12:09 +00:00
bsongis e0cdbb8294 Another animation (circle). Comments welcome :) 2011-11-26 16:02:46 +00:00
bsongis 2ec3769bb5 One byte read 2 times in EEPROM when it could be read only one time 2011-11-26 13:02:56 +00:00
bsongis 5e633363a9 EEPROM async write bug solved. Progress bar. Popup on MODELSEL. Simu EEPROM async write. 2011-11-26 12:55:00 +00:00
bsongis 9761da9de3 Issues with current model during copy / move operations in MODELSEL menu. 2011-11-25 11:04:38 +00:00
bsongis 5d9a2a483b Gruvin9x issue 73 solved 2011-11-19 13:22:02 +00:00
bsongis afe2e339b3 Some RAM saved in getADC functions (port from er9x). Reverse throttle issue 14 solved. Bug in mixer delays. PPM frame length configurable. 2011-11-18 18:45:12 +00:00
bsongis a9a8947744 More inline in pulses.cpp. Saves 4 bytes flash as well when DSM2 not used :) 2011-11-17 22:04:13 +00:00
bsongis 2b4823ab84 Last changes to gruvin9x 2011-11-17 21:35:33 +00:00
bsongis 3772179692 Function not used removed 2011-11-09 20:33:17 +00:00
bsongis 14104d00a2 Bugs in EXPOS/DR 2011-11-09 20:11:15 +00:00
bsongis 58ab92f7a8 Cosmetics 2011-11-09 19:12:47 +00:00
bsongis af4391857e Problem with putsStr and LEADING0 2011-10-31 08:37:26 +00:00
bsongis 5a29859183 Minor bug: when adding a Mix/Expo after or before a line, the event was not killed. 2011-10-30 07:49:22 +00:00
bsongis f529eca41c The last one was not the very last. This is the winner: curve screen is impossible to use. All values move in the same time. Found on the runway before my Yak first flight. 2011-10-16 17:50:01 +00:00
bsongis c3bb6ac2b5 Bugs in model copy 2011-10-14 19:45:53 +00:00
bsongis 54d6634a8b Calibration screen. Bugs and optimizations. 2011-10-13 18:23:01 +00:00
bsongis f131b0a016 Huge ram saving (320bytes) + expos order change 2011-10-10 19:58:02 +00:00
bsongis f65942d83b Issue 57 solved 2011-10-10 09:42:20 +00:00
bsongis 423a394bb4 Trims2Offsets feature is back 2011-10-10 08:42:30 +00:00
bsongis 7f41efd74d Import current stable gruvin9x version eeproms (v3) 2011-10-09 20:29:05 +00:00
bsongis 8312f5d20e Many MODELSEL screen bugs solved 2011-10-09 12:16:48 +00:00
bsongis ac45e5bfac Just before reverting ... 2011-10-08 08:28:43 +00:00
bsongis b91b63615c No more quick select function 2011-10-03 06:53:09 +00:00
bsongis ec2f6064f4 popMenu is always called without argument 2011-10-03 06:52:11 +00:00
bsongis ac982ef991 Maintainability bug... 2011-10-03 06:51:17 +00:00
bsongis daa74368e1 Conversions from er9x last version should be ok 2011-10-03 06:48:35 +00:00
bsongis 5897553265 Avoids splash + checks at startup on wdt reboot 2011-09-28 21:32:10 +00:00
bsongis 3fc4203261 Ignore list 2011-09-27 10:09:58 +00:00
bsongis dc0b387b6e Hopefully the last async eeprom write bug solved (missing wdt_reset)... Clear Mixes not working 2011-09-27 10:06:00 +00:00
bsongis 807e76f112 Many details commited 2011-09-21 20:31:44 +00:00
bsongis c1e7fba8d9 FrSky hub enabled 2011-09-20 21:30:41 +00:00
bsongis 6fe807e7af Another stupid bug 2011-09-20 21:27:46 +00:00
bsongis baa8c58813 Commit before revert to a previous version. The async eeprom write doesn't work any more. 2011-09-20 18:56:53 +00:00
bsongis c6925989ed EEPROM_ASYNC_WRITE only on STD PCB 2011-09-17 09:37:55 +00:00
bsongis 3d27fed72f ASYNC_WRITE changed to EEPROM_ASYNC_WRITE 2011-09-17 09:29:04 +00:00
bsongis 446ea4deab EEPROM async write is now default behavior 2011-09-16 20:38:25 +00:00
bsongis c9fae27078 lcd_outdezNAtt. We keep only the fastest and shortest 2011-09-16 20:37:39 +00:00
bsongis 46b340a06b Function keys now allow trainer for each stick 2011-09-16 19:53:01 +00:00
bsongis b228f1397b Backup after extended trims merge. 2011-09-16 19:43:08 +00:00
bsongis af73d05bbd Backup before 10bits trims function merge (instead of 8bits + subtrims) 2011-09-14 12:54:57 +00:00
bsongis f0fca34b7e Backup before extended trims function merge 2011-09-13 18:11:01 +00:00
(no author) 4788ea632e Initial directory structure. 2011-09-07 09:17:47 +00:00
925 changed files with 237525 additions and 63119 deletions
-27
View File
@@ -1,27 +0,0 @@
// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: t -*-
/// @file GCS_MAVLink.cpp
/// @brief Supporting bits for MAVLink.
#include "GCS_MAVLink.h"
BetterStream *mavlink_comm_0_port;
BetterStream *mavlink_comm_1_port;
// this might need to move to the flight software
mavlink_system_t mavlink_system = {7,1,0,0};
#ifdef MAVLINK10
# include "include_v1.0/mavlink_helpers.h"
#else
# include "include/mavlink_helpers.h"
#endif
uint8_t mavlink_check_target(uint8_t sysid, uint8_t compid)
{
if (sysid != mavlink_system.sysid)
return 1;
// Currently we are not checking for correct compid since APM is not passing mavlink info to any subsystem
// If it is addressed to our system ID we assume it is for us
return 0; // no error
}
-128
View File
@@ -1,128 +0,0 @@
// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: t -*-
/// @file GCS_MAVLink.h
/// @brief One size fits all header for MAVLink integration.
#ifndef GCS_MAVLink_h
#define GCS_MAVLink_h
#include <BetterStream.h>
#define MAVLINK_SEPARATE_HELPERS
#ifdef MAVLINK10
# include "include_v1.0/ardupilotmega/version.h"
#else
# include "include/ardupilotmega/version.h"
#endif
// this allows us to make mavlink_message_t much smaller
#define MAVLINK_MAX_PAYLOAD_LEN MAVLINK_MAX_DIALECT_PAYLOAD_SIZE
#define MAVLINK_COMM_NUM_BUFFERS 2
#ifdef MAVLINK10
# include "include_v1.0/mavlink_types.h"
#else
# include "include/mavlink_types.h"
#endif
/// MAVLink stream used for HIL interaction
extern BetterStream *mavlink_comm_0_port;
/// MAVLink stream used for ground control communication
extern BetterStream *mavlink_comm_1_port;
/// MAVLink system definition
extern mavlink_system_t mavlink_system;
/// Send a byte to the nominated MAVLink channel
///
/// @param chan Channel to send to
/// @param ch Byte to send
///
static inline void comm_send_ch(mavlink_channel_t chan, uint8_t ch)
{
switch(chan) {
case MAVLINK_COMM_0:
mavlink_comm_0_port->write(ch);
break;
case MAVLINK_COMM_1:
mavlink_comm_1_port->write(ch);
break;
default:
break;
}
}
/// Read a byte from the nominated MAVLink channel
///
/// @param chan Channel to receive on
/// @returns Byte read
///
static inline uint8_t comm_receive_ch(mavlink_channel_t chan)
{
uint8_t data = 0;
switch(chan) {
case MAVLINK_COMM_0:
data = mavlink_comm_0_port->read();
break;
case MAVLINK_COMM_1:
data = mavlink_comm_1_port->read();
break;
default:
break;
}
return data;
}
/// Check for available data on the nominated MAVLink channel
///
/// @param chan Channel to check
/// @returns Number of bytes available
static inline uint16_t comm_get_available(mavlink_channel_t chan)
{
uint16_t bytes = 0;
switch(chan) {
case MAVLINK_COMM_0:
bytes = mavlink_comm_0_port->available();
break;
case MAVLINK_COMM_1:
bytes = mavlink_comm_1_port->available();
break;
default:
break;
}
return bytes;
}
/// Check for available transmit space on the nominated MAVLink channel
///
/// @param chan Channel to check
/// @returns Number of bytes available, -1 for error
static inline int comm_get_txspace(mavlink_channel_t chan)
{
switch(chan) {
case MAVLINK_COMM_0:
return mavlink_comm_0_port->txspace();
break;
case MAVLINK_COMM_1:
return mavlink_comm_1_port->txspace();
break;
default:
break;
}
return -1;
}
#define MAVLINK_USE_CONVENIENCE_FUNCTIONS
#ifdef MAVLINK10
# include "include_v1.0/ardupilotmega/mavlink.h"
#else
# include "include/ardupilotmega/mavlink.h"
#endif
uint8_t mavlink_check_target(uint8_t sysid, uint8_t compid);
#endif // GCS_MAVLink_h
-172
View File
@@ -1,172 +0,0 @@
/*
compatibility header during transition to MAVLink 1.0
*/
#ifdef MAVLINK10
// in MAVLink 1.0 'waypoint' becomes 'mission'. We can remove these
// mappings once we are not trying to support both protocols
#define MAVLINK_MSG_ID_WAYPOINT_CURRENT MAVLINK_MSG_ID_MISSION_CURRENT
#define MAVLINK_MSG_ID_WAYPOINT_CURRENT_LEN MAVLINK_MSG_ID_MISSION_CURRENT_LEN
#define mavlink_msg_waypoint_current_send mavlink_msg_mission_current_send
#define mavlink_msg_waypoint_current_decode mavlink_msg_mission_current_decode
#define MAVLINK_MSG_ID_WAYPOINT_COUNT MAVLINK_MSG_ID_MISSION_COUNT
#define MAVLINK_MSG_ID_WAYPOINT_COUNT_LEN MAVLINK_MSG_ID_MISSION_COUNT_LEN
#define mavlink_msg_waypoint_count_send mavlink_msg_mission_count_send
#define mavlink_msg_waypoint_count_decode mavlink_msg_mission_count_decode
#define mavlink_waypoint_count_t mavlink_mission_count_t
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST MAVLINK_MSG_ID_MISSION_REQUEST
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST_LEN MAVLINK_MSG_ID_MISSION_REQUEST_LEN
#define mavlink_msg_waypoint_request_send mavlink_msg_mission_request_send
#define mavlink_msg_waypoint_request_decode mavlink_msg_mission_request_decode
#define mavlink_waypoint_request_t mavlink_mission_request_t
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST MAVLINK_MSG_ID_MISSION_REQUEST_LIST
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST_LEN MAVLINK_MSG_ID_MISSION_REQUEST_LIST_LEN
#define mavlink_msg_waypoint_request_list_send mavlink_msg_mission_request_list_send
#define mavlink_msg_waypoint_request_list_decode mavlink_msg_mission_request_list_decode
#define mavlink_waypoint_request_list_t mavlink_mission_request_list_t
#define MAVLINK_MSG_ID_WAYPOINT MAVLINK_MSG_ID_MISSION_ITEM
#define MAVLINK_MSG_ID_WAYPOINT_LEN MAVLINK_MSG_ID_MISSION_ITEM_LEN
#define mavlink_msg_waypoint_send mavlink_msg_mission_item_send
#define mavlink_msg_waypoint_decode mavlink_msg_mission_item_decode
#define mavlink_waypoint_t mavlink_mission_item_t
#define MAVLINK_MSG_ID_WAYPOINT_ACK MAVLINK_MSG_ID_MISSION_ACK
#define MAVLINK_MSG_ID_WAYPOINT_ACK_LEN MAVLINK_MSG_ID_MISSION_ACK_LEN
#define mavlink_msg_waypoint_ack_send mavlink_msg_mission_ack_send
#define mavlink_msg_waypoint_ack_decode mavlink_msg_mission_ack_decode
#define mavlink_waypoint_ack_t mavlink_mission_ack_t
#define MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL MAVLINK_MSG_ID_MISSION_CLEAR_ALL
#define MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL_LEN MAVLINK_MSG_ID_MISSION_CLEAR_ALL_LEN
#define mavlink_msg_waypoint_clear_all_send mavlink_msg_mission_clear_all_send
#define mavlink_msg_waypoint_clear_all_decode mavlink_msg_mission_clear_all_decode
#define mavlink_waypoint_clear_all_t mavlink_mission_clear_all_t
#define MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT MAVLINK_MSG_ID_MISSION_SET_CURRENT
#define MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT_LEN MAVLINK_MSG_ID_MISSION_SET_CURRENT_LEN
#define mavlink_msg_waypoint_set_current_send mavlink_msg_mission_set_current_send
#define mavlink_msg_waypoint_set_current_decode mavlink_msg_mission_set_current_decode
#define mavlink_waypoint_set_current_t mavlink_mission_set_current_t
static uint8_t mav_var_type(enum ap_var_type t)
{
if (t == AP_PARAM_INT8) {
return MAV_VAR_INT8;
}
if (t == AP_PARAM_INT16) {
return MAV_VAR_INT16;
}
if (t == AP_PARAM_INT32) {
return MAV_VAR_INT32;
}
// treat any others as float
return MAV_VAR_FLOAT;
}
#define MAV_FIXED_WING MAV_TYPE_FIXED_WING
#else // MAVLINK10
static uint8_t mav_var_type(enum ap_var_type t)
{
return 0;
}
#define MAV_MISSION_ACCEPTED 0
#define MAV_MISSION_UNSUPPORTED 1
#define MAV_MISSION_UNSUPPORTED_FRAME 1
#define MAV_MISSION_ERROR 1
#define MAV_MISSION_INVALID_SEQUENCE 1
/*
some functions have some extra params in MAVLink 1.0
*/
static void mavlink_msg_global_position_int_send(mavlink_channel_t chan, uint32_t time_boot_ms, int32_t lat, int32_t lon,
int32_t alt, int32_t relative_alt, int16_t vx, int16_t vy,
int16_t vz, uint16_t hdg)
{
mavlink_msg_global_position_int_send(
chan,
lat,
lon,
alt,
vx, vy, vz);
}
static void mavlink_msg_rc_channels_scaled_send(mavlink_channel_t chan, uint32_t time_boot_ms, uint8_t port,
int16_t chan1_scaled, int16_t chan2_scaled, int16_t chan3_scaled,
int16_t chan4_scaled, int16_t chan5_scaled, int16_t chan6_scaled,
int16_t chan7_scaled, int16_t chan8_scaled, uint8_t rssi)
{
mavlink_msg_rc_channels_scaled_send(
chan,
chan1_scaled,
chan2_scaled,
chan3_scaled,
chan4_scaled,
chan5_scaled,
chan6_scaled,
chan7_scaled,
chan8_scaled,
rssi);
}
static void mavlink_msg_rc_channels_raw_send(mavlink_channel_t chan, uint32_t time_boot_ms, uint8_t port,
uint16_t chan1_raw, uint16_t chan2_raw, uint16_t chan3_raw,
uint16_t chan4_raw, uint16_t chan5_raw, uint16_t chan6_raw,
uint16_t chan7_raw, uint16_t chan8_raw, uint8_t rssi)
{
mavlink_msg_rc_channels_raw_send(
chan,
chan1_raw,
chan2_raw,
chan3_raw,
chan4_raw,
chan5_raw,
chan6_raw,
chan7_raw,
chan8_raw,
rssi);
}
static void mavlink_msg_servo_output_raw_send(mavlink_channel_t chan, uint32_t time_usec, uint8_t port,
uint16_t servo1_raw, uint16_t servo2_raw, uint16_t servo3_raw,
uint16_t servo4_raw, uint16_t servo5_raw, uint16_t servo6_raw,
uint16_t servo7_raw, uint16_t servo8_raw)
{
mavlink_msg_servo_output_raw_send(
chan,
servo1_raw,
servo2_raw,
servo3_raw,
servo4_raw,
servo5_raw,
servo6_raw,
servo7_raw,
servo8_raw);
}
static void mavlink_msg_statustext_send(mavlink_channel_t chan, uint8_t severity, const char *text)
{
mavlink_msg_statustext_send(chan, severity, (const int8_t*) text);
}
static void mavlink_msg_param_value_send(mavlink_channel_t chan, const char *param_id,
float param_value, uint8_t param_type,
uint16_t param_count, uint16_t param_index)
{
mavlink_msg_param_value_send(
chan,
(int8_t *)param_id,
param_value,
param_count,
param_index);
}
#endif // MAVLINK10
@@ -1,150 +0,0 @@
/** @file
* @brief MAVLink comm protocol generated from ardupilotmega.xml
* @see http://qgroundcontrol.org/mavlink/
*/
#ifndef ARDUPILOTMEGA_H
#define ARDUPILOTMEGA_H
#ifdef __cplusplus
extern "C" {
#endif
// MESSAGE LENGTHS AND CRCS
#ifndef MAVLINK_MESSAGE_LENGTHS
#define MAVLINK_MESSAGE_LENGTHS {3, 4, 8, 14, 8, 28, 3, 32, 0, 2, 3, 2, 2, 0, 0, 0, 0, 0, 0, 0, 19, 2, 23, 21, 0, 37, 26, 101, 26, 16, 32, 32, 37, 32, 11, 17, 17, 16, 18, 36, 4, 4, 2, 2, 4, 2, 2, 3, 14, 12, 18, 16, 8, 27, 25, 18, 18, 24, 24, 0, 0, 0, 26, 16, 36, 5, 6, 56, 26, 21, 18, 0, 0, 18, 20, 20, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 8, 4, 12, 15, 13, 6, 15, 14, 0, 12, 3, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 14, 14, 51, 5}
#endif
#ifndef MAVLINK_MESSAGE_CRCS
#define MAVLINK_MESSAGE_CRCS {72, 39, 190, 92, 191, 217, 104, 119, 0, 219, 60, 186, 10, 0, 0, 0, 0, 0, 0, 0, 89, 159, 162, 121, 0, 149, 222, 110, 179, 136, 66, 126, 185, 147, 112, 252, 162, 215, 229, 128, 9, 106, 101, 213, 4, 229, 21, 214, 215, 14, 206, 50, 157, 126, 108, 213, 95, 5, 127, 0, 0, 0, 57, 126, 130, 119, 193, 191, 236, 158, 143, 0, 0, 104, 123, 131, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 155, 0, 0, 0, 0, 0, 0, 0, 0, 0, 143, 29, 208, 188, 118, 242, 19, 97, 233, 0, 18, 68, 136, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 178, 224, 60, 106, 7}
#endif
#ifndef MAVLINK_MESSAGE_INFO
#define MAVLINK_MESSAGE_INFO {MAVLINK_MESSAGE_INFO_HEARTBEAT, MAVLINK_MESSAGE_INFO_BOOT, MAVLINK_MESSAGE_INFO_SYSTEM_TIME, MAVLINK_MESSAGE_INFO_PING, MAVLINK_MESSAGE_INFO_SYSTEM_TIME_UTC, MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL, MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL_ACK, MAVLINK_MESSAGE_INFO_AUTH_KEY, {NULL}, MAVLINK_MESSAGE_INFO_ACTION_ACK, MAVLINK_MESSAGE_INFO_ACTION, MAVLINK_MESSAGE_INFO_SET_MODE, MAVLINK_MESSAGE_INFO_SET_NAV_MODE, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_PARAM_REQUEST_READ, MAVLINK_MESSAGE_INFO_PARAM_REQUEST_LIST, MAVLINK_MESSAGE_INFO_PARAM_VALUE, MAVLINK_MESSAGE_INFO_PARAM_SET, {NULL}, MAVLINK_MESSAGE_INFO_GPS_RAW_INT, MAVLINK_MESSAGE_INFO_SCALED_IMU, MAVLINK_MESSAGE_INFO_GPS_STATUS, MAVLINK_MESSAGE_INFO_RAW_IMU, MAVLINK_MESSAGE_INFO_RAW_PRESSURE, MAVLINK_MESSAGE_INFO_ATTITUDE, MAVLINK_MESSAGE_INFO_LOCAL_POSITION, MAVLINK_MESSAGE_INFO_GPS_RAW, MAVLINK_MESSAGE_INFO_GLOBAL_POSITION, MAVLINK_MESSAGE_INFO_SYS_STATUS, MAVLINK_MESSAGE_INFO_RC_CHANNELS_RAW, MAVLINK_MESSAGE_INFO_RC_CHANNELS_SCALED, MAVLINK_MESSAGE_INFO_SERVO_OUTPUT_RAW, MAVLINK_MESSAGE_INFO_SCALED_PRESSURE, MAVLINK_MESSAGE_INFO_WAYPOINT, MAVLINK_MESSAGE_INFO_WAYPOINT_REQUEST, MAVLINK_MESSAGE_INFO_WAYPOINT_SET_CURRENT, MAVLINK_MESSAGE_INFO_WAYPOINT_CURRENT, MAVLINK_MESSAGE_INFO_WAYPOINT_REQUEST_LIST, MAVLINK_MESSAGE_INFO_WAYPOINT_COUNT, MAVLINK_MESSAGE_INFO_WAYPOINT_CLEAR_ALL, MAVLINK_MESSAGE_INFO_WAYPOINT_REACHED, MAVLINK_MESSAGE_INFO_WAYPOINT_ACK, MAVLINK_MESSAGE_INFO_GPS_SET_GLOBAL_ORIGIN, MAVLINK_MESSAGE_INFO_GPS_LOCAL_ORIGIN_SET, MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT_SET, MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT, MAVLINK_MESSAGE_INFO_CONTROL_STATUS, MAVLINK_MESSAGE_INFO_SAFETY_SET_ALLOWED_AREA, MAVLINK_MESSAGE_INFO_SAFETY_ALLOWED_AREA, MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_THRUST, MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_SPEED_THRUST, MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_THRUST_SETPOINT, MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_NAV_CONTROLLER_OUTPUT, MAVLINK_MESSAGE_INFO_POSITION_TARGET, MAVLINK_MESSAGE_INFO_STATE_CORRECTION, MAVLINK_MESSAGE_INFO_SET_ALTITUDE, MAVLINK_MESSAGE_INFO_REQUEST_DATA_STREAM, MAVLINK_MESSAGE_INFO_HIL_STATE, MAVLINK_MESSAGE_INFO_HIL_CONTROLS, MAVLINK_MESSAGE_INFO_MANUAL_CONTROL, MAVLINK_MESSAGE_INFO_RC_CHANNELS_OVERRIDE, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_GLOBAL_POSITION_INT, MAVLINK_MESSAGE_INFO_VFR_HUD, MAVLINK_MESSAGE_INFO_COMMAND, MAVLINK_MESSAGE_INFO_COMMAND_ACK, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_OPTICAL_FLOW, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_OBJECT_DETECTION_EVENT, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_SENSOR_OFFSETS, MAVLINK_MESSAGE_INFO_SET_MAG_OFFSETS, MAVLINK_MESSAGE_INFO_MEMINFO, MAVLINK_MESSAGE_INFO_AP_ADC, MAVLINK_MESSAGE_INFO_DIGICAM_CONFIGURE, MAVLINK_MESSAGE_INFO_DIGICAM_CONTROL, MAVLINK_MESSAGE_INFO_MOUNT_CONFIGURE, MAVLINK_MESSAGE_INFO_MOUNT_CONTROL, MAVLINK_MESSAGE_INFO_MOUNT_STATUS, {NULL}, MAVLINK_MESSAGE_INFO_FENCE_POINT, MAVLINK_MESSAGE_INFO_FENCE_FETCH_POINT, MAVLINK_MESSAGE_INFO_FENCE_STATUS, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_DEBUG_VECT, MAVLINK_MESSAGE_INFO_NAMED_VALUE_FLOAT, MAVLINK_MESSAGE_INFO_NAMED_VALUE_INT, MAVLINK_MESSAGE_INFO_STATUSTEXT, MAVLINK_MESSAGE_INFO_DEBUG}
#endif
#include "../protocol.h"
#define MAVLINK_ENABLED_ARDUPILOTMEGA
#include "../common/common.h"
// MAVLINK VERSION
#ifndef MAVLINK_VERSION
#define MAVLINK_VERSION 2
#endif
#if (MAVLINK_VERSION == 0)
#undef MAVLINK_VERSION
#define MAVLINK_VERSION 2
#endif
// ENUM DEFINITIONS
/** @brief Enumeration of possible mount operation modes */
#ifndef HAVE_ENUM_MAV_MOUNT_MODE
#define HAVE_ENUM_MAV_MOUNT_MODE
enum MAV_MOUNT_MODE
{
MAV_MOUNT_MODE_RETRACT=0, /* Load and keep safe position (Roll,Pitch,Yaw) from EEPROM and stop stabilization | */
MAV_MOUNT_MODE_NEUTRAL=1, /* Load and keep neutral position (Roll,Pitch,Yaw) from EEPROM. | */
MAV_MOUNT_MODE_MAVLINK_TARGETING=2, /* Load neutral position and start MAVLink Roll,Pitch,Yaw control with stabilization | */
MAV_MOUNT_MODE_RC_TARGETING=3, /* Load neutral position and start RC Roll,Pitch,Yaw control with stabilization | */
MAV_MOUNT_MODE_GPS_POINT=4, /* Load neutral position and start to point to Lat,Lon,Alt | */
MAV_MOUNT_MODE_ENUM_END=5, /* | */
};
#endif
/** @brief */
#ifndef HAVE_ENUM_MAV_CMD
#define HAVE_ENUM_MAV_CMD
enum MAV_CMD
{
MAV_CMD_NAV_WAYPOINT=16, /* Navigate to waypoint. |Hold time in decimal seconds. (ignored by fixed wing, time to stay at waypoint for rotary wing)| Acceptance radius in meters (if the sphere with this radius is hit, the waypoint counts as reached)| 0 to pass through the WP, if > 0 radius in meters to pass by WP. Positive value for clockwise orbit, negative value for counter-clockwise orbit. Allows trajectory control.| Desired yaw angle at waypoint (rotary wing)| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_LOITER_UNLIM=17, /* Loiter around this waypoint an unlimited amount of time |Empty| Empty| Radius around waypoint, in meters. If positive loiter clockwise, else counter-clockwise| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_LOITER_TURNS=18, /* Loiter around this waypoint for X turns |Turns| Empty| Radius around waypoint, in meters. If positive loiter clockwise, else counter-clockwise| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_LOITER_TIME=19, /* Loiter around this waypoint for X seconds |Seconds (decimal)| Empty| Radius around waypoint, in meters. If positive loiter clockwise, else counter-clockwise| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_RETURN_TO_LAUNCH=20, /* Return to launch location |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_NAV_LAND=21, /* Land at location |Empty| Empty| Empty| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_TAKEOFF=22, /* Takeoff from ground / hand |Minimum pitch (if airspeed sensor present), desired pitch without sensor| Empty| Empty| Yaw angle (if magnetometer present), ignored without magnetometer| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_ROI=80, /* Sets the region of interest (ROI) for a sensor set or the
vehicle itself. This can then be used by the vehicles control
system to control the vehicle attitude and the attitude of various
sensors such as cameras. |Region of intereset mode. (see MAV_ROI enum)| Waypoint index/ target ID. (see MAV_ROI enum)| ROI index (allows a vehicle to manage multiple ROI's)| Empty| x the location of the fixed ROI (see MAV_FRAME)| y| z| */
MAV_CMD_NAV_PATHPLANNING=81, /* Control autonomous path planning on the MAV. |0: Disable local obstacle avoidance / local path planning (without resetting map), 1: Enable local path planning, 2: Enable and reset local path planning| 0: Disable full path planning (without resetting map), 1: Enable, 2: Enable and reset map/occupancy grid, 3: Enable and reset planned route, but not occupancy grid| Empty| Yaw angle at goal, in compass degrees, [0..360]| Latitude/X of goal| Longitude/Y of goal| Altitude/Z of goal| */
MAV_CMD_NAV_LAST=95, /* NOP - This command is only used to mark the upper limit of the NAV/ACTION commands in the enumeration |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_CONDITION_DELAY=112, /* Delay mission state machine. |Delay in seconds (decimal)| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_CONDITION_CHANGE_ALT=113, /* Ascend/descend at rate. Delay mission state machine until desired altitude reached. |Descent / Ascend rate (m/s)| Empty| Empty| Empty| Empty| Empty| Finish Altitude| */
MAV_CMD_CONDITION_DISTANCE=114, /* Delay mission state machine until within desired distance of next NAV point. |Distance (meters)| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_CONDITION_YAW=115, /* Reach a certain target angle. |target angle: [0-360], 0 is north| speed during yaw change:[deg per second]| direction: negative: counter clockwise, positive: clockwise [-1,1]| relative offset or absolute angle: [ 1,0]| Empty| Empty| Empty| */
MAV_CMD_CONDITION_LAST=159, /* NOP - This command is only used to mark the upper limit of the CONDITION commands in the enumeration |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_MODE=176, /* Set system mode. |Mode, as defined by ENUM MAV_MODE| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_JUMP=177, /* Jump to the desired command in the mission list. Repeat this action only the specified number of times |Sequence number| Repeat count| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_CHANGE_SPEED=178, /* Change speed and/or throttle set points. |Speed type (0=Airspeed, 1=Ground Speed)| Speed (m/s, -1 indicates no change)| Throttle ( Percent, -1 indicates no change)| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_HOME=179, /* Changes the home location either to the current location or a specified location. |Use current (1=use current location, 0=use specified location)| Empty| Empty| Empty| Latitude| Longitude| Altitude| */
MAV_CMD_DO_SET_PARAMETER=180, /* Set a system parameter. Caution! Use of this command requires knowledge of the numeric enumeration value of the parameter. |Parameter number| Parameter value| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_RELAY=181, /* Set a relay to a condition. |Relay number| Setting (1=on, 0=off, others possible depending on system hardware)| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_REPEAT_RELAY=182, /* Cycle a relay on and off for a desired number of cyles with a desired period. |Relay number| Cycle count| Cycle time (seconds, decimal)| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_SERVO=183, /* Set a servo to a desired PWM value. |Servo number| PWM (microseconds, 1000 to 2000 typical)| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_REPEAT_SERVO=184, /* Cycle a between its nominal setting and a desired PWM for a desired number of cycles with a desired period. |Servo number| PWM (microseconds, 1000 to 2000 typical)| Cycle count| Cycle time (seconds)| Empty| Empty| Empty| */
MAV_CMD_DO_CONTROL_VIDEO=200, /* Control onboard camera capturing. |Camera ID (-1 for all)| Transmission: 0: disabled, 1: enabled compressed, 2: enabled raw| Transmission mode: 0: video stream, >0: single images every n seconds (decimal)| Recording: 0: disabled, 1: enabled compressed, 2: enabled raw| Empty| Empty| Empty| */
MAV_CMD_DO_SET_ROI=201, /* Sets the region of interest (ROI) for a sensor set or the
vehicle itself. This can then be used by the vehicles control
system to control the vehicle attitude and the attitude of various
devices such as cameras.
|Region of interest mode. (see MAV_ROI enum)| Waypoint index/ target ID. (see MAV_ROI enum)| ROI index (allows a vehicle to manage multiple cameras etc.)| Empty| x the location of the fixed ROI (see MAV_FRAME)| y| z| */
MAV_CMD_DO_DIGICAM_CONFIGURE=202, /* Mission command to configure an on-board camera controller system. |Modes: P, TV, AV, M, Etc| Shutter speed: Divisor number for one second| Aperture: F stop number| ISO number e.g. 80, 100, 200, Etc| Exposure type enumerator| Command Identity| Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)| */
MAV_CMD_DO_DIGICAM_CONTROL=203, /* Mission command to control an on-board camera controller system. |Session control e.g. show/hide lens| Zoom's absolute position| Zooming step value to offset zoom from the current position| Focus Locking, Unlocking or Re-locking| Shooting Command| Command Identity| Empty| */
MAV_CMD_DO_MOUNT_CONFIGURE=204, /* Mission command to configure a camera or antenna mount |Mount operation mode (see MAV_MOUNT_MODE enum)| stabilize roll? (1 = yes, 0 = no)| stabilize pitch? (1 = yes, 0 = no)| stabilize yaw? (1 = yes, 0 = no)| Empty| Empty| Empty| */
MAV_CMD_DO_MOUNT_CONTROL=205, /* Mission command to control a camera or antenna mount |pitch(deg*100) or lat, depending on mount mode.| roll(deg*100) or lon depending on mount mode| yaw(deg*100) or alt (in cm) depending on mount mode| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_LAST=240, /* NOP - This command is only used to mark the upper limit of the DO commands in the enumeration |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_PREFLIGHT_CALIBRATION=241, /* Trigger calibration. This command will be only accepted if in pre-flight mode. |Gyro calibration: 0: no, 1: yes| Magnetometer calibration: 0: no, 1: yes| Ground pressure: 0: no, 1: yes| Radio calibration: 0: no, 1: yes| Empty| Empty| Empty| */
MAV_CMD_PREFLIGHT_STORAGE=245, /* Request storage of different parameter values and logs. This command will be only accepted if in pre-flight mode. |Parameter storage: 0: READ FROM FLASH/EEPROM, 1: WRITE CURRENT TO FLASH/EEPROM| Mission storage: 0: READ FROM FLASH/EEPROM, 1: WRITE CURRENT TO FLASH/EEPROM| Reserved| Reserved| Empty| Empty| Empty| */
MAV_CMD_ENUM_END=246, /* | */
};
#endif
/** @brief */
#ifndef HAVE_ENUM_FENCE_ACTION
#define HAVE_ENUM_FENCE_ACTION
enum FENCE_ACTION
{
FENCE_ACTION_NONE=0, /* Disable fenced mode | */
FENCE_ACTION_GUIDED=1, /* Switched to guided mode to return point (fence point 0) | */
FENCE_ACTION_ENUM_END=2, /* | */
};
#endif
/** @brief */
#ifndef HAVE_ENUM_FENCE_BREACH
#define HAVE_ENUM_FENCE_BREACH
enum FENCE_BREACH
{
FENCE_BREACH_NONE=0, /* No last fence breach | */
FENCE_BREACH_MINALT=1, /* Breached minimum altitude | */
FENCE_BREACH_MAXALT=2, /* Breached minimum altitude | */
FENCE_BREACH_BOUNDARY=3, /* Breached fence boundary | */
FENCE_BREACH_ENUM_END=4, /* | */
};
#endif
// MESSAGE DEFINITIONS
#include "./mavlink_msg_sensor_offsets.h"
#include "./mavlink_msg_set_mag_offsets.h"
#include "./mavlink_msg_meminfo.h"
#include "./mavlink_msg_ap_adc.h"
#include "./mavlink_msg_digicam_configure.h"
#include "./mavlink_msg_digicam_control.h"
#include "./mavlink_msg_mount_configure.h"
#include "./mavlink_msg_mount_control.h"
#include "./mavlink_msg_mount_status.h"
#include "./mavlink_msg_fence_point.h"
#include "./mavlink_msg_fence_fetch_point.h"
#include "./mavlink_msg_fence_status.h"
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // ARDUPILOTMEGA_H
@@ -1,27 +0,0 @@
/** @file
* @brief MAVLink comm protocol built from ardupilotmega.xml
* @see http://pixhawk.ethz.ch/software/mavlink
*/
#ifndef MAVLINK_H
#define MAVLINK_H
#ifndef MAVLINK_STX
#define MAVLINK_STX 85
#endif
#ifndef MAVLINK_ENDIAN
#define MAVLINK_ENDIAN MAVLINK_BIG_ENDIAN
#endif
#ifndef MAVLINK_ALIGNED_FIELDS
#define MAVLINK_ALIGNED_FIELDS 0
#endif
#ifndef MAVLINK_CRC_EXTRA
#define MAVLINK_CRC_EXTRA 0
#endif
#include "version.h"
#include "ardupilotmega.h"
#endif // MAVLINK_H
@@ -1,364 +0,0 @@
// MESSAGE DIGICAM_CONFIGURE PACKING
#define MAVLINK_MSG_ID_DIGICAM_CONFIGURE 154
typedef struct __mavlink_digicam_configure_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t mode; ///< Mode enumeration from 1 to N //P, TV, AV, M, Etc (0 means ignore)
uint16_t shutter_speed; ///< Divisor number //e.g. 1000 means 1/1000 (0 means ignore)
uint8_t aperture; ///< F stop number x 10 //e.g. 28 means 2.8 (0 means ignore)
uint8_t iso; ///< ISO enumeration from 1 to N //e.g. 80, 100, 200, Etc (0 means ignore)
uint8_t exposure_type; ///< Exposure type enumeration from 1 to N (0 means ignore)
uint8_t command_id; ///< Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
uint8_t engine_cut_off; ///< Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)
uint8_t extra_param; ///< Extra parameters enumeration (0 means ignore)
float extra_value; ///< Correspondent value to given extra_param
} mavlink_digicam_configure_t;
#define MAVLINK_MSG_ID_DIGICAM_CONFIGURE_LEN 15
#define MAVLINK_MSG_ID_154_LEN 15
#define MAVLINK_MESSAGE_INFO_DIGICAM_CONFIGURE { \
"DIGICAM_CONFIGURE", \
11, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_digicam_configure_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_digicam_configure_t, target_component) }, \
{ "mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_digicam_configure_t, mode) }, \
{ "shutter_speed", NULL, MAVLINK_TYPE_UINT16_T, 0, 3, offsetof(mavlink_digicam_configure_t, shutter_speed) }, \
{ "aperture", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_digicam_configure_t, aperture) }, \
{ "iso", NULL, MAVLINK_TYPE_UINT8_T, 0, 6, offsetof(mavlink_digicam_configure_t, iso) }, \
{ "exposure_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 7, offsetof(mavlink_digicam_configure_t, exposure_type) }, \
{ "command_id", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_digicam_configure_t, command_id) }, \
{ "engine_cut_off", NULL, MAVLINK_TYPE_UINT8_T, 0, 9, offsetof(mavlink_digicam_configure_t, engine_cut_off) }, \
{ "extra_param", NULL, MAVLINK_TYPE_UINT8_T, 0, 10, offsetof(mavlink_digicam_configure_t, extra_param) }, \
{ "extra_value", NULL, MAVLINK_TYPE_FLOAT, 0, 11, offsetof(mavlink_digicam_configure_t, extra_value) }, \
} \
}
/**
* @brief Pack a digicam_configure message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param mode Mode enumeration from 1 to N //P, TV, AV, M, Etc (0 means ignore)
* @param shutter_speed Divisor number //e.g. 1000 means 1/1000 (0 means ignore)
* @param aperture F stop number x 10 //e.g. 28 means 2.8 (0 means ignore)
* @param iso ISO enumeration from 1 to N //e.g. 80, 100, 200, Etc (0 means ignore)
* @param exposure_type Exposure type enumeration from 1 to N (0 means ignore)
* @param command_id Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
* @param engine_cut_off Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)
* @param extra_param Extra parameters enumeration (0 means ignore)
* @param extra_value Correspondent value to given extra_param
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_digicam_configure_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t mode, uint16_t shutter_speed, uint8_t aperture, uint8_t iso, uint8_t exposure_type, uint8_t command_id, uint8_t engine_cut_off, uint8_t extra_param, float extra_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[15];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, mode);
_mav_put_uint16_t(buf, 3, shutter_speed);
_mav_put_uint8_t(buf, 5, aperture);
_mav_put_uint8_t(buf, 6, iso);
_mav_put_uint8_t(buf, 7, exposure_type);
_mav_put_uint8_t(buf, 8, command_id);
_mav_put_uint8_t(buf, 9, engine_cut_off);
_mav_put_uint8_t(buf, 10, extra_param);
_mav_put_float(buf, 11, extra_value);
memcpy(_MAV_PAYLOAD(msg), buf, 15);
#else
mavlink_digicam_configure_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mode = mode;
packet.shutter_speed = shutter_speed;
packet.aperture = aperture;
packet.iso = iso;
packet.exposure_type = exposure_type;
packet.command_id = command_id;
packet.engine_cut_off = engine_cut_off;
packet.extra_param = extra_param;
packet.extra_value = extra_value;
memcpy(_MAV_PAYLOAD(msg), &packet, 15);
#endif
msg->msgid = MAVLINK_MSG_ID_DIGICAM_CONFIGURE;
return mavlink_finalize_message(msg, system_id, component_id, 15);
}
/**
* @brief Pack a digicam_configure message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param mode Mode enumeration from 1 to N //P, TV, AV, M, Etc (0 means ignore)
* @param shutter_speed Divisor number //e.g. 1000 means 1/1000 (0 means ignore)
* @param aperture F stop number x 10 //e.g. 28 means 2.8 (0 means ignore)
* @param iso ISO enumeration from 1 to N //e.g. 80, 100, 200, Etc (0 means ignore)
* @param exposure_type Exposure type enumeration from 1 to N (0 means ignore)
* @param command_id Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
* @param engine_cut_off Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)
* @param extra_param Extra parameters enumeration (0 means ignore)
* @param extra_value Correspondent value to given extra_param
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_digicam_configure_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t mode,uint16_t shutter_speed,uint8_t aperture,uint8_t iso,uint8_t exposure_type,uint8_t command_id,uint8_t engine_cut_off,uint8_t extra_param,float extra_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[15];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, mode);
_mav_put_uint16_t(buf, 3, shutter_speed);
_mav_put_uint8_t(buf, 5, aperture);
_mav_put_uint8_t(buf, 6, iso);
_mav_put_uint8_t(buf, 7, exposure_type);
_mav_put_uint8_t(buf, 8, command_id);
_mav_put_uint8_t(buf, 9, engine_cut_off);
_mav_put_uint8_t(buf, 10, extra_param);
_mav_put_float(buf, 11, extra_value);
memcpy(_MAV_PAYLOAD(msg), buf, 15);
#else
mavlink_digicam_configure_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mode = mode;
packet.shutter_speed = shutter_speed;
packet.aperture = aperture;
packet.iso = iso;
packet.exposure_type = exposure_type;
packet.command_id = command_id;
packet.engine_cut_off = engine_cut_off;
packet.extra_param = extra_param;
packet.extra_value = extra_value;
memcpy(_MAV_PAYLOAD(msg), &packet, 15);
#endif
msg->msgid = MAVLINK_MSG_ID_DIGICAM_CONFIGURE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 15);
}
/**
* @brief Encode a digicam_configure struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param digicam_configure C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_digicam_configure_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_digicam_configure_t* digicam_configure)
{
return mavlink_msg_digicam_configure_pack(system_id, component_id, msg, digicam_configure->target_system, digicam_configure->target_component, digicam_configure->mode, digicam_configure->shutter_speed, digicam_configure->aperture, digicam_configure->iso, digicam_configure->exposure_type, digicam_configure->command_id, digicam_configure->engine_cut_off, digicam_configure->extra_param, digicam_configure->extra_value);
}
/**
* @brief Send a digicam_configure message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param mode Mode enumeration from 1 to N //P, TV, AV, M, Etc (0 means ignore)
* @param shutter_speed Divisor number //e.g. 1000 means 1/1000 (0 means ignore)
* @param aperture F stop number x 10 //e.g. 28 means 2.8 (0 means ignore)
* @param iso ISO enumeration from 1 to N //e.g. 80, 100, 200, Etc (0 means ignore)
* @param exposure_type Exposure type enumeration from 1 to N (0 means ignore)
* @param command_id Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
* @param engine_cut_off Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)
* @param extra_param Extra parameters enumeration (0 means ignore)
* @param extra_value Correspondent value to given extra_param
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_digicam_configure_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t mode, uint16_t shutter_speed, uint8_t aperture, uint8_t iso, uint8_t exposure_type, uint8_t command_id, uint8_t engine_cut_off, uint8_t extra_param, float extra_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[15];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, mode);
_mav_put_uint16_t(buf, 3, shutter_speed);
_mav_put_uint8_t(buf, 5, aperture);
_mav_put_uint8_t(buf, 6, iso);
_mav_put_uint8_t(buf, 7, exposure_type);
_mav_put_uint8_t(buf, 8, command_id);
_mav_put_uint8_t(buf, 9, engine_cut_off);
_mav_put_uint8_t(buf, 10, extra_param);
_mav_put_float(buf, 11, extra_value);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DIGICAM_CONFIGURE, buf, 15);
#else
mavlink_digicam_configure_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mode = mode;
packet.shutter_speed = shutter_speed;
packet.aperture = aperture;
packet.iso = iso;
packet.exposure_type = exposure_type;
packet.command_id = command_id;
packet.engine_cut_off = engine_cut_off;
packet.extra_param = extra_param;
packet.extra_value = extra_value;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DIGICAM_CONFIGURE, (const char *)&packet, 15);
#endif
}
#endif
// MESSAGE DIGICAM_CONFIGURE UNPACKING
/**
* @brief Get field target_system from digicam_configure message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_digicam_configure_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from digicam_configure message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_digicam_configure_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field mode from digicam_configure message
*
* @return Mode enumeration from 1 to N //P, TV, AV, M, Etc (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_configure_get_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field shutter_speed from digicam_configure message
*
* @return Divisor number //e.g. 1000 means 1/1000 (0 means ignore)
*/
static inline uint16_t mavlink_msg_digicam_configure_get_shutter_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 3);
}
/**
* @brief Get field aperture from digicam_configure message
*
* @return F stop number x 10 //e.g. 28 means 2.8 (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_configure_get_aperture(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Get field iso from digicam_configure message
*
* @return ISO enumeration from 1 to N //e.g. 80, 100, 200, Etc (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_configure_get_iso(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 6);
}
/**
* @brief Get field exposure_type from digicam_configure message
*
* @return Exposure type enumeration from 1 to N (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_configure_get_exposure_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 7);
}
/**
* @brief Get field command_id from digicam_configure message
*
* @return Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
*/
static inline uint8_t mavlink_msg_digicam_configure_get_command_id(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 8);
}
/**
* @brief Get field engine_cut_off from digicam_configure message
*
* @return Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)
*/
static inline uint8_t mavlink_msg_digicam_configure_get_engine_cut_off(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 9);
}
/**
* @brief Get field extra_param from digicam_configure message
*
* @return Extra parameters enumeration (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_configure_get_extra_param(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 10);
}
/**
* @brief Get field extra_value from digicam_configure message
*
* @return Correspondent value to given extra_param
*/
static inline float mavlink_msg_digicam_configure_get_extra_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 11);
}
/**
* @brief Decode a digicam_configure message into a struct
*
* @param msg The message to decode
* @param digicam_configure C-struct to decode the message contents into
*/
static inline void mavlink_msg_digicam_configure_decode(const mavlink_message_t* msg, mavlink_digicam_configure_t* digicam_configure)
{
#if MAVLINK_NEED_BYTE_SWAP
digicam_configure->target_system = mavlink_msg_digicam_configure_get_target_system(msg);
digicam_configure->target_component = mavlink_msg_digicam_configure_get_target_component(msg);
digicam_configure->mode = mavlink_msg_digicam_configure_get_mode(msg);
digicam_configure->shutter_speed = mavlink_msg_digicam_configure_get_shutter_speed(msg);
digicam_configure->aperture = mavlink_msg_digicam_configure_get_aperture(msg);
digicam_configure->iso = mavlink_msg_digicam_configure_get_iso(msg);
digicam_configure->exposure_type = mavlink_msg_digicam_configure_get_exposure_type(msg);
digicam_configure->command_id = mavlink_msg_digicam_configure_get_command_id(msg);
digicam_configure->engine_cut_off = mavlink_msg_digicam_configure_get_engine_cut_off(msg);
digicam_configure->extra_param = mavlink_msg_digicam_configure_get_extra_param(msg);
digicam_configure->extra_value = mavlink_msg_digicam_configure_get_extra_value(msg);
#else
memcpy(digicam_configure, _MAV_PAYLOAD(msg), 15);
#endif
}
@@ -1,342 +0,0 @@
// MESSAGE DIGICAM_CONTROL PACKING
#define MAVLINK_MSG_ID_DIGICAM_CONTROL 155
typedef struct __mavlink_digicam_control_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t session; ///< 0: stop, 1: start or keep it up //Session control e.g. show/hide lens
uint8_t zoom_pos; ///< 1 to N //Zoom's absolute position (0 means ignore)
int8_t zoom_step; ///< -100 to 100 //Zooming step value to offset zoom from the current position
uint8_t focus_lock; ///< 0: unlock focus or keep unlocked, 1: lock focus or keep locked, 3: re-lock focus
uint8_t shot; ///< 0: ignore, 1: shot or start filming
uint8_t command_id; ///< Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
uint8_t extra_param; ///< Extra parameters enumeration (0 means ignore)
float extra_value; ///< Correspondent value to given extra_param
} mavlink_digicam_control_t;
#define MAVLINK_MSG_ID_DIGICAM_CONTROL_LEN 13
#define MAVLINK_MSG_ID_155_LEN 13
#define MAVLINK_MESSAGE_INFO_DIGICAM_CONTROL { \
"DIGICAM_CONTROL", \
10, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_digicam_control_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_digicam_control_t, target_component) }, \
{ "session", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_digicam_control_t, session) }, \
{ "zoom_pos", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_digicam_control_t, zoom_pos) }, \
{ "zoom_step", NULL, MAVLINK_TYPE_INT8_T, 0, 4, offsetof(mavlink_digicam_control_t, zoom_step) }, \
{ "focus_lock", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_digicam_control_t, focus_lock) }, \
{ "shot", NULL, MAVLINK_TYPE_UINT8_T, 0, 6, offsetof(mavlink_digicam_control_t, shot) }, \
{ "command_id", NULL, MAVLINK_TYPE_UINT8_T, 0, 7, offsetof(mavlink_digicam_control_t, command_id) }, \
{ "extra_param", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_digicam_control_t, extra_param) }, \
{ "extra_value", NULL, MAVLINK_TYPE_FLOAT, 0, 9, offsetof(mavlink_digicam_control_t, extra_value) }, \
} \
}
/**
* @brief Pack a digicam_control message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param session 0: stop, 1: start or keep it up //Session control e.g. show/hide lens
* @param zoom_pos 1 to N //Zoom's absolute position (0 means ignore)
* @param zoom_step -100 to 100 //Zooming step value to offset zoom from the current position
* @param focus_lock 0: unlock focus or keep unlocked, 1: lock focus or keep locked, 3: re-lock focus
* @param shot 0: ignore, 1: shot or start filming
* @param command_id Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
* @param extra_param Extra parameters enumeration (0 means ignore)
* @param extra_value Correspondent value to given extra_param
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_digicam_control_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t session, uint8_t zoom_pos, int8_t zoom_step, uint8_t focus_lock, uint8_t shot, uint8_t command_id, uint8_t extra_param, float extra_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[13];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, session);
_mav_put_uint8_t(buf, 3, zoom_pos);
_mav_put_int8_t(buf, 4, zoom_step);
_mav_put_uint8_t(buf, 5, focus_lock);
_mav_put_uint8_t(buf, 6, shot);
_mav_put_uint8_t(buf, 7, command_id);
_mav_put_uint8_t(buf, 8, extra_param);
_mav_put_float(buf, 9, extra_value);
memcpy(_MAV_PAYLOAD(msg), buf, 13);
#else
mavlink_digicam_control_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.session = session;
packet.zoom_pos = zoom_pos;
packet.zoom_step = zoom_step;
packet.focus_lock = focus_lock;
packet.shot = shot;
packet.command_id = command_id;
packet.extra_param = extra_param;
packet.extra_value = extra_value;
memcpy(_MAV_PAYLOAD(msg), &packet, 13);
#endif
msg->msgid = MAVLINK_MSG_ID_DIGICAM_CONTROL;
return mavlink_finalize_message(msg, system_id, component_id, 13);
}
/**
* @brief Pack a digicam_control message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param session 0: stop, 1: start or keep it up //Session control e.g. show/hide lens
* @param zoom_pos 1 to N //Zoom's absolute position (0 means ignore)
* @param zoom_step -100 to 100 //Zooming step value to offset zoom from the current position
* @param focus_lock 0: unlock focus or keep unlocked, 1: lock focus or keep locked, 3: re-lock focus
* @param shot 0: ignore, 1: shot or start filming
* @param command_id Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
* @param extra_param Extra parameters enumeration (0 means ignore)
* @param extra_value Correspondent value to given extra_param
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_digicam_control_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t session,uint8_t zoom_pos,int8_t zoom_step,uint8_t focus_lock,uint8_t shot,uint8_t command_id,uint8_t extra_param,float extra_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[13];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, session);
_mav_put_uint8_t(buf, 3, zoom_pos);
_mav_put_int8_t(buf, 4, zoom_step);
_mav_put_uint8_t(buf, 5, focus_lock);
_mav_put_uint8_t(buf, 6, shot);
_mav_put_uint8_t(buf, 7, command_id);
_mav_put_uint8_t(buf, 8, extra_param);
_mav_put_float(buf, 9, extra_value);
memcpy(_MAV_PAYLOAD(msg), buf, 13);
#else
mavlink_digicam_control_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.session = session;
packet.zoom_pos = zoom_pos;
packet.zoom_step = zoom_step;
packet.focus_lock = focus_lock;
packet.shot = shot;
packet.command_id = command_id;
packet.extra_param = extra_param;
packet.extra_value = extra_value;
memcpy(_MAV_PAYLOAD(msg), &packet, 13);
#endif
msg->msgid = MAVLINK_MSG_ID_DIGICAM_CONTROL;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 13);
}
/**
* @brief Encode a digicam_control struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param digicam_control C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_digicam_control_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_digicam_control_t* digicam_control)
{
return mavlink_msg_digicam_control_pack(system_id, component_id, msg, digicam_control->target_system, digicam_control->target_component, digicam_control->session, digicam_control->zoom_pos, digicam_control->zoom_step, digicam_control->focus_lock, digicam_control->shot, digicam_control->command_id, digicam_control->extra_param, digicam_control->extra_value);
}
/**
* @brief Send a digicam_control message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param session 0: stop, 1: start or keep it up //Session control e.g. show/hide lens
* @param zoom_pos 1 to N //Zoom's absolute position (0 means ignore)
* @param zoom_step -100 to 100 //Zooming step value to offset zoom from the current position
* @param focus_lock 0: unlock focus or keep unlocked, 1: lock focus or keep locked, 3: re-lock focus
* @param shot 0: ignore, 1: shot or start filming
* @param command_id Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
* @param extra_param Extra parameters enumeration (0 means ignore)
* @param extra_value Correspondent value to given extra_param
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_digicam_control_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t session, uint8_t zoom_pos, int8_t zoom_step, uint8_t focus_lock, uint8_t shot, uint8_t command_id, uint8_t extra_param, float extra_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[13];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, session);
_mav_put_uint8_t(buf, 3, zoom_pos);
_mav_put_int8_t(buf, 4, zoom_step);
_mav_put_uint8_t(buf, 5, focus_lock);
_mav_put_uint8_t(buf, 6, shot);
_mav_put_uint8_t(buf, 7, command_id);
_mav_put_uint8_t(buf, 8, extra_param);
_mav_put_float(buf, 9, extra_value);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DIGICAM_CONTROL, buf, 13);
#else
mavlink_digicam_control_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.session = session;
packet.zoom_pos = zoom_pos;
packet.zoom_step = zoom_step;
packet.focus_lock = focus_lock;
packet.shot = shot;
packet.command_id = command_id;
packet.extra_param = extra_param;
packet.extra_value = extra_value;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DIGICAM_CONTROL, (const char *)&packet, 13);
#endif
}
#endif
// MESSAGE DIGICAM_CONTROL UNPACKING
/**
* @brief Get field target_system from digicam_control message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_digicam_control_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from digicam_control message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_digicam_control_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field session from digicam_control message
*
* @return 0: stop, 1: start or keep it up //Session control e.g. show/hide lens
*/
static inline uint8_t mavlink_msg_digicam_control_get_session(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field zoom_pos from digicam_control message
*
* @return 1 to N //Zoom's absolute position (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_control_get_zoom_pos(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 3);
}
/**
* @brief Get field zoom_step from digicam_control message
*
* @return -100 to 100 //Zooming step value to offset zoom from the current position
*/
static inline int8_t mavlink_msg_digicam_control_get_zoom_step(const mavlink_message_t* msg)
{
return _MAV_RETURN_int8_t(msg, 4);
}
/**
* @brief Get field focus_lock from digicam_control message
*
* @return 0: unlock focus or keep unlocked, 1: lock focus or keep locked, 3: re-lock focus
*/
static inline uint8_t mavlink_msg_digicam_control_get_focus_lock(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Get field shot from digicam_control message
*
* @return 0: ignore, 1: shot or start filming
*/
static inline uint8_t mavlink_msg_digicam_control_get_shot(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 6);
}
/**
* @brief Get field command_id from digicam_control message
*
* @return Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once
*/
static inline uint8_t mavlink_msg_digicam_control_get_command_id(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 7);
}
/**
* @brief Get field extra_param from digicam_control message
*
* @return Extra parameters enumeration (0 means ignore)
*/
static inline uint8_t mavlink_msg_digicam_control_get_extra_param(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 8);
}
/**
* @brief Get field extra_value from digicam_control message
*
* @return Correspondent value to given extra_param
*/
static inline float mavlink_msg_digicam_control_get_extra_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 9);
}
/**
* @brief Decode a digicam_control message into a struct
*
* @param msg The message to decode
* @param digicam_control C-struct to decode the message contents into
*/
static inline void mavlink_msg_digicam_control_decode(const mavlink_message_t* msg, mavlink_digicam_control_t* digicam_control)
{
#if MAVLINK_NEED_BYTE_SWAP
digicam_control->target_system = mavlink_msg_digicam_control_get_target_system(msg);
digicam_control->target_component = mavlink_msg_digicam_control_get_target_component(msg);
digicam_control->session = mavlink_msg_digicam_control_get_session(msg);
digicam_control->zoom_pos = mavlink_msg_digicam_control_get_zoom_pos(msg);
digicam_control->zoom_step = mavlink_msg_digicam_control_get_zoom_step(msg);
digicam_control->focus_lock = mavlink_msg_digicam_control_get_focus_lock(msg);
digicam_control->shot = mavlink_msg_digicam_control_get_shot(msg);
digicam_control->command_id = mavlink_msg_digicam_control_get_command_id(msg);
digicam_control->extra_param = mavlink_msg_digicam_control_get_extra_param(msg);
digicam_control->extra_value = mavlink_msg_digicam_control_get_extra_value(msg);
#else
memcpy(digicam_control, _MAV_PAYLOAD(msg), 13);
#endif
}
@@ -1,188 +0,0 @@
// MESSAGE FENCE_FETCH_POINT PACKING
#define MAVLINK_MSG_ID_FENCE_FETCH_POINT 161
typedef struct __mavlink_fence_fetch_point_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t idx; ///< point index (first point is 1, 0 is for return point)
} mavlink_fence_fetch_point_t;
#define MAVLINK_MSG_ID_FENCE_FETCH_POINT_LEN 3
#define MAVLINK_MSG_ID_161_LEN 3
#define MAVLINK_MESSAGE_INFO_FENCE_FETCH_POINT { \
"FENCE_FETCH_POINT", \
3, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_fence_fetch_point_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_fence_fetch_point_t, target_component) }, \
{ "idx", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_fence_fetch_point_t, idx) }, \
} \
}
/**
* @brief Pack a fence_fetch_point message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param idx point index (first point is 1, 0 is for return point)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fence_fetch_point_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t idx)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, idx);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_fence_fetch_point_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.idx = idx;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCE_FETCH_POINT;
return mavlink_finalize_message(msg, system_id, component_id, 3);
}
/**
* @brief Pack a fence_fetch_point message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param idx point index (first point is 1, 0 is for return point)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fence_fetch_point_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t idx)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, idx);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_fence_fetch_point_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.idx = idx;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCE_FETCH_POINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 3);
}
/**
* @brief Encode a fence_fetch_point struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param fence_fetch_point C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_fence_fetch_point_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_fence_fetch_point_t* fence_fetch_point)
{
return mavlink_msg_fence_fetch_point_pack(system_id, component_id, msg, fence_fetch_point->target_system, fence_fetch_point->target_component, fence_fetch_point->idx);
}
/**
* @brief Send a fence_fetch_point message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param idx point index (first point is 1, 0 is for return point)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_fence_fetch_point_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t idx)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, idx);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCE_FETCH_POINT, buf, 3);
#else
mavlink_fence_fetch_point_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.idx = idx;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCE_FETCH_POINT, (const char *)&packet, 3);
#endif
}
#endif
// MESSAGE FENCE_FETCH_POINT UNPACKING
/**
* @brief Get field target_system from fence_fetch_point message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_fence_fetch_point_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from fence_fetch_point message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_fence_fetch_point_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field idx from fence_fetch_point message
*
* @return point index (first point is 1, 0 is for return point)
*/
static inline uint8_t mavlink_msg_fence_fetch_point_get_idx(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Decode a fence_fetch_point message into a struct
*
* @param msg The message to decode
* @param fence_fetch_point C-struct to decode the message contents into
*/
static inline void mavlink_msg_fence_fetch_point_decode(const mavlink_message_t* msg, mavlink_fence_fetch_point_t* fence_fetch_point)
{
#if MAVLINK_NEED_BYTE_SWAP
fence_fetch_point->target_system = mavlink_msg_fence_fetch_point_get_target_system(msg);
fence_fetch_point->target_component = mavlink_msg_fence_fetch_point_get_target_component(msg);
fence_fetch_point->idx = mavlink_msg_fence_fetch_point_get_idx(msg);
#else
memcpy(fence_fetch_point, _MAV_PAYLOAD(msg), 3);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE FENCE_POINT PACKING
#define MAVLINK_MSG_ID_FENCE_POINT 160
typedef struct __mavlink_fence_point_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t idx; ///< point index (first point is 1, 0 is for return point)
uint8_t count; ///< total number of points (for sanity checking)
float lat; ///< Latitude of point
float lng; ///< Longitude of point
} mavlink_fence_point_t;
#define MAVLINK_MSG_ID_FENCE_POINT_LEN 12
#define MAVLINK_MSG_ID_160_LEN 12
#define MAVLINK_MESSAGE_INFO_FENCE_POINT { \
"FENCE_POINT", \
6, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_fence_point_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_fence_point_t, target_component) }, \
{ "idx", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_fence_point_t, idx) }, \
{ "count", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_fence_point_t, count) }, \
{ "lat", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_fence_point_t, lat) }, \
{ "lng", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_fence_point_t, lng) }, \
} \
}
/**
* @brief Pack a fence_point message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param idx point index (first point is 1, 0 is for return point)
* @param count total number of points (for sanity checking)
* @param lat Latitude of point
* @param lng Longitude of point
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fence_point_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t idx, uint8_t count, float lat, float lng)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, idx);
_mav_put_uint8_t(buf, 3, count);
_mav_put_float(buf, 4, lat);
_mav_put_float(buf, 8, lng);
memcpy(_MAV_PAYLOAD(msg), buf, 12);
#else
mavlink_fence_point_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.idx = idx;
packet.count = count;
packet.lat = lat;
packet.lng = lng;
memcpy(_MAV_PAYLOAD(msg), &packet, 12);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCE_POINT;
return mavlink_finalize_message(msg, system_id, component_id, 12);
}
/**
* @brief Pack a fence_point message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param idx point index (first point is 1, 0 is for return point)
* @param count total number of points (for sanity checking)
* @param lat Latitude of point
* @param lng Longitude of point
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fence_point_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t idx,uint8_t count,float lat,float lng)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, idx);
_mav_put_uint8_t(buf, 3, count);
_mav_put_float(buf, 4, lat);
_mav_put_float(buf, 8, lng);
memcpy(_MAV_PAYLOAD(msg), buf, 12);
#else
mavlink_fence_point_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.idx = idx;
packet.count = count;
packet.lat = lat;
packet.lng = lng;
memcpy(_MAV_PAYLOAD(msg), &packet, 12);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCE_POINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 12);
}
/**
* @brief Encode a fence_point struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param fence_point C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_fence_point_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_fence_point_t* fence_point)
{
return mavlink_msg_fence_point_pack(system_id, component_id, msg, fence_point->target_system, fence_point->target_component, fence_point->idx, fence_point->count, fence_point->lat, fence_point->lng);
}
/**
* @brief Send a fence_point message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param idx point index (first point is 1, 0 is for return point)
* @param count total number of points (for sanity checking)
* @param lat Latitude of point
* @param lng Longitude of point
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_fence_point_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t idx, uint8_t count, float lat, float lng)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, idx);
_mav_put_uint8_t(buf, 3, count);
_mav_put_float(buf, 4, lat);
_mav_put_float(buf, 8, lng);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCE_POINT, buf, 12);
#else
mavlink_fence_point_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.idx = idx;
packet.count = count;
packet.lat = lat;
packet.lng = lng;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCE_POINT, (const char *)&packet, 12);
#endif
}
#endif
// MESSAGE FENCE_POINT UNPACKING
/**
* @brief Get field target_system from fence_point message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_fence_point_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from fence_point message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_fence_point_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field idx from fence_point message
*
* @return point index (first point is 1, 0 is for return point)
*/
static inline uint8_t mavlink_msg_fence_point_get_idx(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field count from fence_point message
*
* @return total number of points (for sanity checking)
*/
static inline uint8_t mavlink_msg_fence_point_get_count(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 3);
}
/**
* @brief Get field lat from fence_point message
*
* @return Latitude of point
*/
static inline float mavlink_msg_fence_point_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field lng from fence_point message
*
* @return Longitude of point
*/
static inline float mavlink_msg_fence_point_get_lng(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Decode a fence_point message into a struct
*
* @param msg The message to decode
* @param fence_point C-struct to decode the message contents into
*/
static inline void mavlink_msg_fence_point_decode(const mavlink_message_t* msg, mavlink_fence_point_t* fence_point)
{
#if MAVLINK_NEED_BYTE_SWAP
fence_point->target_system = mavlink_msg_fence_point_get_target_system(msg);
fence_point->target_component = mavlink_msg_fence_point_get_target_component(msg);
fence_point->idx = mavlink_msg_fence_point_get_idx(msg);
fence_point->count = mavlink_msg_fence_point_get_count(msg);
fence_point->lat = mavlink_msg_fence_point_get_lat(msg);
fence_point->lng = mavlink_msg_fence_point_get_lng(msg);
#else
memcpy(fence_point, _MAV_PAYLOAD(msg), 12);
#endif
}
@@ -1,210 +0,0 @@
// MESSAGE FENCE_STATUS PACKING
#define MAVLINK_MSG_ID_FENCE_STATUS 162
typedef struct __mavlink_fence_status_t
{
uint8_t breach_status; ///< 0 if currently inside fence, 1 if outside
uint16_t breach_count; ///< number of fence breaches
uint8_t breach_type; ///< last breach type (see FENCE_BREACH_* enum)
uint32_t breach_time; ///< time of last breach in milliseconds since boot
} mavlink_fence_status_t;
#define MAVLINK_MSG_ID_FENCE_STATUS_LEN 8
#define MAVLINK_MSG_ID_162_LEN 8
#define MAVLINK_MESSAGE_INFO_FENCE_STATUS { \
"FENCE_STATUS", \
4, \
{ { "breach_status", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_fence_status_t, breach_status) }, \
{ "breach_count", NULL, MAVLINK_TYPE_UINT16_T, 0, 1, offsetof(mavlink_fence_status_t, breach_count) }, \
{ "breach_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_fence_status_t, breach_type) }, \
{ "breach_time", NULL, MAVLINK_TYPE_UINT32_T, 0, 4, offsetof(mavlink_fence_status_t, breach_time) }, \
} \
}
/**
* @brief Pack a fence_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param breach_status 0 if currently inside fence, 1 if outside
* @param breach_count number of fence breaches
* @param breach_type last breach type (see FENCE_BREACH_* enum)
* @param breach_time time of last breach in milliseconds since boot
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fence_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t breach_status, uint16_t breach_count, uint8_t breach_type, uint32_t breach_time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, breach_status);
_mav_put_uint16_t(buf, 1, breach_count);
_mav_put_uint8_t(buf, 3, breach_type);
_mav_put_uint32_t(buf, 4, breach_time);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_fence_status_t packet;
packet.breach_status = breach_status;
packet.breach_count = breach_count;
packet.breach_type = breach_type;
packet.breach_time = breach_time;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCE_STATUS;
return mavlink_finalize_message(msg, system_id, component_id, 8);
}
/**
* @brief Pack a fence_status message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param breach_status 0 if currently inside fence, 1 if outside
* @param breach_count number of fence breaches
* @param breach_type last breach type (see FENCE_BREACH_* enum)
* @param breach_time time of last breach in milliseconds since boot
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fence_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t breach_status,uint16_t breach_count,uint8_t breach_type,uint32_t breach_time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, breach_status);
_mav_put_uint16_t(buf, 1, breach_count);
_mav_put_uint8_t(buf, 3, breach_type);
_mav_put_uint32_t(buf, 4, breach_time);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_fence_status_t packet;
packet.breach_status = breach_status;
packet.breach_count = breach_count;
packet.breach_type = breach_type;
packet.breach_time = breach_time;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCE_STATUS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 8);
}
/**
* @brief Encode a fence_status struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param fence_status C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_fence_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_fence_status_t* fence_status)
{
return mavlink_msg_fence_status_pack(system_id, component_id, msg, fence_status->breach_status, fence_status->breach_count, fence_status->breach_type, fence_status->breach_time);
}
/**
* @brief Send a fence_status message
* @param chan MAVLink channel to send the message
*
* @param breach_status 0 if currently inside fence, 1 if outside
* @param breach_count number of fence breaches
* @param breach_type last breach type (see FENCE_BREACH_* enum)
* @param breach_time time of last breach in milliseconds since boot
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_fence_status_send(mavlink_channel_t chan, uint8_t breach_status, uint16_t breach_count, uint8_t breach_type, uint32_t breach_time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, breach_status);
_mav_put_uint16_t(buf, 1, breach_count);
_mav_put_uint8_t(buf, 3, breach_type);
_mav_put_uint32_t(buf, 4, breach_time);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCE_STATUS, buf, 8);
#else
mavlink_fence_status_t packet;
packet.breach_status = breach_status;
packet.breach_count = breach_count;
packet.breach_type = breach_type;
packet.breach_time = breach_time;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCE_STATUS, (const char *)&packet, 8);
#endif
}
#endif
// MESSAGE FENCE_STATUS UNPACKING
/**
* @brief Get field breach_status from fence_status message
*
* @return 0 if currently inside fence, 1 if outside
*/
static inline uint8_t mavlink_msg_fence_status_get_breach_status(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field breach_count from fence_status message
*
* @return number of fence breaches
*/
static inline uint16_t mavlink_msg_fence_status_get_breach_count(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 1);
}
/**
* @brief Get field breach_type from fence_status message
*
* @return last breach type (see FENCE_BREACH_* enum)
*/
static inline uint8_t mavlink_msg_fence_status_get_breach_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 3);
}
/**
* @brief Get field breach_time from fence_status message
*
* @return time of last breach in milliseconds since boot
*/
static inline uint32_t mavlink_msg_fence_status_get_breach_time(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 4);
}
/**
* @brief Decode a fence_status message into a struct
*
* @param msg The message to decode
* @param fence_status C-struct to decode the message contents into
*/
static inline void mavlink_msg_fence_status_decode(const mavlink_message_t* msg, mavlink_fence_status_t* fence_status)
{
#if MAVLINK_NEED_BYTE_SWAP
fence_status->breach_status = mavlink_msg_fence_status_get_breach_status(msg);
fence_status->breach_count = mavlink_msg_fence_status_get_breach_count(msg);
fence_status->breach_type = mavlink_msg_fence_status_get_breach_type(msg);
fence_status->breach_time = mavlink_msg_fence_status_get_breach_time(msg);
#else
memcpy(fence_status, _MAV_PAYLOAD(msg), 8);
#endif
}
@@ -1,144 +0,0 @@
// MESSAGE FENCED_FETCH_POINT PACKING
#define MAVLINK_MSG_ID_FENCED_FETCH_POINT 161
typedef struct __mavlink_fenced_fetch_point_t
{
uint8_t idx; ///< point index (first point is 1, 0 is for return point)
} mavlink_fenced_fetch_point_t;
#define MAVLINK_MSG_ID_FENCED_FETCH_POINT_LEN 1
#define MAVLINK_MSG_ID_161_LEN 1
#define MAVLINK_MESSAGE_INFO_FENCED_FETCH_POINT { \
"FENCED_FETCH_POINT", \
1, \
{ { "idx", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_fenced_fetch_point_t, idx) }, \
} \
}
/**
* @brief Pack a fenced_fetch_point message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param idx point index (first point is 1, 0 is for return point)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fenced_fetch_point_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t idx)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[1];
_mav_put_uint8_t(buf, 0, idx);
memcpy(_MAV_PAYLOAD(msg), buf, 1);
#else
mavlink_fenced_fetch_point_t packet;
packet.idx = idx;
memcpy(_MAV_PAYLOAD(msg), &packet, 1);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCED_FETCH_POINT;
return mavlink_finalize_message(msg, system_id, component_id, 1);
}
/**
* @brief Pack a fenced_fetch_point message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param idx point index (first point is 1, 0 is for return point)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fenced_fetch_point_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t idx)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[1];
_mav_put_uint8_t(buf, 0, idx);
memcpy(_MAV_PAYLOAD(msg), buf, 1);
#else
mavlink_fenced_fetch_point_t packet;
packet.idx = idx;
memcpy(_MAV_PAYLOAD(msg), &packet, 1);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCED_FETCH_POINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 1);
}
/**
* @brief Encode a fenced_fetch_point struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param fenced_fetch_point C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_fenced_fetch_point_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_fenced_fetch_point_t* fenced_fetch_point)
{
return mavlink_msg_fenced_fetch_point_pack(system_id, component_id, msg, fenced_fetch_point->idx);
}
/**
* @brief Send a fenced_fetch_point message
* @param chan MAVLink channel to send the message
*
* @param idx point index (first point is 1, 0 is for return point)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_fenced_fetch_point_send(mavlink_channel_t chan, uint8_t idx)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[1];
_mav_put_uint8_t(buf, 0, idx);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCED_FETCH_POINT, buf, 1);
#else
mavlink_fenced_fetch_point_t packet;
packet.idx = idx;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCED_FETCH_POINT, (const char *)&packet, 1);
#endif
}
#endif
// MESSAGE FENCED_FETCH_POINT UNPACKING
/**
* @brief Get field idx from fenced_fetch_point message
*
* @return point index (first point is 1, 0 is for return point)
*/
static inline uint8_t mavlink_msg_fenced_fetch_point_get_idx(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Decode a fenced_fetch_point message into a struct
*
* @param msg The message to decode
* @param fenced_fetch_point C-struct to decode the message contents into
*/
static inline void mavlink_msg_fenced_fetch_point_decode(const mavlink_message_t* msg, mavlink_fenced_fetch_point_t* fenced_fetch_point)
{
#if MAVLINK_NEED_BYTE_SWAP
fenced_fetch_point->idx = mavlink_msg_fenced_fetch_point_get_idx(msg);
#else
memcpy(fenced_fetch_point, _MAV_PAYLOAD(msg), 1);
#endif
}
@@ -1,210 +0,0 @@
// MESSAGE FENCED_POINT PACKING
#define MAVLINK_MSG_ID_FENCED_POINT 160
typedef struct __mavlink_fenced_point_t
{
uint8_t idx; ///< point index (first point is 1, 0 is for return point)
uint8_t count; ///< total number of points (for sanity checking)
float lat; ///< Latitude of point
float lng; ///< Longitude of point
} mavlink_fenced_point_t;
#define MAVLINK_MSG_ID_FENCED_POINT_LEN 10
#define MAVLINK_MSG_ID_160_LEN 10
#define MAVLINK_MESSAGE_INFO_FENCED_POINT { \
"FENCED_POINT", \
4, \
{ { "idx", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_fenced_point_t, idx) }, \
{ "count", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_fenced_point_t, count) }, \
{ "lat", NULL, MAVLINK_TYPE_FLOAT, 0, 2, offsetof(mavlink_fenced_point_t, lat) }, \
{ "lng", NULL, MAVLINK_TYPE_FLOAT, 0, 6, offsetof(mavlink_fenced_point_t, lng) }, \
} \
}
/**
* @brief Pack a fenced_point message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param idx point index (first point is 1, 0 is for return point)
* @param count total number of points (for sanity checking)
* @param lat Latitude of point
* @param lng Longitude of point
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fenced_point_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t idx, uint8_t count, float lat, float lng)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[10];
_mav_put_uint8_t(buf, 0, idx);
_mav_put_uint8_t(buf, 1, count);
_mav_put_float(buf, 2, lat);
_mav_put_float(buf, 6, lng);
memcpy(_MAV_PAYLOAD(msg), buf, 10);
#else
mavlink_fenced_point_t packet;
packet.idx = idx;
packet.count = count;
packet.lat = lat;
packet.lng = lng;
memcpy(_MAV_PAYLOAD(msg), &packet, 10);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCED_POINT;
return mavlink_finalize_message(msg, system_id, component_id, 10);
}
/**
* @brief Pack a fenced_point message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param idx point index (first point is 1, 0 is for return point)
* @param count total number of points (for sanity checking)
* @param lat Latitude of point
* @param lng Longitude of point
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_fenced_point_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t idx,uint8_t count,float lat,float lng)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[10];
_mav_put_uint8_t(buf, 0, idx);
_mav_put_uint8_t(buf, 1, count);
_mav_put_float(buf, 2, lat);
_mav_put_float(buf, 6, lng);
memcpy(_MAV_PAYLOAD(msg), buf, 10);
#else
mavlink_fenced_point_t packet;
packet.idx = idx;
packet.count = count;
packet.lat = lat;
packet.lng = lng;
memcpy(_MAV_PAYLOAD(msg), &packet, 10);
#endif
msg->msgid = MAVLINK_MSG_ID_FENCED_POINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 10);
}
/**
* @brief Encode a fenced_point struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param fenced_point C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_fenced_point_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_fenced_point_t* fenced_point)
{
return mavlink_msg_fenced_point_pack(system_id, component_id, msg, fenced_point->idx, fenced_point->count, fenced_point->lat, fenced_point->lng);
}
/**
* @brief Send a fenced_point message
* @param chan MAVLink channel to send the message
*
* @param idx point index (first point is 1, 0 is for return point)
* @param count total number of points (for sanity checking)
* @param lat Latitude of point
* @param lng Longitude of point
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_fenced_point_send(mavlink_channel_t chan, uint8_t idx, uint8_t count, float lat, float lng)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[10];
_mav_put_uint8_t(buf, 0, idx);
_mav_put_uint8_t(buf, 1, count);
_mav_put_float(buf, 2, lat);
_mav_put_float(buf, 6, lng);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCED_POINT, buf, 10);
#else
mavlink_fenced_point_t packet;
packet.idx = idx;
packet.count = count;
packet.lat = lat;
packet.lng = lng;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FENCED_POINT, (const char *)&packet, 10);
#endif
}
#endif
// MESSAGE FENCED_POINT UNPACKING
/**
* @brief Get field idx from fenced_point message
*
* @return point index (first point is 1, 0 is for return point)
*/
static inline uint8_t mavlink_msg_fenced_point_get_idx(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field count from fenced_point message
*
* @return total number of points (for sanity checking)
*/
static inline uint8_t mavlink_msg_fenced_point_get_count(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field lat from fenced_point message
*
* @return Latitude of point
*/
static inline float mavlink_msg_fenced_point_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 2);
}
/**
* @brief Get field lng from fenced_point message
*
* @return Longitude of point
*/
static inline float mavlink_msg_fenced_point_get_lng(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 6);
}
/**
* @brief Decode a fenced_point message into a struct
*
* @param msg The message to decode
* @param fenced_point C-struct to decode the message contents into
*/
static inline void mavlink_msg_fenced_point_decode(const mavlink_message_t* msg, mavlink_fenced_point_t* fenced_point)
{
#if MAVLINK_NEED_BYTE_SWAP
fenced_point->idx = mavlink_msg_fenced_point_get_idx(msg);
fenced_point->count = mavlink_msg_fenced_point_get_count(msg);
fenced_point->lat = mavlink_msg_fenced_point_get_lat(msg);
fenced_point->lng = mavlink_msg_fenced_point_get_lng(msg);
#else
memcpy(fenced_point, _MAV_PAYLOAD(msg), 10);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE MOUNT_CONTROL PACKING
#define MAVLINK_MSG_ID_MOUNT_CONTROL 157
typedef struct __mavlink_mount_control_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
int32_t input_a; ///< pitch(deg*100) or lat, depending on mount mode
int32_t input_b; ///< roll(deg*100) or lon depending on mount mode
int32_t input_c; ///< yaw(deg*100) or alt (in cm) depending on mount mode
uint8_t save_position; ///< if "1" it will save current trimmed position on EEPROM (just valid for NEUTRAL and LANDING)
} mavlink_mount_control_t;
#define MAVLINK_MSG_ID_MOUNT_CONTROL_LEN 15
#define MAVLINK_MSG_ID_157_LEN 15
#define MAVLINK_MESSAGE_INFO_MOUNT_CONTROL { \
"MOUNT_CONTROL", \
6, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_mount_control_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_mount_control_t, target_component) }, \
{ "input_a", NULL, MAVLINK_TYPE_INT32_T, 0, 2, offsetof(mavlink_mount_control_t, input_a) }, \
{ "input_b", NULL, MAVLINK_TYPE_INT32_T, 0, 6, offsetof(mavlink_mount_control_t, input_b) }, \
{ "input_c", NULL, MAVLINK_TYPE_INT32_T, 0, 10, offsetof(mavlink_mount_control_t, input_c) }, \
{ "save_position", NULL, MAVLINK_TYPE_UINT8_T, 0, 14, offsetof(mavlink_mount_control_t, save_position) }, \
} \
}
/**
* @brief Pack a mount_control message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param input_a pitch(deg*100) or lat, depending on mount mode
* @param input_b roll(deg*100) or lon depending on mount mode
* @param input_c yaw(deg*100) or alt (in cm) depending on mount mode
* @param save_position if "1" it will save current trimmed position on EEPROM (just valid for NEUTRAL and LANDING)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_mount_control_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, int32_t input_a, int32_t input_b, int32_t input_c, uint8_t save_position)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[15];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, input_a);
_mav_put_int32_t(buf, 6, input_b);
_mav_put_int32_t(buf, 10, input_c);
_mav_put_uint8_t(buf, 14, save_position);
memcpy(_MAV_PAYLOAD(msg), buf, 15);
#else
mavlink_mount_control_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.input_a = input_a;
packet.input_b = input_b;
packet.input_c = input_c;
packet.save_position = save_position;
memcpy(_MAV_PAYLOAD(msg), &packet, 15);
#endif
msg->msgid = MAVLINK_MSG_ID_MOUNT_CONTROL;
return mavlink_finalize_message(msg, system_id, component_id, 15);
}
/**
* @brief Pack a mount_control message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param input_a pitch(deg*100) or lat, depending on mount mode
* @param input_b roll(deg*100) or lon depending on mount mode
* @param input_c yaw(deg*100) or alt (in cm) depending on mount mode
* @param save_position if "1" it will save current trimmed position on EEPROM (just valid for NEUTRAL and LANDING)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_mount_control_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,int32_t input_a,int32_t input_b,int32_t input_c,uint8_t save_position)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[15];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, input_a);
_mav_put_int32_t(buf, 6, input_b);
_mav_put_int32_t(buf, 10, input_c);
_mav_put_uint8_t(buf, 14, save_position);
memcpy(_MAV_PAYLOAD(msg), buf, 15);
#else
mavlink_mount_control_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.input_a = input_a;
packet.input_b = input_b;
packet.input_c = input_c;
packet.save_position = save_position;
memcpy(_MAV_PAYLOAD(msg), &packet, 15);
#endif
msg->msgid = MAVLINK_MSG_ID_MOUNT_CONTROL;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 15);
}
/**
* @brief Encode a mount_control struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param mount_control C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_mount_control_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_mount_control_t* mount_control)
{
return mavlink_msg_mount_control_pack(system_id, component_id, msg, mount_control->target_system, mount_control->target_component, mount_control->input_a, mount_control->input_b, mount_control->input_c, mount_control->save_position);
}
/**
* @brief Send a mount_control message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param input_a pitch(deg*100) or lat, depending on mount mode
* @param input_b roll(deg*100) or lon depending on mount mode
* @param input_c yaw(deg*100) or alt (in cm) depending on mount mode
* @param save_position if "1" it will save current trimmed position on EEPROM (just valid for NEUTRAL and LANDING)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_mount_control_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, int32_t input_a, int32_t input_b, int32_t input_c, uint8_t save_position)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[15];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, input_a);
_mav_put_int32_t(buf, 6, input_b);
_mav_put_int32_t(buf, 10, input_c);
_mav_put_uint8_t(buf, 14, save_position);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MOUNT_CONTROL, buf, 15);
#else
mavlink_mount_control_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.input_a = input_a;
packet.input_b = input_b;
packet.input_c = input_c;
packet.save_position = save_position;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MOUNT_CONTROL, (const char *)&packet, 15);
#endif
}
#endif
// MESSAGE MOUNT_CONTROL UNPACKING
/**
* @brief Get field target_system from mount_control message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_mount_control_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from mount_control message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_mount_control_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field input_a from mount_control message
*
* @return pitch(deg*100) or lat, depending on mount mode
*/
static inline int32_t mavlink_msg_mount_control_get_input_a(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 2);
}
/**
* @brief Get field input_b from mount_control message
*
* @return roll(deg*100) or lon depending on mount mode
*/
static inline int32_t mavlink_msg_mount_control_get_input_b(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 6);
}
/**
* @brief Get field input_c from mount_control message
*
* @return yaw(deg*100) or alt (in cm) depending on mount mode
*/
static inline int32_t mavlink_msg_mount_control_get_input_c(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 10);
}
/**
* @brief Get field save_position from mount_control message
*
* @return if "1" it will save current trimmed position on EEPROM (just valid for NEUTRAL and LANDING)
*/
static inline uint8_t mavlink_msg_mount_control_get_save_position(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 14);
}
/**
* @brief Decode a mount_control message into a struct
*
* @param msg The message to decode
* @param mount_control C-struct to decode the message contents into
*/
static inline void mavlink_msg_mount_control_decode(const mavlink_message_t* msg, mavlink_mount_control_t* mount_control)
{
#if MAVLINK_NEED_BYTE_SWAP
mount_control->target_system = mavlink_msg_mount_control_get_target_system(msg);
mount_control->target_component = mavlink_msg_mount_control_get_target_component(msg);
mount_control->input_a = mavlink_msg_mount_control_get_input_a(msg);
mount_control->input_b = mavlink_msg_mount_control_get_input_b(msg);
mount_control->input_c = mavlink_msg_mount_control_get_input_c(msg);
mount_control->save_position = mavlink_msg_mount_control_get_save_position(msg);
#else
memcpy(mount_control, _MAV_PAYLOAD(msg), 15);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE MOUNT_STATUS PACKING
#define MAVLINK_MSG_ID_MOUNT_STATUS 158
typedef struct __mavlink_mount_status_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
int32_t pointing_a; ///< pitch(deg*100) or lat, depending on mount mode
int32_t pointing_b; ///< roll(deg*100) or lon depending on mount mode
int32_t pointing_c; ///< yaw(deg*100) or alt (in cm) depending on mount mode
} mavlink_mount_status_t;
#define MAVLINK_MSG_ID_MOUNT_STATUS_LEN 14
#define MAVLINK_MSG_ID_158_LEN 14
#define MAVLINK_MESSAGE_INFO_MOUNT_STATUS { \
"MOUNT_STATUS", \
5, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_mount_status_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_mount_status_t, target_component) }, \
{ "pointing_a", NULL, MAVLINK_TYPE_INT32_T, 0, 2, offsetof(mavlink_mount_status_t, pointing_a) }, \
{ "pointing_b", NULL, MAVLINK_TYPE_INT32_T, 0, 6, offsetof(mavlink_mount_status_t, pointing_b) }, \
{ "pointing_c", NULL, MAVLINK_TYPE_INT32_T, 0, 10, offsetof(mavlink_mount_status_t, pointing_c) }, \
} \
}
/**
* @brief Pack a mount_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param pointing_a pitch(deg*100) or lat, depending on mount mode
* @param pointing_b roll(deg*100) or lon depending on mount mode
* @param pointing_c yaw(deg*100) or alt (in cm) depending on mount mode
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_mount_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, int32_t pointing_a, int32_t pointing_b, int32_t pointing_c)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, pointing_a);
_mav_put_int32_t(buf, 6, pointing_b);
_mav_put_int32_t(buf, 10, pointing_c);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_mount_status_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.pointing_a = pointing_a;
packet.pointing_b = pointing_b;
packet.pointing_c = pointing_c;
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_MOUNT_STATUS;
return mavlink_finalize_message(msg, system_id, component_id, 14);
}
/**
* @brief Pack a mount_status message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param pointing_a pitch(deg*100) or lat, depending on mount mode
* @param pointing_b roll(deg*100) or lon depending on mount mode
* @param pointing_c yaw(deg*100) or alt (in cm) depending on mount mode
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_mount_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,int32_t pointing_a,int32_t pointing_b,int32_t pointing_c)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, pointing_a);
_mav_put_int32_t(buf, 6, pointing_b);
_mav_put_int32_t(buf, 10, pointing_c);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_mount_status_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.pointing_a = pointing_a;
packet.pointing_b = pointing_b;
packet.pointing_c = pointing_c;
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_MOUNT_STATUS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 14);
}
/**
* @brief Encode a mount_status struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param mount_status C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_mount_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_mount_status_t* mount_status)
{
return mavlink_msg_mount_status_pack(system_id, component_id, msg, mount_status->target_system, mount_status->target_component, mount_status->pointing_a, mount_status->pointing_b, mount_status->pointing_c);
}
/**
* @brief Send a mount_status message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param pointing_a pitch(deg*100) or lat, depending on mount mode
* @param pointing_b roll(deg*100) or lon depending on mount mode
* @param pointing_c yaw(deg*100) or alt (in cm) depending on mount mode
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_mount_status_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, int32_t pointing_a, int32_t pointing_b, int32_t pointing_c)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, pointing_a);
_mav_put_int32_t(buf, 6, pointing_b);
_mav_put_int32_t(buf, 10, pointing_c);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MOUNT_STATUS, buf, 14);
#else
mavlink_mount_status_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.pointing_a = pointing_a;
packet.pointing_b = pointing_b;
packet.pointing_c = pointing_c;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MOUNT_STATUS, (const char *)&packet, 14);
#endif
}
#endif
// MESSAGE MOUNT_STATUS UNPACKING
/**
* @brief Get field target_system from mount_status message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_mount_status_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from mount_status message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_mount_status_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field pointing_a from mount_status message
*
* @return pitch(deg*100) or lat, depending on mount mode
*/
static inline int32_t mavlink_msg_mount_status_get_pointing_a(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 2);
}
/**
* @brief Get field pointing_b from mount_status message
*
* @return roll(deg*100) or lon depending on mount mode
*/
static inline int32_t mavlink_msg_mount_status_get_pointing_b(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 6);
}
/**
* @brief Get field pointing_c from mount_status message
*
* @return yaw(deg*100) or alt (in cm) depending on mount mode
*/
static inline int32_t mavlink_msg_mount_status_get_pointing_c(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 10);
}
/**
* @brief Decode a mount_status message into a struct
*
* @param msg The message to decode
* @param mount_status C-struct to decode the message contents into
*/
static inline void mavlink_msg_mount_status_decode(const mavlink_message_t* msg, mavlink_mount_status_t* mount_status)
{
#if MAVLINK_NEED_BYTE_SWAP
mount_status->target_system = mavlink_msg_mount_status_get_target_system(msg);
mount_status->target_component = mavlink_msg_mount_status_get_target_component(msg);
mount_status->pointing_a = mavlink_msg_mount_status_get_pointing_a(msg);
mount_status->pointing_b = mavlink_msg_mount_status_get_pointing_b(msg);
mount_status->pointing_c = mavlink_msg_mount_status_get_pointing_c(msg);
#else
memcpy(mount_status, _MAV_PAYLOAD(msg), 14);
#endif
}
@@ -1,386 +0,0 @@
// MESSAGE SENSOR_OFFSETS PACKING
#define MAVLINK_MSG_ID_SENSOR_OFFSETS 150
typedef struct __mavlink_sensor_offsets_t
{
int16_t mag_ofs_x; ///< magnetometer X offset
int16_t mag_ofs_y; ///< magnetometer Y offset
int16_t mag_ofs_z; ///< magnetometer Z offset
float mag_declination; ///< magnetic declination (radians)
int32_t raw_press; ///< raw pressure from barometer
int32_t raw_temp; ///< raw temperature from barometer
float gyro_cal_x; ///< gyro X calibration
float gyro_cal_y; ///< gyro Y calibration
float gyro_cal_z; ///< gyro Z calibration
float accel_cal_x; ///< accel X calibration
float accel_cal_y; ///< accel Y calibration
float accel_cal_z; ///< accel Z calibration
} mavlink_sensor_offsets_t;
#define MAVLINK_MSG_ID_SENSOR_OFFSETS_LEN 42
#define MAVLINK_MSG_ID_150_LEN 42
#define MAVLINK_MESSAGE_INFO_SENSOR_OFFSETS { \
"SENSOR_OFFSETS", \
12, \
{ { "mag_ofs_x", NULL, MAVLINK_TYPE_INT16_T, 0, 0, offsetof(mavlink_sensor_offsets_t, mag_ofs_x) }, \
{ "mag_ofs_y", NULL, MAVLINK_TYPE_INT16_T, 0, 2, offsetof(mavlink_sensor_offsets_t, mag_ofs_y) }, \
{ "mag_ofs_z", NULL, MAVLINK_TYPE_INT16_T, 0, 4, offsetof(mavlink_sensor_offsets_t, mag_ofs_z) }, \
{ "mag_declination", NULL, MAVLINK_TYPE_FLOAT, 0, 6, offsetof(mavlink_sensor_offsets_t, mag_declination) }, \
{ "raw_press", NULL, MAVLINK_TYPE_INT32_T, 0, 10, offsetof(mavlink_sensor_offsets_t, raw_press) }, \
{ "raw_temp", NULL, MAVLINK_TYPE_INT32_T, 0, 14, offsetof(mavlink_sensor_offsets_t, raw_temp) }, \
{ "gyro_cal_x", NULL, MAVLINK_TYPE_FLOAT, 0, 18, offsetof(mavlink_sensor_offsets_t, gyro_cal_x) }, \
{ "gyro_cal_y", NULL, MAVLINK_TYPE_FLOAT, 0, 22, offsetof(mavlink_sensor_offsets_t, gyro_cal_y) }, \
{ "gyro_cal_z", NULL, MAVLINK_TYPE_FLOAT, 0, 26, offsetof(mavlink_sensor_offsets_t, gyro_cal_z) }, \
{ "accel_cal_x", NULL, MAVLINK_TYPE_FLOAT, 0, 30, offsetof(mavlink_sensor_offsets_t, accel_cal_x) }, \
{ "accel_cal_y", NULL, MAVLINK_TYPE_FLOAT, 0, 34, offsetof(mavlink_sensor_offsets_t, accel_cal_y) }, \
{ "accel_cal_z", NULL, MAVLINK_TYPE_FLOAT, 0, 38, offsetof(mavlink_sensor_offsets_t, accel_cal_z) }, \
} \
}
/**
* @brief Pack a sensor_offsets message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param mag_ofs_x magnetometer X offset
* @param mag_ofs_y magnetometer Y offset
* @param mag_ofs_z magnetometer Z offset
* @param mag_declination magnetic declination (radians)
* @param raw_press raw pressure from barometer
* @param raw_temp raw temperature from barometer
* @param gyro_cal_x gyro X calibration
* @param gyro_cal_y gyro Y calibration
* @param gyro_cal_z gyro Z calibration
* @param accel_cal_x accel X calibration
* @param accel_cal_y accel Y calibration
* @param accel_cal_z accel Z calibration
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_sensor_offsets_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
int16_t mag_ofs_x, int16_t mag_ofs_y, int16_t mag_ofs_z, float mag_declination, int32_t raw_press, int32_t raw_temp, float gyro_cal_x, float gyro_cal_y, float gyro_cal_z, float accel_cal_x, float accel_cal_y, float accel_cal_z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[42];
_mav_put_int16_t(buf, 0, mag_ofs_x);
_mav_put_int16_t(buf, 2, mag_ofs_y);
_mav_put_int16_t(buf, 4, mag_ofs_z);
_mav_put_float(buf, 6, mag_declination);
_mav_put_int32_t(buf, 10, raw_press);
_mav_put_int32_t(buf, 14, raw_temp);
_mav_put_float(buf, 18, gyro_cal_x);
_mav_put_float(buf, 22, gyro_cal_y);
_mav_put_float(buf, 26, gyro_cal_z);
_mav_put_float(buf, 30, accel_cal_x);
_mav_put_float(buf, 34, accel_cal_y);
_mav_put_float(buf, 38, accel_cal_z);
memcpy(_MAV_PAYLOAD(msg), buf, 42);
#else
mavlink_sensor_offsets_t packet;
packet.mag_ofs_x = mag_ofs_x;
packet.mag_ofs_y = mag_ofs_y;
packet.mag_ofs_z = mag_ofs_z;
packet.mag_declination = mag_declination;
packet.raw_press = raw_press;
packet.raw_temp = raw_temp;
packet.gyro_cal_x = gyro_cal_x;
packet.gyro_cal_y = gyro_cal_y;
packet.gyro_cal_z = gyro_cal_z;
packet.accel_cal_x = accel_cal_x;
packet.accel_cal_y = accel_cal_y;
packet.accel_cal_z = accel_cal_z;
memcpy(_MAV_PAYLOAD(msg), &packet, 42);
#endif
msg->msgid = MAVLINK_MSG_ID_SENSOR_OFFSETS;
return mavlink_finalize_message(msg, system_id, component_id, 42);
}
/**
* @brief Pack a sensor_offsets message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param mag_ofs_x magnetometer X offset
* @param mag_ofs_y magnetometer Y offset
* @param mag_ofs_z magnetometer Z offset
* @param mag_declination magnetic declination (radians)
* @param raw_press raw pressure from barometer
* @param raw_temp raw temperature from barometer
* @param gyro_cal_x gyro X calibration
* @param gyro_cal_y gyro Y calibration
* @param gyro_cal_z gyro Z calibration
* @param accel_cal_x accel X calibration
* @param accel_cal_y accel Y calibration
* @param accel_cal_z accel Z calibration
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_sensor_offsets_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
int16_t mag_ofs_x,int16_t mag_ofs_y,int16_t mag_ofs_z,float mag_declination,int32_t raw_press,int32_t raw_temp,float gyro_cal_x,float gyro_cal_y,float gyro_cal_z,float accel_cal_x,float accel_cal_y,float accel_cal_z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[42];
_mav_put_int16_t(buf, 0, mag_ofs_x);
_mav_put_int16_t(buf, 2, mag_ofs_y);
_mav_put_int16_t(buf, 4, mag_ofs_z);
_mav_put_float(buf, 6, mag_declination);
_mav_put_int32_t(buf, 10, raw_press);
_mav_put_int32_t(buf, 14, raw_temp);
_mav_put_float(buf, 18, gyro_cal_x);
_mav_put_float(buf, 22, gyro_cal_y);
_mav_put_float(buf, 26, gyro_cal_z);
_mav_put_float(buf, 30, accel_cal_x);
_mav_put_float(buf, 34, accel_cal_y);
_mav_put_float(buf, 38, accel_cal_z);
memcpy(_MAV_PAYLOAD(msg), buf, 42);
#else
mavlink_sensor_offsets_t packet;
packet.mag_ofs_x = mag_ofs_x;
packet.mag_ofs_y = mag_ofs_y;
packet.mag_ofs_z = mag_ofs_z;
packet.mag_declination = mag_declination;
packet.raw_press = raw_press;
packet.raw_temp = raw_temp;
packet.gyro_cal_x = gyro_cal_x;
packet.gyro_cal_y = gyro_cal_y;
packet.gyro_cal_z = gyro_cal_z;
packet.accel_cal_x = accel_cal_x;
packet.accel_cal_y = accel_cal_y;
packet.accel_cal_z = accel_cal_z;
memcpy(_MAV_PAYLOAD(msg), &packet, 42);
#endif
msg->msgid = MAVLINK_MSG_ID_SENSOR_OFFSETS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 42);
}
/**
* @brief Encode a sensor_offsets struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param sensor_offsets C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_sensor_offsets_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_sensor_offsets_t* sensor_offsets)
{
return mavlink_msg_sensor_offsets_pack(system_id, component_id, msg, sensor_offsets->mag_ofs_x, sensor_offsets->mag_ofs_y, sensor_offsets->mag_ofs_z, sensor_offsets->mag_declination, sensor_offsets->raw_press, sensor_offsets->raw_temp, sensor_offsets->gyro_cal_x, sensor_offsets->gyro_cal_y, sensor_offsets->gyro_cal_z, sensor_offsets->accel_cal_x, sensor_offsets->accel_cal_y, sensor_offsets->accel_cal_z);
}
/**
* @brief Send a sensor_offsets message
* @param chan MAVLink channel to send the message
*
* @param mag_ofs_x magnetometer X offset
* @param mag_ofs_y magnetometer Y offset
* @param mag_ofs_z magnetometer Z offset
* @param mag_declination magnetic declination (radians)
* @param raw_press raw pressure from barometer
* @param raw_temp raw temperature from barometer
* @param gyro_cal_x gyro X calibration
* @param gyro_cal_y gyro Y calibration
* @param gyro_cal_z gyro Z calibration
* @param accel_cal_x accel X calibration
* @param accel_cal_y accel Y calibration
* @param accel_cal_z accel Z calibration
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_sensor_offsets_send(mavlink_channel_t chan, int16_t mag_ofs_x, int16_t mag_ofs_y, int16_t mag_ofs_z, float mag_declination, int32_t raw_press, int32_t raw_temp, float gyro_cal_x, float gyro_cal_y, float gyro_cal_z, float accel_cal_x, float accel_cal_y, float accel_cal_z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[42];
_mav_put_int16_t(buf, 0, mag_ofs_x);
_mav_put_int16_t(buf, 2, mag_ofs_y);
_mav_put_int16_t(buf, 4, mag_ofs_z);
_mav_put_float(buf, 6, mag_declination);
_mav_put_int32_t(buf, 10, raw_press);
_mav_put_int32_t(buf, 14, raw_temp);
_mav_put_float(buf, 18, gyro_cal_x);
_mav_put_float(buf, 22, gyro_cal_y);
_mav_put_float(buf, 26, gyro_cal_z);
_mav_put_float(buf, 30, accel_cal_x);
_mav_put_float(buf, 34, accel_cal_y);
_mav_put_float(buf, 38, accel_cal_z);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SENSOR_OFFSETS, buf, 42);
#else
mavlink_sensor_offsets_t packet;
packet.mag_ofs_x = mag_ofs_x;
packet.mag_ofs_y = mag_ofs_y;
packet.mag_ofs_z = mag_ofs_z;
packet.mag_declination = mag_declination;
packet.raw_press = raw_press;
packet.raw_temp = raw_temp;
packet.gyro_cal_x = gyro_cal_x;
packet.gyro_cal_y = gyro_cal_y;
packet.gyro_cal_z = gyro_cal_z;
packet.accel_cal_x = accel_cal_x;
packet.accel_cal_y = accel_cal_y;
packet.accel_cal_z = accel_cal_z;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SENSOR_OFFSETS, (const char *)&packet, 42);
#endif
}
#endif
// MESSAGE SENSOR_OFFSETS UNPACKING
/**
* @brief Get field mag_ofs_x from sensor_offsets message
*
* @return magnetometer X offset
*/
static inline int16_t mavlink_msg_sensor_offsets_get_mag_ofs_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 0);
}
/**
* @brief Get field mag_ofs_y from sensor_offsets message
*
* @return magnetometer Y offset
*/
static inline int16_t mavlink_msg_sensor_offsets_get_mag_ofs_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 2);
}
/**
* @brief Get field mag_ofs_z from sensor_offsets message
*
* @return magnetometer Z offset
*/
static inline int16_t mavlink_msg_sensor_offsets_get_mag_ofs_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 4);
}
/**
* @brief Get field mag_declination from sensor_offsets message
*
* @return magnetic declination (radians)
*/
static inline float mavlink_msg_sensor_offsets_get_mag_declination(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 6);
}
/**
* @brief Get field raw_press from sensor_offsets message
*
* @return raw pressure from barometer
*/
static inline int32_t mavlink_msg_sensor_offsets_get_raw_press(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 10);
}
/**
* @brief Get field raw_temp from sensor_offsets message
*
* @return raw temperature from barometer
*/
static inline int32_t mavlink_msg_sensor_offsets_get_raw_temp(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 14);
}
/**
* @brief Get field gyro_cal_x from sensor_offsets message
*
* @return gyro X calibration
*/
static inline float mavlink_msg_sensor_offsets_get_gyro_cal_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 18);
}
/**
* @brief Get field gyro_cal_y from sensor_offsets message
*
* @return gyro Y calibration
*/
static inline float mavlink_msg_sensor_offsets_get_gyro_cal_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 22);
}
/**
* @brief Get field gyro_cal_z from sensor_offsets message
*
* @return gyro Z calibration
*/
static inline float mavlink_msg_sensor_offsets_get_gyro_cal_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 26);
}
/**
* @brief Get field accel_cal_x from sensor_offsets message
*
* @return accel X calibration
*/
static inline float mavlink_msg_sensor_offsets_get_accel_cal_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 30);
}
/**
* @brief Get field accel_cal_y from sensor_offsets message
*
* @return accel Y calibration
*/
static inline float mavlink_msg_sensor_offsets_get_accel_cal_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 34);
}
/**
* @brief Get field accel_cal_z from sensor_offsets message
*
* @return accel Z calibration
*/
static inline float mavlink_msg_sensor_offsets_get_accel_cal_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 38);
}
/**
* @brief Decode a sensor_offsets message into a struct
*
* @param msg The message to decode
* @param sensor_offsets C-struct to decode the message contents into
*/
static inline void mavlink_msg_sensor_offsets_decode(const mavlink_message_t* msg, mavlink_sensor_offsets_t* sensor_offsets)
{
#if MAVLINK_NEED_BYTE_SWAP
sensor_offsets->mag_ofs_x = mavlink_msg_sensor_offsets_get_mag_ofs_x(msg);
sensor_offsets->mag_ofs_y = mavlink_msg_sensor_offsets_get_mag_ofs_y(msg);
sensor_offsets->mag_ofs_z = mavlink_msg_sensor_offsets_get_mag_ofs_z(msg);
sensor_offsets->mag_declination = mavlink_msg_sensor_offsets_get_mag_declination(msg);
sensor_offsets->raw_press = mavlink_msg_sensor_offsets_get_raw_press(msg);
sensor_offsets->raw_temp = mavlink_msg_sensor_offsets_get_raw_temp(msg);
sensor_offsets->gyro_cal_x = mavlink_msg_sensor_offsets_get_gyro_cal_x(msg);
sensor_offsets->gyro_cal_y = mavlink_msg_sensor_offsets_get_gyro_cal_y(msg);
sensor_offsets->gyro_cal_z = mavlink_msg_sensor_offsets_get_gyro_cal_z(msg);
sensor_offsets->accel_cal_x = mavlink_msg_sensor_offsets_get_accel_cal_x(msg);
sensor_offsets->accel_cal_y = mavlink_msg_sensor_offsets_get_accel_cal_y(msg);
sensor_offsets->accel_cal_z = mavlink_msg_sensor_offsets_get_accel_cal_z(msg);
#else
memcpy(sensor_offsets, _MAV_PAYLOAD(msg), 42);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE SET_MAG_OFFSETS PACKING
#define MAVLINK_MSG_ID_SET_MAG_OFFSETS 151
typedef struct __mavlink_set_mag_offsets_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
int16_t mag_ofs_x; ///< magnetometer X offset
int16_t mag_ofs_y; ///< magnetometer Y offset
int16_t mag_ofs_z; ///< magnetometer Z offset
} mavlink_set_mag_offsets_t;
#define MAVLINK_MSG_ID_SET_MAG_OFFSETS_LEN 8
#define MAVLINK_MSG_ID_151_LEN 8
#define MAVLINK_MESSAGE_INFO_SET_MAG_OFFSETS { \
"SET_MAG_OFFSETS", \
5, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_set_mag_offsets_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_set_mag_offsets_t, target_component) }, \
{ "mag_ofs_x", NULL, MAVLINK_TYPE_INT16_T, 0, 2, offsetof(mavlink_set_mag_offsets_t, mag_ofs_x) }, \
{ "mag_ofs_y", NULL, MAVLINK_TYPE_INT16_T, 0, 4, offsetof(mavlink_set_mag_offsets_t, mag_ofs_y) }, \
{ "mag_ofs_z", NULL, MAVLINK_TYPE_INT16_T, 0, 6, offsetof(mavlink_set_mag_offsets_t, mag_ofs_z) }, \
} \
}
/**
* @brief Pack a set_mag_offsets message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param mag_ofs_x magnetometer X offset
* @param mag_ofs_y magnetometer Y offset
* @param mag_ofs_z magnetometer Z offset
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_mag_offsets_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, int16_t mag_ofs_x, int16_t mag_ofs_y, int16_t mag_ofs_z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int16_t(buf, 2, mag_ofs_x);
_mav_put_int16_t(buf, 4, mag_ofs_y);
_mav_put_int16_t(buf, 6, mag_ofs_z);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_set_mag_offsets_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mag_ofs_x = mag_ofs_x;
packet.mag_ofs_y = mag_ofs_y;
packet.mag_ofs_z = mag_ofs_z;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_MAG_OFFSETS;
return mavlink_finalize_message(msg, system_id, component_id, 8);
}
/**
* @brief Pack a set_mag_offsets message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param mag_ofs_x magnetometer X offset
* @param mag_ofs_y magnetometer Y offset
* @param mag_ofs_z magnetometer Z offset
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_mag_offsets_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,int16_t mag_ofs_x,int16_t mag_ofs_y,int16_t mag_ofs_z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int16_t(buf, 2, mag_ofs_x);
_mav_put_int16_t(buf, 4, mag_ofs_y);
_mav_put_int16_t(buf, 6, mag_ofs_z);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_set_mag_offsets_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mag_ofs_x = mag_ofs_x;
packet.mag_ofs_y = mag_ofs_y;
packet.mag_ofs_z = mag_ofs_z;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_MAG_OFFSETS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 8);
}
/**
* @brief Encode a set_mag_offsets struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_mag_offsets C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_mag_offsets_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_mag_offsets_t* set_mag_offsets)
{
return mavlink_msg_set_mag_offsets_pack(system_id, component_id, msg, set_mag_offsets->target_system, set_mag_offsets->target_component, set_mag_offsets->mag_ofs_x, set_mag_offsets->mag_ofs_y, set_mag_offsets->mag_ofs_z);
}
/**
* @brief Send a set_mag_offsets message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param mag_ofs_x magnetometer X offset
* @param mag_ofs_y magnetometer Y offset
* @param mag_ofs_z magnetometer Z offset
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_mag_offsets_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, int16_t mag_ofs_x, int16_t mag_ofs_y, int16_t mag_ofs_z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int16_t(buf, 2, mag_ofs_x);
_mav_put_int16_t(buf, 4, mag_ofs_y);
_mav_put_int16_t(buf, 6, mag_ofs_z);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_MAG_OFFSETS, buf, 8);
#else
mavlink_set_mag_offsets_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mag_ofs_x = mag_ofs_x;
packet.mag_ofs_y = mag_ofs_y;
packet.mag_ofs_z = mag_ofs_z;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_MAG_OFFSETS, (const char *)&packet, 8);
#endif
}
#endif
// MESSAGE SET_MAG_OFFSETS UNPACKING
/**
* @brief Get field target_system from set_mag_offsets message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_set_mag_offsets_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from set_mag_offsets message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_set_mag_offsets_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field mag_ofs_x from set_mag_offsets message
*
* @return magnetometer X offset
*/
static inline int16_t mavlink_msg_set_mag_offsets_get_mag_ofs_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 2);
}
/**
* @brief Get field mag_ofs_y from set_mag_offsets message
*
* @return magnetometer Y offset
*/
static inline int16_t mavlink_msg_set_mag_offsets_get_mag_ofs_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 4);
}
/**
* @brief Get field mag_ofs_z from set_mag_offsets message
*
* @return magnetometer Z offset
*/
static inline int16_t mavlink_msg_set_mag_offsets_get_mag_ofs_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 6);
}
/**
* @brief Decode a set_mag_offsets message into a struct
*
* @param msg The message to decode
* @param set_mag_offsets C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_mag_offsets_decode(const mavlink_message_t* msg, mavlink_set_mag_offsets_t* set_mag_offsets)
{
#if MAVLINK_NEED_BYTE_SWAP
set_mag_offsets->target_system = mavlink_msg_set_mag_offsets_get_target_system(msg);
set_mag_offsets->target_component = mavlink_msg_set_mag_offsets_get_target_component(msg);
set_mag_offsets->mag_ofs_x = mavlink_msg_set_mag_offsets_get_mag_ofs_x(msg);
set_mag_offsets->mag_ofs_y = mavlink_msg_set_mag_offsets_get_mag_ofs_y(msg);
set_mag_offsets->mag_ofs_z = mavlink_msg_set_mag_offsets_get_mag_ofs_z(msg);
#else
memcpy(set_mag_offsets, _MAV_PAYLOAD(msg), 8);
#endif
}
@@ -1,690 +0,0 @@
/** @file
* @brief MAVLink comm protocol testsuite generated from ardupilotmega.xml
* @see http://qgroundcontrol.org/mavlink/
*/
#ifndef ARDUPILOTMEGA_TESTSUITE_H
#define ARDUPILOTMEGA_TESTSUITE_H
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MAVLINK_TEST_ALL
#define MAVLINK_TEST_ALL
static void mavlink_test_common(uint8_t, uint8_t, mavlink_message_t *last_msg);
static void mavlink_test_ardupilotmega(uint8_t, uint8_t, mavlink_message_t *last_msg);
static void mavlink_test_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_test_common(system_id, component_id, last_msg);
mavlink_test_ardupilotmega(system_id, component_id, last_msg);
}
#endif
#include "../common/testsuite.h"
static void mavlink_test_sensor_offsets(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_sensor_offsets_t packet_in = {
17235,
17339,
17443,
59.0,
963497984,
963498192,
143.0,
171.0,
199.0,
227.0,
255.0,
283.0,
};
mavlink_sensor_offsets_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.mag_ofs_x = packet_in.mag_ofs_x;
packet1.mag_ofs_y = packet_in.mag_ofs_y;
packet1.mag_ofs_z = packet_in.mag_ofs_z;
packet1.mag_declination = packet_in.mag_declination;
packet1.raw_press = packet_in.raw_press;
packet1.raw_temp = packet_in.raw_temp;
packet1.gyro_cal_x = packet_in.gyro_cal_x;
packet1.gyro_cal_y = packet_in.gyro_cal_y;
packet1.gyro_cal_z = packet_in.gyro_cal_z;
packet1.accel_cal_x = packet_in.accel_cal_x;
packet1.accel_cal_y = packet_in.accel_cal_y;
packet1.accel_cal_z = packet_in.accel_cal_z;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_sensor_offsets_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_sensor_offsets_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_sensor_offsets_pack(system_id, component_id, &msg , packet1.mag_ofs_x , packet1.mag_ofs_y , packet1.mag_ofs_z , packet1.mag_declination , packet1.raw_press , packet1.raw_temp , packet1.gyro_cal_x , packet1.gyro_cal_y , packet1.gyro_cal_z , packet1.accel_cal_x , packet1.accel_cal_y , packet1.accel_cal_z );
mavlink_msg_sensor_offsets_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_sensor_offsets_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.mag_ofs_x , packet1.mag_ofs_y , packet1.mag_ofs_z , packet1.mag_declination , packet1.raw_press , packet1.raw_temp , packet1.gyro_cal_x , packet1.gyro_cal_y , packet1.gyro_cal_z , packet1.accel_cal_x , packet1.accel_cal_y , packet1.accel_cal_z );
mavlink_msg_sensor_offsets_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_sensor_offsets_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_sensor_offsets_send(MAVLINK_COMM_1 , packet1.mag_ofs_x , packet1.mag_ofs_y , packet1.mag_ofs_z , packet1.mag_declination , packet1.raw_press , packet1.raw_temp , packet1.gyro_cal_x , packet1.gyro_cal_y , packet1.gyro_cal_z , packet1.accel_cal_x , packet1.accel_cal_y , packet1.accel_cal_z );
mavlink_msg_sensor_offsets_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_set_mag_offsets(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_set_mag_offsets_t packet_in = {
5,
72,
17339,
17443,
17547,
};
mavlink_set_mag_offsets_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.mag_ofs_x = packet_in.mag_ofs_x;
packet1.mag_ofs_y = packet_in.mag_ofs_y;
packet1.mag_ofs_z = packet_in.mag_ofs_z;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_set_mag_offsets_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_set_mag_offsets_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_set_mag_offsets_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.mag_ofs_x , packet1.mag_ofs_y , packet1.mag_ofs_z );
mavlink_msg_set_mag_offsets_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_set_mag_offsets_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.mag_ofs_x , packet1.mag_ofs_y , packet1.mag_ofs_z );
mavlink_msg_set_mag_offsets_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_set_mag_offsets_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_set_mag_offsets_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.mag_ofs_x , packet1.mag_ofs_y , packet1.mag_ofs_z );
mavlink_msg_set_mag_offsets_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_meminfo(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_meminfo_t packet_in = {
17235,
17339,
};
mavlink_meminfo_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.brkval = packet_in.brkval;
packet1.freemem = packet_in.freemem;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_meminfo_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_meminfo_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_meminfo_pack(system_id, component_id, &msg , packet1.brkval , packet1.freemem );
mavlink_msg_meminfo_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_meminfo_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.brkval , packet1.freemem );
mavlink_msg_meminfo_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_meminfo_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_meminfo_send(MAVLINK_COMM_1 , packet1.brkval , packet1.freemem );
mavlink_msg_meminfo_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_ap_adc(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_ap_adc_t packet_in = {
17235,
17339,
17443,
17547,
17651,
17755,
};
mavlink_ap_adc_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.adc1 = packet_in.adc1;
packet1.adc2 = packet_in.adc2;
packet1.adc3 = packet_in.adc3;
packet1.adc4 = packet_in.adc4;
packet1.adc5 = packet_in.adc5;
packet1.adc6 = packet_in.adc6;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_ap_adc_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_ap_adc_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_ap_adc_pack(system_id, component_id, &msg , packet1.adc1 , packet1.adc2 , packet1.adc3 , packet1.adc4 , packet1.adc5 , packet1.adc6 );
mavlink_msg_ap_adc_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_ap_adc_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.adc1 , packet1.adc2 , packet1.adc3 , packet1.adc4 , packet1.adc5 , packet1.adc6 );
mavlink_msg_ap_adc_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_ap_adc_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_ap_adc_send(MAVLINK_COMM_1 , packet1.adc1 , packet1.adc2 , packet1.adc3 , packet1.adc4 , packet1.adc5 , packet1.adc6 );
mavlink_msg_ap_adc_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_digicam_configure(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_digicam_configure_t packet_in = {
5,
72,
139,
17391,
84,
151,
218,
29,
96,
163,
94.0,
};
mavlink_digicam_configure_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.mode = packet_in.mode;
packet1.shutter_speed = packet_in.shutter_speed;
packet1.aperture = packet_in.aperture;
packet1.iso = packet_in.iso;
packet1.exposure_type = packet_in.exposure_type;
packet1.command_id = packet_in.command_id;
packet1.engine_cut_off = packet_in.engine_cut_off;
packet1.extra_param = packet_in.extra_param;
packet1.extra_value = packet_in.extra_value;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_configure_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_digicam_configure_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_configure_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.mode , packet1.shutter_speed , packet1.aperture , packet1.iso , packet1.exposure_type , packet1.command_id , packet1.engine_cut_off , packet1.extra_param , packet1.extra_value );
mavlink_msg_digicam_configure_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_configure_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.mode , packet1.shutter_speed , packet1.aperture , packet1.iso , packet1.exposure_type , packet1.command_id , packet1.engine_cut_off , packet1.extra_param , packet1.extra_value );
mavlink_msg_digicam_configure_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_digicam_configure_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_configure_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.mode , packet1.shutter_speed , packet1.aperture , packet1.iso , packet1.exposure_type , packet1.command_id , packet1.engine_cut_off , packet1.extra_param , packet1.extra_value );
mavlink_msg_digicam_configure_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_digicam_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_digicam_control_t packet_in = {
5,
72,
139,
206,
17,
84,
151,
218,
29,
80.0,
};
mavlink_digicam_control_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.session = packet_in.session;
packet1.zoom_pos = packet_in.zoom_pos;
packet1.zoom_step = packet_in.zoom_step;
packet1.focus_lock = packet_in.focus_lock;
packet1.shot = packet_in.shot;
packet1.command_id = packet_in.command_id;
packet1.extra_param = packet_in.extra_param;
packet1.extra_value = packet_in.extra_value;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_control_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_digicam_control_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_control_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.session , packet1.zoom_pos , packet1.zoom_step , packet1.focus_lock , packet1.shot , packet1.command_id , packet1.extra_param , packet1.extra_value );
mavlink_msg_digicam_control_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_control_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.session , packet1.zoom_pos , packet1.zoom_step , packet1.focus_lock , packet1.shot , packet1.command_id , packet1.extra_param , packet1.extra_value );
mavlink_msg_digicam_control_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_digicam_control_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_digicam_control_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.session , packet1.zoom_pos , packet1.zoom_step , packet1.focus_lock , packet1.shot , packet1.command_id , packet1.extra_param , packet1.extra_value );
mavlink_msg_digicam_control_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_mount_configure(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_mount_configure_t packet_in = {
5,
72,
139,
206,
17,
84,
};
mavlink_mount_configure_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.mount_mode = packet_in.mount_mode;
packet1.stab_roll = packet_in.stab_roll;
packet1.stab_pitch = packet_in.stab_pitch;
packet1.stab_yaw = packet_in.stab_yaw;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_configure_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_mount_configure_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_configure_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.mount_mode , packet1.stab_roll , packet1.stab_pitch , packet1.stab_yaw );
mavlink_msg_mount_configure_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_configure_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.mount_mode , packet1.stab_roll , packet1.stab_pitch , packet1.stab_yaw );
mavlink_msg_mount_configure_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_mount_configure_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_configure_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.mount_mode , packet1.stab_roll , packet1.stab_pitch , packet1.stab_yaw );
mavlink_msg_mount_configure_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_mount_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_mount_control_t packet_in = {
5,
72,
963497568,
963497776,
963497984,
175,
};
mavlink_mount_control_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.input_a = packet_in.input_a;
packet1.input_b = packet_in.input_b;
packet1.input_c = packet_in.input_c;
packet1.save_position = packet_in.save_position;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_control_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_mount_control_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_control_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.input_a , packet1.input_b , packet1.input_c , packet1.save_position );
mavlink_msg_mount_control_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_control_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.input_a , packet1.input_b , packet1.input_c , packet1.save_position );
mavlink_msg_mount_control_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_mount_control_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_control_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.input_a , packet1.input_b , packet1.input_c , packet1.save_position );
mavlink_msg_mount_control_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_mount_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_mount_status_t packet_in = {
5,
72,
963497568,
963497776,
963497984,
};
mavlink_mount_status_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.pointing_a = packet_in.pointing_a;
packet1.pointing_b = packet_in.pointing_b;
packet1.pointing_c = packet_in.pointing_c;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_status_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_mount_status_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_status_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.pointing_a , packet1.pointing_b , packet1.pointing_c );
mavlink_msg_mount_status_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.pointing_a , packet1.pointing_b , packet1.pointing_c );
mavlink_msg_mount_status_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_mount_status_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_mount_status_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.pointing_a , packet1.pointing_b , packet1.pointing_c );
mavlink_msg_mount_status_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_fence_point(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_fence_point_t packet_in = {
5,
72,
139,
206,
45.0,
73.0,
};
mavlink_fence_point_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.idx = packet_in.idx;
packet1.count = packet_in.count;
packet1.lat = packet_in.lat;
packet1.lng = packet_in.lng;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_point_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_fence_point_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_point_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.idx , packet1.count , packet1.lat , packet1.lng );
mavlink_msg_fence_point_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_point_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.idx , packet1.count , packet1.lat , packet1.lng );
mavlink_msg_fence_point_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_fence_point_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_point_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.idx , packet1.count , packet1.lat , packet1.lng );
mavlink_msg_fence_point_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_fence_fetch_point(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_fence_fetch_point_t packet_in = {
5,
72,
139,
};
mavlink_fence_fetch_point_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.target_system = packet_in.target_system;
packet1.target_component = packet_in.target_component;
packet1.idx = packet_in.idx;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_fetch_point_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_fence_fetch_point_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_fetch_point_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.idx );
mavlink_msg_fence_fetch_point_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_fetch_point_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.idx );
mavlink_msg_fence_fetch_point_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_fence_fetch_point_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_fetch_point_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.idx );
mavlink_msg_fence_fetch_point_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_fence_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_message_t msg;
uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
uint16_t i;
mavlink_fence_status_t packet_in = {
5,
17287,
206,
963497672,
};
mavlink_fence_status_t packet1, packet2;
memset(&packet1, 0, sizeof(packet1));
packet1.breach_status = packet_in.breach_status;
packet1.breach_count = packet_in.breach_count;
packet1.breach_type = packet_in.breach_type;
packet1.breach_time = packet_in.breach_time;
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_status_encode(system_id, component_id, &msg, &packet1);
mavlink_msg_fence_status_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_status_pack(system_id, component_id, &msg , packet1.breach_status , packet1.breach_count , packet1.breach_type , packet1.breach_time );
mavlink_msg_fence_status_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.breach_status , packet1.breach_count , packet1.breach_type , packet1.breach_time );
mavlink_msg_fence_status_decode(&msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_to_send_buffer(buffer, &msg);
for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
comm_send_ch(MAVLINK_COMM_0, buffer[i]);
}
mavlink_msg_fence_status_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
memset(&packet2, 0, sizeof(packet2));
mavlink_msg_fence_status_send(MAVLINK_COMM_1 , packet1.breach_status , packet1.breach_count , packet1.breach_type , packet1.breach_time );
mavlink_msg_fence_status_decode(last_msg, &packet2);
MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}
static void mavlink_test_ardupilotmega(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
mavlink_test_sensor_offsets(system_id, component_id, last_msg);
mavlink_test_set_mag_offsets(system_id, component_id, last_msg);
mavlink_test_meminfo(system_id, component_id, last_msg);
mavlink_test_ap_adc(system_id, component_id, last_msg);
mavlink_test_digicam_configure(system_id, component_id, last_msg);
mavlink_test_digicam_control(system_id, component_id, last_msg);
mavlink_test_mount_configure(system_id, component_id, last_msg);
mavlink_test_mount_control(system_id, component_id, last_msg);
mavlink_test_mount_status(system_id, component_id, last_msg);
mavlink_test_fence_point(system_id, component_id, last_msg);
mavlink_test_fence_fetch_point(system_id, component_id, last_msg);
mavlink_test_fence_status(system_id, component_id, last_msg);
}
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // ARDUPILOTMEGA_TESTSUITE_H
@@ -1,12 +0,0 @@
/** @file
* @brief MAVLink comm protocol built from ardupilotmega.xml
* @see http://pixhawk.ethz.ch/software/mavlink
*/
#ifndef MAVLINK_VERSION_H
#define MAVLINK_VERSION_H
#define MAVLINK_BUILD_DATE "Fri Dec 16 12:39:09 2011"
#define MAVLINK_WIRE_PROTOCOL_VERSION "0.9"
#define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 101
#endif // MAVLINK_VERSION_H
-159
View File
@@ -1,159 +0,0 @@
/** @file
* @brief MAVLink comm protocol generated from common.xml
* @see http://qgroundcontrol.org/mavlink/
*/
#ifndef COMMON_H
#define COMMON_H
#ifdef __cplusplus
extern "C" {
#endif
// MESSAGE LENGTHS AND CRCS
#ifndef MAVLINK_MESSAGE_LENGTHS
#define MAVLINK_MESSAGE_LENGTHS {3, 4, 8, 14, 8, 28, 3, 32, 0, 2, 3, 2, 2, 0, 0, 0, 0, 0, 0, 0, 19, 2, 23, 21, 0, 37, 26, 101, 26, 16, 32, 32, 37, 32, 11, 17, 17, 16, 18, 36, 4, 4, 2, 2, 4, 2, 2, 3, 14, 12, 18, 16, 8, 27, 25, 18, 18, 24, 24, 0, 0, 0, 26, 16, 36, 5, 6, 56, 26, 21, 18, 0, 0, 18, 20, 20, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 14, 14, 51, 5}
#endif
#ifndef MAVLINK_MESSAGE_CRCS
#define MAVLINK_MESSAGE_CRCS {72, 39, 190, 92, 191, 217, 104, 119, 0, 219, 60, 186, 10, 0, 0, 0, 0, 0, 0, 0, 89, 159, 162, 121, 0, 149, 222, 110, 179, 136, 66, 126, 185, 147, 112, 252, 162, 215, 229, 128, 9, 106, 101, 213, 4, 229, 21, 214, 215, 14, 206, 50, 157, 126, 108, 213, 95, 5, 127, 0, 0, 0, 57, 126, 130, 119, 193, 191, 236, 158, 143, 0, 0, 104, 123, 131, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 155, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 178, 224, 60, 106, 7}
#endif
#ifndef MAVLINK_MESSAGE_INFO
#define MAVLINK_MESSAGE_INFO {MAVLINK_MESSAGE_INFO_HEARTBEAT, MAVLINK_MESSAGE_INFO_BOOT, MAVLINK_MESSAGE_INFO_SYSTEM_TIME, MAVLINK_MESSAGE_INFO_PING, MAVLINK_MESSAGE_INFO_SYSTEM_TIME_UTC, MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL, MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL_ACK, MAVLINK_MESSAGE_INFO_AUTH_KEY, {NULL}, MAVLINK_MESSAGE_INFO_ACTION_ACK, MAVLINK_MESSAGE_INFO_ACTION, MAVLINK_MESSAGE_INFO_SET_MODE, MAVLINK_MESSAGE_INFO_SET_NAV_MODE, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_PARAM_REQUEST_READ, MAVLINK_MESSAGE_INFO_PARAM_REQUEST_LIST, MAVLINK_MESSAGE_INFO_PARAM_VALUE, MAVLINK_MESSAGE_INFO_PARAM_SET, {NULL}, MAVLINK_MESSAGE_INFO_GPS_RAW_INT, MAVLINK_MESSAGE_INFO_SCALED_IMU, MAVLINK_MESSAGE_INFO_GPS_STATUS, MAVLINK_MESSAGE_INFO_RAW_IMU, MAVLINK_MESSAGE_INFO_RAW_PRESSURE, MAVLINK_MESSAGE_INFO_ATTITUDE, MAVLINK_MESSAGE_INFO_LOCAL_POSITION, MAVLINK_MESSAGE_INFO_GPS_RAW, MAVLINK_MESSAGE_INFO_GLOBAL_POSITION, MAVLINK_MESSAGE_INFO_SYS_STATUS, MAVLINK_MESSAGE_INFO_RC_CHANNELS_RAW, MAVLINK_MESSAGE_INFO_RC_CHANNELS_SCALED, MAVLINK_MESSAGE_INFO_SERVO_OUTPUT_RAW, MAVLINK_MESSAGE_INFO_SCALED_PRESSURE, MAVLINK_MESSAGE_INFO_WAYPOINT, MAVLINK_MESSAGE_INFO_WAYPOINT_REQUEST, MAVLINK_MESSAGE_INFO_WAYPOINT_SET_CURRENT, MAVLINK_MESSAGE_INFO_WAYPOINT_CURRENT, MAVLINK_MESSAGE_INFO_WAYPOINT_REQUEST_LIST, MAVLINK_MESSAGE_INFO_WAYPOINT_COUNT, MAVLINK_MESSAGE_INFO_WAYPOINT_CLEAR_ALL, MAVLINK_MESSAGE_INFO_WAYPOINT_REACHED, MAVLINK_MESSAGE_INFO_WAYPOINT_ACK, MAVLINK_MESSAGE_INFO_GPS_SET_GLOBAL_ORIGIN, MAVLINK_MESSAGE_INFO_GPS_LOCAL_ORIGIN_SET, MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT_SET, MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT, MAVLINK_MESSAGE_INFO_CONTROL_STATUS, MAVLINK_MESSAGE_INFO_SAFETY_SET_ALLOWED_AREA, MAVLINK_MESSAGE_INFO_SAFETY_ALLOWED_AREA, MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_THRUST, MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_SPEED_THRUST, MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_THRUST_SETPOINT, MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_NAV_CONTROLLER_OUTPUT, MAVLINK_MESSAGE_INFO_POSITION_TARGET, MAVLINK_MESSAGE_INFO_STATE_CORRECTION, MAVLINK_MESSAGE_INFO_SET_ALTITUDE, MAVLINK_MESSAGE_INFO_REQUEST_DATA_STREAM, MAVLINK_MESSAGE_INFO_HIL_STATE, MAVLINK_MESSAGE_INFO_HIL_CONTROLS, MAVLINK_MESSAGE_INFO_MANUAL_CONTROL, MAVLINK_MESSAGE_INFO_RC_CHANNELS_OVERRIDE, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_GLOBAL_POSITION_INT, MAVLINK_MESSAGE_INFO_VFR_HUD, MAVLINK_MESSAGE_INFO_COMMAND, MAVLINK_MESSAGE_INFO_COMMAND_ACK, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_OPTICAL_FLOW, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_OBJECT_DETECTION_EVENT, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_DEBUG_VECT, MAVLINK_MESSAGE_INFO_NAMED_VALUE_FLOAT, MAVLINK_MESSAGE_INFO_NAMED_VALUE_INT, MAVLINK_MESSAGE_INFO_STATUSTEXT, MAVLINK_MESSAGE_INFO_DEBUG}
#endif
#include "../protocol.h"
#define MAVLINK_ENABLED_COMMON
// MAVLINK VERSION
#ifndef MAVLINK_VERSION
#define MAVLINK_VERSION 2
#endif
#if (MAVLINK_VERSION == 0)
#undef MAVLINK_VERSION
#define MAVLINK_VERSION 2
#endif
// ENUM DEFINITIONS
/** @brief Data stream IDs. A data stream is not a fixed set of messages, but rather a
recommendation to the autopilot software. Individual autopilots may or may not obey
the recommended messages.
*/
#ifndef HAVE_ENUM_MAV_DATA_STREAM
#define HAVE_ENUM_MAV_DATA_STREAM
enum MAV_DATA_STREAM
{
MAV_DATA_STREAM_ALL=0, /* Enable all data streams | */
MAV_DATA_STREAM_RAW_SENSORS=1, /* Enable IMU_RAW, GPS_RAW, GPS_STATUS packets. | */
MAV_DATA_STREAM_EXTENDED_STATUS=2, /* Enable GPS_STATUS, CONTROL_STATUS, AUX_STATUS | */
MAV_DATA_STREAM_RC_CHANNELS=3, /* Enable RC_CHANNELS_SCALED, RC_CHANNELS_RAW, SERVO_OUTPUT_RAW | */
MAV_DATA_STREAM_RAW_CONTROLLER=4, /* Enable ATTITUDE_CONTROLLER_OUTPUT, POSITION_CONTROLLER_OUTPUT, NAV_CONTROLLER_OUTPUT. | */
MAV_DATA_STREAM_POSITION=6, /* Enable LOCAL_POSITION, GLOBAL_POSITION/GLOBAL_POSITION_INT messages. | */
MAV_DATA_STREAM_EXTRA1=10, /* Dependent on the autopilot | */
MAV_DATA_STREAM_EXTRA2=11, /* Dependent on the autopilot | */
MAV_DATA_STREAM_EXTRA3=12, /* Dependent on the autopilot | */
MAV_DATA_STREAM_ENUM_END=13, /* | */
};
#endif
/** @brief The ROI (region of interest) for the vehicle. This can be
be used by the vehicle for camera/vehicle attitude alignment (see
MAV_CMD_NAV_ROI).
*/
#ifndef HAVE_ENUM_MAV_ROI
#define HAVE_ENUM_MAV_ROI
enum MAV_ROI
{
MAV_ROI_NONE=0, /* No region of interest. | */
MAV_ROI_WPNEXT=1, /* Point toward next waypoint. | */
MAV_ROI_WPINDEX=2, /* Point toward given waypoint. | */
MAV_ROI_LOCATION=3, /* Point toward fixed location. | */
MAV_ROI_TARGET=4, /* Point toward of given id. | */
MAV_ROI_ENUM_END=5, /* | */
};
#endif
// MESSAGE DEFINITIONS
#include "./mavlink_msg_heartbeat.h"
#include "./mavlink_msg_boot.h"
#include "./mavlink_msg_system_time.h"
#include "./mavlink_msg_ping.h"
#include "./mavlink_msg_system_time_utc.h"
#include "./mavlink_msg_change_operator_control.h"
#include "./mavlink_msg_change_operator_control_ack.h"
#include "./mavlink_msg_auth_key.h"
#include "./mavlink_msg_action_ack.h"
#include "./mavlink_msg_action.h"
#include "./mavlink_msg_set_mode.h"
#include "./mavlink_msg_set_nav_mode.h"
#include "./mavlink_msg_param_request_read.h"
#include "./mavlink_msg_param_request_list.h"
#include "./mavlink_msg_param_value.h"
#include "./mavlink_msg_param_set.h"
#include "./mavlink_msg_gps_raw_int.h"
#include "./mavlink_msg_scaled_imu.h"
#include "./mavlink_msg_gps_status.h"
#include "./mavlink_msg_raw_imu.h"
#include "./mavlink_msg_raw_pressure.h"
#include "./mavlink_msg_scaled_pressure.h"
#include "./mavlink_msg_attitude.h"
#include "./mavlink_msg_local_position.h"
#include "./mavlink_msg_global_position.h"
#include "./mavlink_msg_gps_raw.h"
#include "./mavlink_msg_sys_status.h"
#include "./mavlink_msg_rc_channels_raw.h"
#include "./mavlink_msg_rc_channels_scaled.h"
#include "./mavlink_msg_servo_output_raw.h"
#include "./mavlink_msg_waypoint.h"
#include "./mavlink_msg_waypoint_request.h"
#include "./mavlink_msg_waypoint_set_current.h"
#include "./mavlink_msg_waypoint_current.h"
#include "./mavlink_msg_waypoint_request_list.h"
#include "./mavlink_msg_waypoint_count.h"
#include "./mavlink_msg_waypoint_clear_all.h"
#include "./mavlink_msg_waypoint_reached.h"
#include "./mavlink_msg_waypoint_ack.h"
#include "./mavlink_msg_gps_set_global_origin.h"
#include "./mavlink_msg_gps_local_origin_set.h"
#include "./mavlink_msg_local_position_setpoint_set.h"
#include "./mavlink_msg_local_position_setpoint.h"
#include "./mavlink_msg_control_status.h"
#include "./mavlink_msg_safety_set_allowed_area.h"
#include "./mavlink_msg_safety_allowed_area.h"
#include "./mavlink_msg_set_roll_pitch_yaw_thrust.h"
#include "./mavlink_msg_set_roll_pitch_yaw_speed_thrust.h"
#include "./mavlink_msg_roll_pitch_yaw_thrust_setpoint.h"
#include "./mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint.h"
#include "./mavlink_msg_nav_controller_output.h"
#include "./mavlink_msg_position_target.h"
#include "./mavlink_msg_state_correction.h"
#include "./mavlink_msg_set_altitude.h"
#include "./mavlink_msg_request_data_stream.h"
#include "./mavlink_msg_hil_state.h"
#include "./mavlink_msg_hil_controls.h"
#include "./mavlink_msg_manual_control.h"
#include "./mavlink_msg_rc_channels_override.h"
#include "./mavlink_msg_global_position_int.h"
#include "./mavlink_msg_vfr_hud.h"
#include "./mavlink_msg_command.h"
#include "./mavlink_msg_command_ack.h"
#include "./mavlink_msg_optical_flow.h"
#include "./mavlink_msg_object_detection_event.h"
#include "./mavlink_msg_debug_vect.h"
#include "./mavlink_msg_named_value_float.h"
#include "./mavlink_msg_named_value_int.h"
#include "./mavlink_msg_statustext.h"
#include "./mavlink_msg_debug.h"
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // COMMON_H
-27
View File
@@ -1,27 +0,0 @@
/** @file
* @brief MAVLink comm protocol built from common.xml
* @see http://pixhawk.ethz.ch/software/mavlink
*/
#ifndef MAVLINK_H
#define MAVLINK_H
#ifndef MAVLINK_STX
#define MAVLINK_STX 85
#endif
#ifndef MAVLINK_ENDIAN
#define MAVLINK_ENDIAN MAVLINK_BIG_ENDIAN
#endif
#ifndef MAVLINK_ALIGNED_FIELDS
#define MAVLINK_ALIGNED_FIELDS 0
#endif
#ifndef MAVLINK_CRC_EXTRA
#define MAVLINK_CRC_EXTRA 0
#endif
#include "version.h"
#include "common.h"
#endif // MAVLINK_H
@@ -1,188 +0,0 @@
// MESSAGE ACTION PACKING
#define MAVLINK_MSG_ID_ACTION 10
typedef struct __mavlink_action_t
{
uint8_t target; ///< The system executing the action
uint8_t target_component; ///< The component executing the action
uint8_t action; ///< The action id
} mavlink_action_t;
#define MAVLINK_MSG_ID_ACTION_LEN 3
#define MAVLINK_MSG_ID_10_LEN 3
#define MAVLINK_MESSAGE_INFO_ACTION { \
"ACTION", \
3, \
{ { "target", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_action_t, target) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_action_t, target_component) }, \
{ "action", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_action_t, action) }, \
} \
}
/**
* @brief Pack a action message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target The system executing the action
* @param target_component The component executing the action
* @param action The action id
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_action_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target, uint8_t target_component, uint8_t action)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, action);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_action_t packet;
packet.target = target;
packet.target_component = target_component;
packet.action = action;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_ACTION;
return mavlink_finalize_message(msg, system_id, component_id, 3);
}
/**
* @brief Pack a action message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target The system executing the action
* @param target_component The component executing the action
* @param action The action id
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_action_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target,uint8_t target_component,uint8_t action)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, action);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_action_t packet;
packet.target = target;
packet.target_component = target_component;
packet.action = action;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_ACTION;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 3);
}
/**
* @brief Encode a action struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param action C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_action_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_action_t* action)
{
return mavlink_msg_action_pack(system_id, component_id, msg, action->target, action->target_component, action->action);
}
/**
* @brief Send a action message
* @param chan MAVLink channel to send the message
*
* @param target The system executing the action
* @param target_component The component executing the action
* @param action The action id
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_action_send(mavlink_channel_t chan, uint8_t target, uint8_t target_component, uint8_t action)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, action);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTION, buf, 3);
#else
mavlink_action_t packet;
packet.target = target;
packet.target_component = target_component;
packet.action = action;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTION, (const char *)&packet, 3);
#endif
}
#endif
// MESSAGE ACTION UNPACKING
/**
* @brief Get field target from action message
*
* @return The system executing the action
*/
static inline uint8_t mavlink_msg_action_get_target(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from action message
*
* @return The component executing the action
*/
static inline uint8_t mavlink_msg_action_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field action from action message
*
* @return The action id
*/
static inline uint8_t mavlink_msg_action_get_action(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Decode a action message into a struct
*
* @param msg The message to decode
* @param action C-struct to decode the message contents into
*/
static inline void mavlink_msg_action_decode(const mavlink_message_t* msg, mavlink_action_t* action)
{
#if MAVLINK_NEED_BYTE_SWAP
action->target = mavlink_msg_action_get_target(msg);
action->target_component = mavlink_msg_action_get_target_component(msg);
action->action = mavlink_msg_action_get_action(msg);
#else
memcpy(action, _MAV_PAYLOAD(msg), 3);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE ACTION_ACK PACKING
#define MAVLINK_MSG_ID_ACTION_ACK 9
typedef struct __mavlink_action_ack_t
{
uint8_t action; ///< The action id
uint8_t result; ///< 0: Action DENIED, 1: Action executed
} mavlink_action_ack_t;
#define MAVLINK_MSG_ID_ACTION_ACK_LEN 2
#define MAVLINK_MSG_ID_9_LEN 2
#define MAVLINK_MESSAGE_INFO_ACTION_ACK { \
"ACTION_ACK", \
2, \
{ { "action", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_action_ack_t, action) }, \
{ "result", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_action_ack_t, result) }, \
} \
}
/**
* @brief Pack a action_ack message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param action The action id
* @param result 0: Action DENIED, 1: Action executed
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_action_ack_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t action, uint8_t result)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, action);
_mav_put_uint8_t(buf, 1, result);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_action_ack_t packet;
packet.action = action;
packet.result = result;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_ACTION_ACK;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a action_ack message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param action The action id
* @param result 0: Action DENIED, 1: Action executed
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_action_ack_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t action,uint8_t result)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, action);
_mav_put_uint8_t(buf, 1, result);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_action_ack_t packet;
packet.action = action;
packet.result = result;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_ACTION_ACK;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a action_ack struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param action_ack C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_action_ack_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_action_ack_t* action_ack)
{
return mavlink_msg_action_ack_pack(system_id, component_id, msg, action_ack->action, action_ack->result);
}
/**
* @brief Send a action_ack message
* @param chan MAVLink channel to send the message
*
* @param action The action id
* @param result 0: Action DENIED, 1: Action executed
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_action_ack_send(mavlink_channel_t chan, uint8_t action, uint8_t result)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, action);
_mav_put_uint8_t(buf, 1, result);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTION_ACK, buf, 2);
#else
mavlink_action_ack_t packet;
packet.action = action;
packet.result = result;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTION_ACK, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE ACTION_ACK UNPACKING
/**
* @brief Get field action from action_ack message
*
* @return The action id
*/
static inline uint8_t mavlink_msg_action_ack_get_action(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field result from action_ack message
*
* @return 0: Action DENIED, 1: Action executed
*/
static inline uint8_t mavlink_msg_action_ack_get_result(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Decode a action_ack message into a struct
*
* @param msg The message to decode
* @param action_ack C-struct to decode the message contents into
*/
static inline void mavlink_msg_action_ack_decode(const mavlink_message_t* msg, mavlink_action_ack_t* action_ack)
{
#if MAVLINK_NEED_BYTE_SWAP
action_ack->action = mavlink_msg_action_ack_get_action(msg);
action_ack->result = mavlink_msg_action_ack_get_result(msg);
#else
memcpy(action_ack, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,276 +0,0 @@
// MESSAGE ATTITUDE PACKING
#define MAVLINK_MSG_ID_ATTITUDE 30
typedef struct __mavlink_attitude_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
float roll; ///< Roll angle (rad)
float pitch; ///< Pitch angle (rad)
float yaw; ///< Yaw angle (rad)
float rollspeed; ///< Roll angular speed (rad/s)
float pitchspeed; ///< Pitch angular speed (rad/s)
float yawspeed; ///< Yaw angular speed (rad/s)
} mavlink_attitude_t;
#define MAVLINK_MSG_ID_ATTITUDE_LEN 32
#define MAVLINK_MSG_ID_30_LEN 32
#define MAVLINK_MESSAGE_INFO_ATTITUDE { \
"ATTITUDE", \
7, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_attitude_t, usec) }, \
{ "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_attitude_t, roll) }, \
{ "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_attitude_t, pitch) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_attitude_t, yaw) }, \
{ "rollspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_attitude_t, rollspeed) }, \
{ "pitchspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_attitude_t, pitchspeed) }, \
{ "yawspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_attitude_t, yawspeed) }, \
} \
}
/**
* @brief Pack a attitude message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll Roll angle (rad)
* @param pitch Pitch angle (rad)
* @param yaw Yaw angle (rad)
* @param rollspeed Roll angular speed (rad/s)
* @param pitchspeed Pitch angular speed (rad/s)
* @param yawspeed Yaw angular speed (rad/s)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_attitude_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, float roll, float pitch, float yaw, float rollspeed, float pitchspeed, float yawspeed)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, rollspeed);
_mav_put_float(buf, 24, pitchspeed);
_mav_put_float(buf, 28, yawspeed);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_attitude_t packet;
packet.usec = usec;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.rollspeed = rollspeed;
packet.pitchspeed = pitchspeed;
packet.yawspeed = yawspeed;
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_ATTITUDE;
return mavlink_finalize_message(msg, system_id, component_id, 32);
}
/**
* @brief Pack a attitude message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll Roll angle (rad)
* @param pitch Pitch angle (rad)
* @param yaw Yaw angle (rad)
* @param rollspeed Roll angular speed (rad/s)
* @param pitchspeed Pitch angular speed (rad/s)
* @param yawspeed Yaw angular speed (rad/s)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_attitude_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,float roll,float pitch,float yaw,float rollspeed,float pitchspeed,float yawspeed)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, rollspeed);
_mav_put_float(buf, 24, pitchspeed);
_mav_put_float(buf, 28, yawspeed);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_attitude_t packet;
packet.usec = usec;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.rollspeed = rollspeed;
packet.pitchspeed = pitchspeed;
packet.yawspeed = yawspeed;
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_ATTITUDE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 32);
}
/**
* @brief Encode a attitude struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param attitude C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_attitude_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_attitude_t* attitude)
{
return mavlink_msg_attitude_pack(system_id, component_id, msg, attitude->usec, attitude->roll, attitude->pitch, attitude->yaw, attitude->rollspeed, attitude->pitchspeed, attitude->yawspeed);
}
/**
* @brief Send a attitude message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll Roll angle (rad)
* @param pitch Pitch angle (rad)
* @param yaw Yaw angle (rad)
* @param rollspeed Roll angular speed (rad/s)
* @param pitchspeed Pitch angular speed (rad/s)
* @param yawspeed Yaw angular speed (rad/s)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_attitude_send(mavlink_channel_t chan, uint64_t usec, float roll, float pitch, float yaw, float rollspeed, float pitchspeed, float yawspeed)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, rollspeed);
_mav_put_float(buf, 24, pitchspeed);
_mav_put_float(buf, 28, yawspeed);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE, buf, 32);
#else
mavlink_attitude_t packet;
packet.usec = usec;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.rollspeed = rollspeed;
packet.pitchspeed = pitchspeed;
packet.yawspeed = yawspeed;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE, (const char *)&packet, 32);
#endif
}
#endif
// MESSAGE ATTITUDE UNPACKING
/**
* @brief Get field usec from attitude message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_attitude_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field roll from attitude message
*
* @return Roll angle (rad)
*/
static inline float mavlink_msg_attitude_get_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field pitch from attitude message
*
* @return Pitch angle (rad)
*/
static inline float mavlink_msg_attitude_get_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field yaw from attitude message
*
* @return Yaw angle (rad)
*/
static inline float mavlink_msg_attitude_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field rollspeed from attitude message
*
* @return Roll angular speed (rad/s)
*/
static inline float mavlink_msg_attitude_get_rollspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field pitchspeed from attitude message
*
* @return Pitch angular speed (rad/s)
*/
static inline float mavlink_msg_attitude_get_pitchspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 24);
}
/**
* @brief Get field yawspeed from attitude message
*
* @return Yaw angular speed (rad/s)
*/
static inline float mavlink_msg_attitude_get_yawspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Decode a attitude message into a struct
*
* @param msg The message to decode
* @param attitude C-struct to decode the message contents into
*/
static inline void mavlink_msg_attitude_decode(const mavlink_message_t* msg, mavlink_attitude_t* attitude)
{
#if MAVLINK_NEED_BYTE_SWAP
attitude->usec = mavlink_msg_attitude_get_usec(msg);
attitude->roll = mavlink_msg_attitude_get_roll(msg);
attitude->pitch = mavlink_msg_attitude_get_pitch(msg);
attitude->yaw = mavlink_msg_attitude_get_yaw(msg);
attitude->rollspeed = mavlink_msg_attitude_get_rollspeed(msg);
attitude->pitchspeed = mavlink_msg_attitude_get_pitchspeed(msg);
attitude->yawspeed = mavlink_msg_attitude_get_yawspeed(msg);
#else
memcpy(attitude, _MAV_PAYLOAD(msg), 32);
#endif
}
@@ -1,144 +0,0 @@
// MESSAGE AUTH_KEY PACKING
#define MAVLINK_MSG_ID_AUTH_KEY 7
typedef struct __mavlink_auth_key_t
{
char key[32]; ///< key
} mavlink_auth_key_t;
#define MAVLINK_MSG_ID_AUTH_KEY_LEN 32
#define MAVLINK_MSG_ID_7_LEN 32
#define MAVLINK_MSG_AUTH_KEY_FIELD_KEY_LEN 32
#define MAVLINK_MESSAGE_INFO_AUTH_KEY { \
"AUTH_KEY", \
1, \
{ { "key", NULL, MAVLINK_TYPE_CHAR, 32, 0, offsetof(mavlink_auth_key_t, key) }, \
} \
}
/**
* @brief Pack a auth_key message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param key key
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_auth_key_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
const char *key)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_char_array(buf, 0, key, 32);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_auth_key_t packet;
mav_array_memcpy(packet.key, key, sizeof(char)*32);
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_AUTH_KEY;
return mavlink_finalize_message(msg, system_id, component_id, 32);
}
/**
* @brief Pack a auth_key message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param key key
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_auth_key_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
const char *key)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_char_array(buf, 0, key, 32);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_auth_key_t packet;
mav_array_memcpy(packet.key, key, sizeof(char)*32);
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_AUTH_KEY;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 32);
}
/**
* @brief Encode a auth_key struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param auth_key C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_auth_key_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_auth_key_t* auth_key)
{
return mavlink_msg_auth_key_pack(system_id, component_id, msg, auth_key->key);
}
/**
* @brief Send a auth_key message
* @param chan MAVLink channel to send the message
*
* @param key key
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_auth_key_send(mavlink_channel_t chan, const char *key)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_char_array(buf, 0, key, 32);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTH_KEY, buf, 32);
#else
mavlink_auth_key_t packet;
mav_array_memcpy(packet.key, key, sizeof(char)*32);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTH_KEY, (const char *)&packet, 32);
#endif
}
#endif
// MESSAGE AUTH_KEY UNPACKING
/**
* @brief Get field key from auth_key message
*
* @return key
*/
static inline uint16_t mavlink_msg_auth_key_get_key(const mavlink_message_t* msg, char *key)
{
return _MAV_RETURN_char_array(msg, key, 32, 0);
}
/**
* @brief Decode a auth_key message into a struct
*
* @param msg The message to decode
* @param auth_key C-struct to decode the message contents into
*/
static inline void mavlink_msg_auth_key_decode(const mavlink_message_t* msg, mavlink_auth_key_t* auth_key)
{
#if MAVLINK_NEED_BYTE_SWAP
mavlink_msg_auth_key_get_key(msg, auth_key->key);
#else
memcpy(auth_key, _MAV_PAYLOAD(msg), 32);
#endif
}
@@ -1,144 +0,0 @@
// MESSAGE BOOT PACKING
#define MAVLINK_MSG_ID_BOOT 1
typedef struct __mavlink_boot_t
{
uint32_t version; ///< The onboard software version
} mavlink_boot_t;
#define MAVLINK_MSG_ID_BOOT_LEN 4
#define MAVLINK_MSG_ID_1_LEN 4
#define MAVLINK_MESSAGE_INFO_BOOT { \
"BOOT", \
1, \
{ { "version", NULL, MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_boot_t, version) }, \
} \
}
/**
* @brief Pack a boot message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param version The onboard software version
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_boot_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint32_t version)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint32_t(buf, 0, version);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_boot_t packet;
packet.version = version;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_BOOT;
return mavlink_finalize_message(msg, system_id, component_id, 4);
}
/**
* @brief Pack a boot message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param version The onboard software version
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_boot_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint32_t version)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint32_t(buf, 0, version);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_boot_t packet;
packet.version = version;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_BOOT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 4);
}
/**
* @brief Encode a boot struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param boot C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_boot_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_boot_t* boot)
{
return mavlink_msg_boot_pack(system_id, component_id, msg, boot->version);
}
/**
* @brief Send a boot message
* @param chan MAVLink channel to send the message
*
* @param version The onboard software version
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_boot_send(mavlink_channel_t chan, uint32_t version)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint32_t(buf, 0, version);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_BOOT, buf, 4);
#else
mavlink_boot_t packet;
packet.version = version;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_BOOT, (const char *)&packet, 4);
#endif
}
#endif
// MESSAGE BOOT UNPACKING
/**
* @brief Get field version from boot message
*
* @return The onboard software version
*/
static inline uint32_t mavlink_msg_boot_get_version(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 0);
}
/**
* @brief Decode a boot message into a struct
*
* @param msg The message to decode
* @param boot C-struct to decode the message contents into
*/
static inline void mavlink_msg_boot_decode(const mavlink_message_t* msg, mavlink_boot_t* boot)
{
#if MAVLINK_NEED_BYTE_SWAP
boot->version = mavlink_msg_boot_get_version(msg);
#else
memcpy(boot, _MAV_PAYLOAD(msg), 4);
#endif
}
@@ -1,204 +0,0 @@
// MESSAGE CHANGE_OPERATOR_CONTROL PACKING
#define MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL 5
typedef struct __mavlink_change_operator_control_t
{
uint8_t target_system; ///< System the GCS requests control for
uint8_t control_request; ///< 0: request control of this MAV, 1: Release control of this MAV
uint8_t version; ///< 0: key as plaintext, 1-255: future, different hashing/encryption variants. The GCS should in general use the safest mode possible initially and then gradually move down the encryption level if it gets a NACK message indicating an encryption mismatch.
char passkey[25]; ///< Password / Key, depending on version plaintext or encrypted. 25 or less characters, NULL terminated. The characters may involve A-Z, a-z, 0-9, and "!?,.-"
} mavlink_change_operator_control_t;
#define MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_LEN 28
#define MAVLINK_MSG_ID_5_LEN 28
#define MAVLINK_MSG_CHANGE_OPERATOR_CONTROL_FIELD_PASSKEY_LEN 25
#define MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL { \
"CHANGE_OPERATOR_CONTROL", \
4, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_change_operator_control_t, target_system) }, \
{ "control_request", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_change_operator_control_t, control_request) }, \
{ "version", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_change_operator_control_t, version) }, \
{ "passkey", NULL, MAVLINK_TYPE_CHAR, 25, 3, offsetof(mavlink_change_operator_control_t, passkey) }, \
} \
}
/**
* @brief Pack a change_operator_control message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System the GCS requests control for
* @param control_request 0: request control of this MAV, 1: Release control of this MAV
* @param version 0: key as plaintext, 1-255: future, different hashing/encryption variants. The GCS should in general use the safest mode possible initially and then gradually move down the encryption level if it gets a NACK message indicating an encryption mismatch.
* @param passkey Password / Key, depending on version plaintext or encrypted. 25 or less characters, NULL terminated. The characters may involve A-Z, a-z, 0-9, and "!?,.-"
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_change_operator_control_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t control_request, uint8_t version, const char *passkey)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[28];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, control_request);
_mav_put_uint8_t(buf, 2, version);
_mav_put_char_array(buf, 3, passkey, 25);
memcpy(_MAV_PAYLOAD(msg), buf, 28);
#else
mavlink_change_operator_control_t packet;
packet.target_system = target_system;
packet.control_request = control_request;
packet.version = version;
mav_array_memcpy(packet.passkey, passkey, sizeof(char)*25);
memcpy(_MAV_PAYLOAD(msg), &packet, 28);
#endif
msg->msgid = MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL;
return mavlink_finalize_message(msg, system_id, component_id, 28);
}
/**
* @brief Pack a change_operator_control message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System the GCS requests control for
* @param control_request 0: request control of this MAV, 1: Release control of this MAV
* @param version 0: key as plaintext, 1-255: future, different hashing/encryption variants. The GCS should in general use the safest mode possible initially and then gradually move down the encryption level if it gets a NACK message indicating an encryption mismatch.
* @param passkey Password / Key, depending on version plaintext or encrypted. 25 or less characters, NULL terminated. The characters may involve A-Z, a-z, 0-9, and "!?,.-"
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_change_operator_control_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t control_request,uint8_t version,const char *passkey)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[28];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, control_request);
_mav_put_uint8_t(buf, 2, version);
_mav_put_char_array(buf, 3, passkey, 25);
memcpy(_MAV_PAYLOAD(msg), buf, 28);
#else
mavlink_change_operator_control_t packet;
packet.target_system = target_system;
packet.control_request = control_request;
packet.version = version;
mav_array_memcpy(packet.passkey, passkey, sizeof(char)*25);
memcpy(_MAV_PAYLOAD(msg), &packet, 28);
#endif
msg->msgid = MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 28);
}
/**
* @brief Encode a change_operator_control struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param change_operator_control C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_change_operator_control_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_change_operator_control_t* change_operator_control)
{
return mavlink_msg_change_operator_control_pack(system_id, component_id, msg, change_operator_control->target_system, change_operator_control->control_request, change_operator_control->version, change_operator_control->passkey);
}
/**
* @brief Send a change_operator_control message
* @param chan MAVLink channel to send the message
*
* @param target_system System the GCS requests control for
* @param control_request 0: request control of this MAV, 1: Release control of this MAV
* @param version 0: key as plaintext, 1-255: future, different hashing/encryption variants. The GCS should in general use the safest mode possible initially and then gradually move down the encryption level if it gets a NACK message indicating an encryption mismatch.
* @param passkey Password / Key, depending on version plaintext or encrypted. 25 or less characters, NULL terminated. The characters may involve A-Z, a-z, 0-9, and "!?,.-"
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_change_operator_control_send(mavlink_channel_t chan, uint8_t target_system, uint8_t control_request, uint8_t version, const char *passkey)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[28];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, control_request);
_mav_put_uint8_t(buf, 2, version);
_mav_put_char_array(buf, 3, passkey, 25);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL, buf, 28);
#else
mavlink_change_operator_control_t packet;
packet.target_system = target_system;
packet.control_request = control_request;
packet.version = version;
mav_array_memcpy(packet.passkey, passkey, sizeof(char)*25);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL, (const char *)&packet, 28);
#endif
}
#endif
// MESSAGE CHANGE_OPERATOR_CONTROL UNPACKING
/**
* @brief Get field target_system from change_operator_control message
*
* @return System the GCS requests control for
*/
static inline uint8_t mavlink_msg_change_operator_control_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field control_request from change_operator_control message
*
* @return 0: request control of this MAV, 1: Release control of this MAV
*/
static inline uint8_t mavlink_msg_change_operator_control_get_control_request(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field version from change_operator_control message
*
* @return 0: key as plaintext, 1-255: future, different hashing/encryption variants. The GCS should in general use the safest mode possible initially and then gradually move down the encryption level if it gets a NACK message indicating an encryption mismatch.
*/
static inline uint8_t mavlink_msg_change_operator_control_get_version(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field passkey from change_operator_control message
*
* @return Password / Key, depending on version plaintext or encrypted. 25 or less characters, NULL terminated. The characters may involve A-Z, a-z, 0-9, and "!?,.-"
*/
static inline uint16_t mavlink_msg_change_operator_control_get_passkey(const mavlink_message_t* msg, char *passkey)
{
return _MAV_RETURN_char_array(msg, passkey, 25, 3);
}
/**
* @brief Decode a change_operator_control message into a struct
*
* @param msg The message to decode
* @param change_operator_control C-struct to decode the message contents into
*/
static inline void mavlink_msg_change_operator_control_decode(const mavlink_message_t* msg, mavlink_change_operator_control_t* change_operator_control)
{
#if MAVLINK_NEED_BYTE_SWAP
change_operator_control->target_system = mavlink_msg_change_operator_control_get_target_system(msg);
change_operator_control->control_request = mavlink_msg_change_operator_control_get_control_request(msg);
change_operator_control->version = mavlink_msg_change_operator_control_get_version(msg);
mavlink_msg_change_operator_control_get_passkey(msg, change_operator_control->passkey);
#else
memcpy(change_operator_control, _MAV_PAYLOAD(msg), 28);
#endif
}
@@ -1,298 +0,0 @@
// MESSAGE COMMAND PACKING
#define MAVLINK_MSG_ID_COMMAND 75
typedef struct __mavlink_command_t
{
uint8_t target_system; ///< System which should execute the command
uint8_t target_component; ///< Component which should execute the command, 0 for all components
uint8_t command; ///< Command ID, as defined by MAV_CMD enum.
uint8_t confirmation; ///< 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command)
float param1; ///< Parameter 1, as defined by MAV_CMD enum.
float param2; ///< Parameter 2, as defined by MAV_CMD enum.
float param3; ///< Parameter 3, as defined by MAV_CMD enum.
float param4; ///< Parameter 4, as defined by MAV_CMD enum.
} mavlink_command_t;
#define MAVLINK_MSG_ID_COMMAND_LEN 20
#define MAVLINK_MSG_ID_75_LEN 20
#define MAVLINK_MESSAGE_INFO_COMMAND { \
"COMMAND", \
8, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_command_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_command_t, target_component) }, \
{ "command", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_command_t, command) }, \
{ "confirmation", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_command_t, confirmation) }, \
{ "param1", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_command_t, param1) }, \
{ "param2", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_command_t, param2) }, \
{ "param3", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_command_t, param3) }, \
{ "param4", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_command_t, param4) }, \
} \
}
/**
* @brief Pack a command message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System which should execute the command
* @param target_component Component which should execute the command, 0 for all components
* @param command Command ID, as defined by MAV_CMD enum.
* @param confirmation 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command)
* @param param1 Parameter 1, as defined by MAV_CMD enum.
* @param param2 Parameter 2, as defined by MAV_CMD enum.
* @param param3 Parameter 3, as defined by MAV_CMD enum.
* @param param4 Parameter 4, as defined by MAV_CMD enum.
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_command_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t command, uint8_t confirmation, float param1, float param2, float param3, float param4)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[20];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, command);
_mav_put_uint8_t(buf, 3, confirmation);
_mav_put_float(buf, 4, param1);
_mav_put_float(buf, 8, param2);
_mav_put_float(buf, 12, param3);
_mav_put_float(buf, 16, param4);
memcpy(_MAV_PAYLOAD(msg), buf, 20);
#else
mavlink_command_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.command = command;
packet.confirmation = confirmation;
packet.param1 = param1;
packet.param2 = param2;
packet.param3 = param3;
packet.param4 = param4;
memcpy(_MAV_PAYLOAD(msg), &packet, 20);
#endif
msg->msgid = MAVLINK_MSG_ID_COMMAND;
return mavlink_finalize_message(msg, system_id, component_id, 20);
}
/**
* @brief Pack a command message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System which should execute the command
* @param target_component Component which should execute the command, 0 for all components
* @param command Command ID, as defined by MAV_CMD enum.
* @param confirmation 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command)
* @param param1 Parameter 1, as defined by MAV_CMD enum.
* @param param2 Parameter 2, as defined by MAV_CMD enum.
* @param param3 Parameter 3, as defined by MAV_CMD enum.
* @param param4 Parameter 4, as defined by MAV_CMD enum.
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_command_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t command,uint8_t confirmation,float param1,float param2,float param3,float param4)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[20];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, command);
_mav_put_uint8_t(buf, 3, confirmation);
_mav_put_float(buf, 4, param1);
_mav_put_float(buf, 8, param2);
_mav_put_float(buf, 12, param3);
_mav_put_float(buf, 16, param4);
memcpy(_MAV_PAYLOAD(msg), buf, 20);
#else
mavlink_command_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.command = command;
packet.confirmation = confirmation;
packet.param1 = param1;
packet.param2 = param2;
packet.param3 = param3;
packet.param4 = param4;
memcpy(_MAV_PAYLOAD(msg), &packet, 20);
#endif
msg->msgid = MAVLINK_MSG_ID_COMMAND;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 20);
}
/**
* @brief Encode a command struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param command C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_command_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_command_t* command)
{
return mavlink_msg_command_pack(system_id, component_id, msg, command->target_system, command->target_component, command->command, command->confirmation, command->param1, command->param2, command->param3, command->param4);
}
/**
* @brief Send a command message
* @param chan MAVLink channel to send the message
*
* @param target_system System which should execute the command
* @param target_component Component which should execute the command, 0 for all components
* @param command Command ID, as defined by MAV_CMD enum.
* @param confirmation 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command)
* @param param1 Parameter 1, as defined by MAV_CMD enum.
* @param param2 Parameter 2, as defined by MAV_CMD enum.
* @param param3 Parameter 3, as defined by MAV_CMD enum.
* @param param4 Parameter 4, as defined by MAV_CMD enum.
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_command_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t command, uint8_t confirmation, float param1, float param2, float param3, float param4)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[20];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, command);
_mav_put_uint8_t(buf, 3, confirmation);
_mav_put_float(buf, 4, param1);
_mav_put_float(buf, 8, param2);
_mav_put_float(buf, 12, param3);
_mav_put_float(buf, 16, param4);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND, buf, 20);
#else
mavlink_command_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.command = command;
packet.confirmation = confirmation;
packet.param1 = param1;
packet.param2 = param2;
packet.param3 = param3;
packet.param4 = param4;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND, (const char *)&packet, 20);
#endif
}
#endif
// MESSAGE COMMAND UNPACKING
/**
* @brief Get field target_system from command message
*
* @return System which should execute the command
*/
static inline uint8_t mavlink_msg_command_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from command message
*
* @return Component which should execute the command, 0 for all components
*/
static inline uint8_t mavlink_msg_command_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field command from command message
*
* @return Command ID, as defined by MAV_CMD enum.
*/
static inline uint8_t mavlink_msg_command_get_command(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field confirmation from command message
*
* @return 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command)
*/
static inline uint8_t mavlink_msg_command_get_confirmation(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 3);
}
/**
* @brief Get field param1 from command message
*
* @return Parameter 1, as defined by MAV_CMD enum.
*/
static inline float mavlink_msg_command_get_param1(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field param2 from command message
*
* @return Parameter 2, as defined by MAV_CMD enum.
*/
static inline float mavlink_msg_command_get_param2(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field param3 from command message
*
* @return Parameter 3, as defined by MAV_CMD enum.
*/
static inline float mavlink_msg_command_get_param3(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field param4 from command message
*
* @return Parameter 4, as defined by MAV_CMD enum.
*/
static inline float mavlink_msg_command_get_param4(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Decode a command message into a struct
*
* @param msg The message to decode
* @param command C-struct to decode the message contents into
*/
static inline void mavlink_msg_command_decode(const mavlink_message_t* msg, mavlink_command_t* command)
{
#if MAVLINK_NEED_BYTE_SWAP
command->target_system = mavlink_msg_command_get_target_system(msg);
command->target_component = mavlink_msg_command_get_target_component(msg);
command->command = mavlink_msg_command_get_command(msg);
command->confirmation = mavlink_msg_command_get_confirmation(msg);
command->param1 = mavlink_msg_command_get_param1(msg);
command->param2 = mavlink_msg_command_get_param2(msg);
command->param3 = mavlink_msg_command_get_param3(msg);
command->param4 = mavlink_msg_command_get_param4(msg);
#else
memcpy(command, _MAV_PAYLOAD(msg), 20);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE COMMAND_ACK PACKING
#define MAVLINK_MSG_ID_COMMAND_ACK 76
typedef struct __mavlink_command_ack_t
{
float command; ///< Current airspeed in m/s
float result; ///< 1: Action ACCEPTED and EXECUTED, 1: Action TEMPORARY REJECTED/DENIED, 2: Action PERMANENTLY DENIED, 3: Action UNKNOWN/UNSUPPORTED, 4: Requesting CONFIRMATION
} mavlink_command_ack_t;
#define MAVLINK_MSG_ID_COMMAND_ACK_LEN 8
#define MAVLINK_MSG_ID_76_LEN 8
#define MAVLINK_MESSAGE_INFO_COMMAND_ACK { \
"COMMAND_ACK", \
2, \
{ { "command", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_command_ack_t, command) }, \
{ "result", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_command_ack_t, result) }, \
} \
}
/**
* @brief Pack a command_ack message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param command Current airspeed in m/s
* @param result 1: Action ACCEPTED and EXECUTED, 1: Action TEMPORARY REJECTED/DENIED, 2: Action PERMANENTLY DENIED, 3: Action UNKNOWN/UNSUPPORTED, 4: Requesting CONFIRMATION
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_command_ack_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
float command, float result)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_float(buf, 0, command);
_mav_put_float(buf, 4, result);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_command_ack_t packet;
packet.command = command;
packet.result = result;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_COMMAND_ACK;
return mavlink_finalize_message(msg, system_id, component_id, 8);
}
/**
* @brief Pack a command_ack message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param command Current airspeed in m/s
* @param result 1: Action ACCEPTED and EXECUTED, 1: Action TEMPORARY REJECTED/DENIED, 2: Action PERMANENTLY DENIED, 3: Action UNKNOWN/UNSUPPORTED, 4: Requesting CONFIRMATION
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_command_ack_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
float command,float result)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_float(buf, 0, command);
_mav_put_float(buf, 4, result);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_command_ack_t packet;
packet.command = command;
packet.result = result;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_COMMAND_ACK;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 8);
}
/**
* @brief Encode a command_ack struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param command_ack C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_command_ack_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_command_ack_t* command_ack)
{
return mavlink_msg_command_ack_pack(system_id, component_id, msg, command_ack->command, command_ack->result);
}
/**
* @brief Send a command_ack message
* @param chan MAVLink channel to send the message
*
* @param command Current airspeed in m/s
* @param result 1: Action ACCEPTED and EXECUTED, 1: Action TEMPORARY REJECTED/DENIED, 2: Action PERMANENTLY DENIED, 3: Action UNKNOWN/UNSUPPORTED, 4: Requesting CONFIRMATION
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_command_ack_send(mavlink_channel_t chan, float command, float result)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_float(buf, 0, command);
_mav_put_float(buf, 4, result);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, buf, 8);
#else
mavlink_command_ack_t packet;
packet.command = command;
packet.result = result;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, (const char *)&packet, 8);
#endif
}
#endif
// MESSAGE COMMAND_ACK UNPACKING
/**
* @brief Get field command from command_ack message
*
* @return Current airspeed in m/s
*/
static inline float mavlink_msg_command_ack_get_command(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field result from command_ack message
*
* @return 1: Action ACCEPTED and EXECUTED, 1: Action TEMPORARY REJECTED/DENIED, 2: Action PERMANENTLY DENIED, 3: Action UNKNOWN/UNSUPPORTED, 4: Requesting CONFIRMATION
*/
static inline float mavlink_msg_command_ack_get_result(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Decode a command_ack message into a struct
*
* @param msg The message to decode
* @param command_ack C-struct to decode the message contents into
*/
static inline void mavlink_msg_command_ack_decode(const mavlink_message_t* msg, mavlink_command_ack_t* command_ack)
{
#if MAVLINK_NEED_BYTE_SWAP
command_ack->command = mavlink_msg_command_ack_get_command(msg);
command_ack->result = mavlink_msg_command_ack_get_result(msg);
#else
memcpy(command_ack, _MAV_PAYLOAD(msg), 8);
#endif
}
@@ -1,298 +0,0 @@
// MESSAGE CONTROL_STATUS PACKING
#define MAVLINK_MSG_ID_CONTROL_STATUS 52
typedef struct __mavlink_control_status_t
{
uint8_t position_fix; ///< Position fix: 0: lost, 2: 2D position fix, 3: 3D position fix
uint8_t vision_fix; ///< Vision position fix: 0: lost, 1: 2D local position hold, 2: 2D global position fix, 3: 3D global position fix
uint8_t gps_fix; ///< GPS position fix: 0: no reception, 1: Minimum 1 satellite, but no position fix, 2: 2D position fix, 3: 3D position fix
uint8_t ahrs_health; ///< Attitude estimation health: 0: poor, 255: excellent
uint8_t control_att; ///< 0: Attitude control disabled, 1: enabled
uint8_t control_pos_xy; ///< 0: X, Y position control disabled, 1: enabled
uint8_t control_pos_z; ///< 0: Z position control disabled, 1: enabled
uint8_t control_pos_yaw; ///< 0: Yaw angle control disabled, 1: enabled
} mavlink_control_status_t;
#define MAVLINK_MSG_ID_CONTROL_STATUS_LEN 8
#define MAVLINK_MSG_ID_52_LEN 8
#define MAVLINK_MESSAGE_INFO_CONTROL_STATUS { \
"CONTROL_STATUS", \
8, \
{ { "position_fix", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_control_status_t, position_fix) }, \
{ "vision_fix", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_control_status_t, vision_fix) }, \
{ "gps_fix", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_control_status_t, gps_fix) }, \
{ "ahrs_health", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_control_status_t, ahrs_health) }, \
{ "control_att", NULL, MAVLINK_TYPE_UINT8_T, 0, 4, offsetof(mavlink_control_status_t, control_att) }, \
{ "control_pos_xy", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_control_status_t, control_pos_xy) }, \
{ "control_pos_z", NULL, MAVLINK_TYPE_UINT8_T, 0, 6, offsetof(mavlink_control_status_t, control_pos_z) }, \
{ "control_pos_yaw", NULL, MAVLINK_TYPE_UINT8_T, 0, 7, offsetof(mavlink_control_status_t, control_pos_yaw) }, \
} \
}
/**
* @brief Pack a control_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param position_fix Position fix: 0: lost, 2: 2D position fix, 3: 3D position fix
* @param vision_fix Vision position fix: 0: lost, 1: 2D local position hold, 2: 2D global position fix, 3: 3D global position fix
* @param gps_fix GPS position fix: 0: no reception, 1: Minimum 1 satellite, but no position fix, 2: 2D position fix, 3: 3D position fix
* @param ahrs_health Attitude estimation health: 0: poor, 255: excellent
* @param control_att 0: Attitude control disabled, 1: enabled
* @param control_pos_xy 0: X, Y position control disabled, 1: enabled
* @param control_pos_z 0: Z position control disabled, 1: enabled
* @param control_pos_yaw 0: Yaw angle control disabled, 1: enabled
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_control_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t position_fix, uint8_t vision_fix, uint8_t gps_fix, uint8_t ahrs_health, uint8_t control_att, uint8_t control_pos_xy, uint8_t control_pos_z, uint8_t control_pos_yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, position_fix);
_mav_put_uint8_t(buf, 1, vision_fix);
_mav_put_uint8_t(buf, 2, gps_fix);
_mav_put_uint8_t(buf, 3, ahrs_health);
_mav_put_uint8_t(buf, 4, control_att);
_mav_put_uint8_t(buf, 5, control_pos_xy);
_mav_put_uint8_t(buf, 6, control_pos_z);
_mav_put_uint8_t(buf, 7, control_pos_yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_control_status_t packet;
packet.position_fix = position_fix;
packet.vision_fix = vision_fix;
packet.gps_fix = gps_fix;
packet.ahrs_health = ahrs_health;
packet.control_att = control_att;
packet.control_pos_xy = control_pos_xy;
packet.control_pos_z = control_pos_z;
packet.control_pos_yaw = control_pos_yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_CONTROL_STATUS;
return mavlink_finalize_message(msg, system_id, component_id, 8);
}
/**
* @brief Pack a control_status message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param position_fix Position fix: 0: lost, 2: 2D position fix, 3: 3D position fix
* @param vision_fix Vision position fix: 0: lost, 1: 2D local position hold, 2: 2D global position fix, 3: 3D global position fix
* @param gps_fix GPS position fix: 0: no reception, 1: Minimum 1 satellite, but no position fix, 2: 2D position fix, 3: 3D position fix
* @param ahrs_health Attitude estimation health: 0: poor, 255: excellent
* @param control_att 0: Attitude control disabled, 1: enabled
* @param control_pos_xy 0: X, Y position control disabled, 1: enabled
* @param control_pos_z 0: Z position control disabled, 1: enabled
* @param control_pos_yaw 0: Yaw angle control disabled, 1: enabled
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_control_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t position_fix,uint8_t vision_fix,uint8_t gps_fix,uint8_t ahrs_health,uint8_t control_att,uint8_t control_pos_xy,uint8_t control_pos_z,uint8_t control_pos_yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, position_fix);
_mav_put_uint8_t(buf, 1, vision_fix);
_mav_put_uint8_t(buf, 2, gps_fix);
_mav_put_uint8_t(buf, 3, ahrs_health);
_mav_put_uint8_t(buf, 4, control_att);
_mav_put_uint8_t(buf, 5, control_pos_xy);
_mav_put_uint8_t(buf, 6, control_pos_z);
_mav_put_uint8_t(buf, 7, control_pos_yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_control_status_t packet;
packet.position_fix = position_fix;
packet.vision_fix = vision_fix;
packet.gps_fix = gps_fix;
packet.ahrs_health = ahrs_health;
packet.control_att = control_att;
packet.control_pos_xy = control_pos_xy;
packet.control_pos_z = control_pos_z;
packet.control_pos_yaw = control_pos_yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_CONTROL_STATUS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 8);
}
/**
* @brief Encode a control_status struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param control_status C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_control_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_control_status_t* control_status)
{
return mavlink_msg_control_status_pack(system_id, component_id, msg, control_status->position_fix, control_status->vision_fix, control_status->gps_fix, control_status->ahrs_health, control_status->control_att, control_status->control_pos_xy, control_status->control_pos_z, control_status->control_pos_yaw);
}
/**
* @brief Send a control_status message
* @param chan MAVLink channel to send the message
*
* @param position_fix Position fix: 0: lost, 2: 2D position fix, 3: 3D position fix
* @param vision_fix Vision position fix: 0: lost, 1: 2D local position hold, 2: 2D global position fix, 3: 3D global position fix
* @param gps_fix GPS position fix: 0: no reception, 1: Minimum 1 satellite, but no position fix, 2: 2D position fix, 3: 3D position fix
* @param ahrs_health Attitude estimation health: 0: poor, 255: excellent
* @param control_att 0: Attitude control disabled, 1: enabled
* @param control_pos_xy 0: X, Y position control disabled, 1: enabled
* @param control_pos_z 0: Z position control disabled, 1: enabled
* @param control_pos_yaw 0: Yaw angle control disabled, 1: enabled
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_control_status_send(mavlink_channel_t chan, uint8_t position_fix, uint8_t vision_fix, uint8_t gps_fix, uint8_t ahrs_health, uint8_t control_att, uint8_t control_pos_xy, uint8_t control_pos_z, uint8_t control_pos_yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint8_t(buf, 0, position_fix);
_mav_put_uint8_t(buf, 1, vision_fix);
_mav_put_uint8_t(buf, 2, gps_fix);
_mav_put_uint8_t(buf, 3, ahrs_health);
_mav_put_uint8_t(buf, 4, control_att);
_mav_put_uint8_t(buf, 5, control_pos_xy);
_mav_put_uint8_t(buf, 6, control_pos_z);
_mav_put_uint8_t(buf, 7, control_pos_yaw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CONTROL_STATUS, buf, 8);
#else
mavlink_control_status_t packet;
packet.position_fix = position_fix;
packet.vision_fix = vision_fix;
packet.gps_fix = gps_fix;
packet.ahrs_health = ahrs_health;
packet.control_att = control_att;
packet.control_pos_xy = control_pos_xy;
packet.control_pos_z = control_pos_z;
packet.control_pos_yaw = control_pos_yaw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CONTROL_STATUS, (const char *)&packet, 8);
#endif
}
#endif
// MESSAGE CONTROL_STATUS UNPACKING
/**
* @brief Get field position_fix from control_status message
*
* @return Position fix: 0: lost, 2: 2D position fix, 3: 3D position fix
*/
static inline uint8_t mavlink_msg_control_status_get_position_fix(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field vision_fix from control_status message
*
* @return Vision position fix: 0: lost, 1: 2D local position hold, 2: 2D global position fix, 3: 3D global position fix
*/
static inline uint8_t mavlink_msg_control_status_get_vision_fix(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field gps_fix from control_status message
*
* @return GPS position fix: 0: no reception, 1: Minimum 1 satellite, but no position fix, 2: 2D position fix, 3: 3D position fix
*/
static inline uint8_t mavlink_msg_control_status_get_gps_fix(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field ahrs_health from control_status message
*
* @return Attitude estimation health: 0: poor, 255: excellent
*/
static inline uint8_t mavlink_msg_control_status_get_ahrs_health(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 3);
}
/**
* @brief Get field control_att from control_status message
*
* @return 0: Attitude control disabled, 1: enabled
*/
static inline uint8_t mavlink_msg_control_status_get_control_att(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 4);
}
/**
* @brief Get field control_pos_xy from control_status message
*
* @return 0: X, Y position control disabled, 1: enabled
*/
static inline uint8_t mavlink_msg_control_status_get_control_pos_xy(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Get field control_pos_z from control_status message
*
* @return 0: Z position control disabled, 1: enabled
*/
static inline uint8_t mavlink_msg_control_status_get_control_pos_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 6);
}
/**
* @brief Get field control_pos_yaw from control_status message
*
* @return 0: Yaw angle control disabled, 1: enabled
*/
static inline uint8_t mavlink_msg_control_status_get_control_pos_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 7);
}
/**
* @brief Decode a control_status message into a struct
*
* @param msg The message to decode
* @param control_status C-struct to decode the message contents into
*/
static inline void mavlink_msg_control_status_decode(const mavlink_message_t* msg, mavlink_control_status_t* control_status)
{
#if MAVLINK_NEED_BYTE_SWAP
control_status->position_fix = mavlink_msg_control_status_get_position_fix(msg);
control_status->vision_fix = mavlink_msg_control_status_get_vision_fix(msg);
control_status->gps_fix = mavlink_msg_control_status_get_gps_fix(msg);
control_status->ahrs_health = mavlink_msg_control_status_get_ahrs_health(msg);
control_status->control_att = mavlink_msg_control_status_get_control_att(msg);
control_status->control_pos_xy = mavlink_msg_control_status_get_control_pos_xy(msg);
control_status->control_pos_z = mavlink_msg_control_status_get_control_pos_z(msg);
control_status->control_pos_yaw = mavlink_msg_control_status_get_control_pos_yaw(msg);
#else
memcpy(control_status, _MAV_PAYLOAD(msg), 8);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE DEBUG PACKING
#define MAVLINK_MSG_ID_DEBUG 255
typedef struct __mavlink_debug_t
{
uint8_t ind; ///< index of debug variable
float value; ///< DEBUG value
} mavlink_debug_t;
#define MAVLINK_MSG_ID_DEBUG_LEN 5
#define MAVLINK_MSG_ID_255_LEN 5
#define MAVLINK_MESSAGE_INFO_DEBUG { \
"DEBUG", \
2, \
{ { "ind", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_debug_t, ind) }, \
{ "value", NULL, MAVLINK_TYPE_FLOAT, 0, 1, offsetof(mavlink_debug_t, value) }, \
} \
}
/**
* @brief Pack a debug message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param ind index of debug variable
* @param value DEBUG value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_debug_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t ind, float value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[5];
_mav_put_uint8_t(buf, 0, ind);
_mav_put_float(buf, 1, value);
memcpy(_MAV_PAYLOAD(msg), buf, 5);
#else
mavlink_debug_t packet;
packet.ind = ind;
packet.value = value;
memcpy(_MAV_PAYLOAD(msg), &packet, 5);
#endif
msg->msgid = MAVLINK_MSG_ID_DEBUG;
return mavlink_finalize_message(msg, system_id, component_id, 5);
}
/**
* @brief Pack a debug message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param ind index of debug variable
* @param value DEBUG value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_debug_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t ind,float value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[5];
_mav_put_uint8_t(buf, 0, ind);
_mav_put_float(buf, 1, value);
memcpy(_MAV_PAYLOAD(msg), buf, 5);
#else
mavlink_debug_t packet;
packet.ind = ind;
packet.value = value;
memcpy(_MAV_PAYLOAD(msg), &packet, 5);
#endif
msg->msgid = MAVLINK_MSG_ID_DEBUG;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 5);
}
/**
* @brief Encode a debug struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param debug C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_debug_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_debug_t* debug)
{
return mavlink_msg_debug_pack(system_id, component_id, msg, debug->ind, debug->value);
}
/**
* @brief Send a debug message
* @param chan MAVLink channel to send the message
*
* @param ind index of debug variable
* @param value DEBUG value
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_debug_send(mavlink_channel_t chan, uint8_t ind, float value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[5];
_mav_put_uint8_t(buf, 0, ind);
_mav_put_float(buf, 1, value);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG, buf, 5);
#else
mavlink_debug_t packet;
packet.ind = ind;
packet.value = value;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG, (const char *)&packet, 5);
#endif
}
#endif
// MESSAGE DEBUG UNPACKING
/**
* @brief Get field ind from debug message
*
* @return index of debug variable
*/
static inline uint8_t mavlink_msg_debug_get_ind(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field value from debug message
*
* @return DEBUG value
*/
static inline float mavlink_msg_debug_get_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 1);
}
/**
* @brief Decode a debug message into a struct
*
* @param msg The message to decode
* @param debug C-struct to decode the message contents into
*/
static inline void mavlink_msg_debug_decode(const mavlink_message_t* msg, mavlink_debug_t* debug)
{
#if MAVLINK_NEED_BYTE_SWAP
debug->ind = mavlink_msg_debug_get_ind(msg);
debug->value = mavlink_msg_debug_get_value(msg);
#else
memcpy(debug, _MAV_PAYLOAD(msg), 5);
#endif
}
@@ -1,226 +0,0 @@
// MESSAGE DEBUG_VECT PACKING
#define MAVLINK_MSG_ID_DEBUG_VECT 251
typedef struct __mavlink_debug_vect_t
{
char name[10]; ///< Name
uint64_t usec; ///< Timestamp
float x; ///< x
float y; ///< y
float z; ///< z
} mavlink_debug_vect_t;
#define MAVLINK_MSG_ID_DEBUG_VECT_LEN 30
#define MAVLINK_MSG_ID_251_LEN 30
#define MAVLINK_MSG_DEBUG_VECT_FIELD_NAME_LEN 10
#define MAVLINK_MESSAGE_INFO_DEBUG_VECT { \
"DEBUG_VECT", \
5, \
{ { "name", NULL, MAVLINK_TYPE_CHAR, 10, 0, offsetof(mavlink_debug_vect_t, name) }, \
{ "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 10, offsetof(mavlink_debug_vect_t, usec) }, \
{ "x", NULL, MAVLINK_TYPE_FLOAT, 0, 18, offsetof(mavlink_debug_vect_t, x) }, \
{ "y", NULL, MAVLINK_TYPE_FLOAT, 0, 22, offsetof(mavlink_debug_vect_t, y) }, \
{ "z", NULL, MAVLINK_TYPE_FLOAT, 0, 26, offsetof(mavlink_debug_vect_t, z) }, \
} \
}
/**
* @brief Pack a debug_vect message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param name Name
* @param usec Timestamp
* @param x x
* @param y y
* @param z z
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_debug_vect_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
const char *name, uint64_t usec, float x, float y, float z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[30];
_mav_put_uint64_t(buf, 10, usec);
_mav_put_float(buf, 18, x);
_mav_put_float(buf, 22, y);
_mav_put_float(buf, 26, z);
_mav_put_char_array(buf, 0, name, 10);
memcpy(_MAV_PAYLOAD(msg), buf, 30);
#else
mavlink_debug_vect_t packet;
packet.usec = usec;
packet.x = x;
packet.y = y;
packet.z = z;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
memcpy(_MAV_PAYLOAD(msg), &packet, 30);
#endif
msg->msgid = MAVLINK_MSG_ID_DEBUG_VECT;
return mavlink_finalize_message(msg, system_id, component_id, 30);
}
/**
* @brief Pack a debug_vect message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param name Name
* @param usec Timestamp
* @param x x
* @param y y
* @param z z
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_debug_vect_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
const char *name,uint64_t usec,float x,float y,float z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[30];
_mav_put_uint64_t(buf, 10, usec);
_mav_put_float(buf, 18, x);
_mav_put_float(buf, 22, y);
_mav_put_float(buf, 26, z);
_mav_put_char_array(buf, 0, name, 10);
memcpy(_MAV_PAYLOAD(msg), buf, 30);
#else
mavlink_debug_vect_t packet;
packet.usec = usec;
packet.x = x;
packet.y = y;
packet.z = z;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
memcpy(_MAV_PAYLOAD(msg), &packet, 30);
#endif
msg->msgid = MAVLINK_MSG_ID_DEBUG_VECT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 30);
}
/**
* @brief Encode a debug_vect struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param debug_vect C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_debug_vect_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_debug_vect_t* debug_vect)
{
return mavlink_msg_debug_vect_pack(system_id, component_id, msg, debug_vect->name, debug_vect->usec, debug_vect->x, debug_vect->y, debug_vect->z);
}
/**
* @brief Send a debug_vect message
* @param chan MAVLink channel to send the message
*
* @param name Name
* @param usec Timestamp
* @param x x
* @param y y
* @param z z
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_debug_vect_send(mavlink_channel_t chan, const char *name, uint64_t usec, float x, float y, float z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[30];
_mav_put_uint64_t(buf, 10, usec);
_mav_put_float(buf, 18, x);
_mav_put_float(buf, 22, y);
_mav_put_float(buf, 26, z);
_mav_put_char_array(buf, 0, name, 10);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_VECT, buf, 30);
#else
mavlink_debug_vect_t packet;
packet.usec = usec;
packet.x = x;
packet.y = y;
packet.z = z;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_VECT, (const char *)&packet, 30);
#endif
}
#endif
// MESSAGE DEBUG_VECT UNPACKING
/**
* @brief Get field name from debug_vect message
*
* @return Name
*/
static inline uint16_t mavlink_msg_debug_vect_get_name(const mavlink_message_t* msg, char *name)
{
return _MAV_RETURN_char_array(msg, name, 10, 0);
}
/**
* @brief Get field usec from debug_vect message
*
* @return Timestamp
*/
static inline uint64_t mavlink_msg_debug_vect_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 10);
}
/**
* @brief Get field x from debug_vect message
*
* @return x
*/
static inline float mavlink_msg_debug_vect_get_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 18);
}
/**
* @brief Get field y from debug_vect message
*
* @return y
*/
static inline float mavlink_msg_debug_vect_get_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 22);
}
/**
* @brief Get field z from debug_vect message
*
* @return z
*/
static inline float mavlink_msg_debug_vect_get_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 26);
}
/**
* @brief Decode a debug_vect message into a struct
*
* @param msg The message to decode
* @param debug_vect C-struct to decode the message contents into
*/
static inline void mavlink_msg_debug_vect_decode(const mavlink_message_t* msg, mavlink_debug_vect_t* debug_vect)
{
#if MAVLINK_NEED_BYTE_SWAP
mavlink_msg_debug_vect_get_name(msg, debug_vect->name);
debug_vect->usec = mavlink_msg_debug_vect_get_usec(msg);
debug_vect->x = mavlink_msg_debug_vect_get_x(msg);
debug_vect->y = mavlink_msg_debug_vect_get_y(msg);
debug_vect->z = mavlink_msg_debug_vect_get_z(msg);
#else
memcpy(debug_vect, _MAV_PAYLOAD(msg), 30);
#endif
}
@@ -1,276 +0,0 @@
// MESSAGE GLOBAL_POSITION PACKING
#define MAVLINK_MSG_ID_GLOBAL_POSITION 33
typedef struct __mavlink_global_position_t
{
uint64_t usec; ///< Timestamp (microseconds since unix epoch)
float lat; ///< Latitude, in degrees
float lon; ///< Longitude, in degrees
float alt; ///< Absolute altitude, in meters
float vx; ///< X Speed (in Latitude direction, positive: going north)
float vy; ///< Y Speed (in Longitude direction, positive: going east)
float vz; ///< Z Speed (in Altitude direction, positive: going up)
} mavlink_global_position_t;
#define MAVLINK_MSG_ID_GLOBAL_POSITION_LEN 32
#define MAVLINK_MSG_ID_33_LEN 32
#define MAVLINK_MESSAGE_INFO_GLOBAL_POSITION { \
"GLOBAL_POSITION", \
7, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_global_position_t, usec) }, \
{ "lat", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_global_position_t, lat) }, \
{ "lon", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_global_position_t, lon) }, \
{ "alt", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_global_position_t, alt) }, \
{ "vx", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_global_position_t, vx) }, \
{ "vy", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_global_position_t, vy) }, \
{ "vz", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_global_position_t, vz) }, \
} \
}
/**
* @brief Pack a global_position message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since unix epoch)
* @param lat Latitude, in degrees
* @param lon Longitude, in degrees
* @param alt Absolute altitude, in meters
* @param vx X Speed (in Latitude direction, positive: going north)
* @param vy Y Speed (in Longitude direction, positive: going east)
* @param vz Z Speed (in Altitude direction, positive: going up)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_global_position_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, float lat, float lon, float alt, float vx, float vy, float vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, lat);
_mav_put_float(buf, 12, lon);
_mav_put_float(buf, 16, alt);
_mav_put_float(buf, 20, vx);
_mav_put_float(buf, 24, vy);
_mav_put_float(buf, 28, vz);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_global_position_t packet;
packet.usec = usec;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_GLOBAL_POSITION;
return mavlink_finalize_message(msg, system_id, component_id, 32);
}
/**
* @brief Pack a global_position message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since unix epoch)
* @param lat Latitude, in degrees
* @param lon Longitude, in degrees
* @param alt Absolute altitude, in meters
* @param vx X Speed (in Latitude direction, positive: going north)
* @param vy Y Speed (in Longitude direction, positive: going east)
* @param vz Z Speed (in Altitude direction, positive: going up)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_global_position_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,float lat,float lon,float alt,float vx,float vy,float vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, lat);
_mav_put_float(buf, 12, lon);
_mav_put_float(buf, 16, alt);
_mav_put_float(buf, 20, vx);
_mav_put_float(buf, 24, vy);
_mav_put_float(buf, 28, vz);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_global_position_t packet;
packet.usec = usec;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_GLOBAL_POSITION;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 32);
}
/**
* @brief Encode a global_position struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param global_position C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_global_position_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_global_position_t* global_position)
{
return mavlink_msg_global_position_pack(system_id, component_id, msg, global_position->usec, global_position->lat, global_position->lon, global_position->alt, global_position->vx, global_position->vy, global_position->vz);
}
/**
* @brief Send a global_position message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since unix epoch)
* @param lat Latitude, in degrees
* @param lon Longitude, in degrees
* @param alt Absolute altitude, in meters
* @param vx X Speed (in Latitude direction, positive: going north)
* @param vy Y Speed (in Longitude direction, positive: going east)
* @param vz Z Speed (in Altitude direction, positive: going up)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_global_position_send(mavlink_channel_t chan, uint64_t usec, float lat, float lon, float alt, float vx, float vy, float vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, lat);
_mav_put_float(buf, 12, lon);
_mav_put_float(buf, 16, alt);
_mav_put_float(buf, 20, vx);
_mav_put_float(buf, 24, vy);
_mav_put_float(buf, 28, vz);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GLOBAL_POSITION, buf, 32);
#else
mavlink_global_position_t packet;
packet.usec = usec;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GLOBAL_POSITION, (const char *)&packet, 32);
#endif
}
#endif
// MESSAGE GLOBAL_POSITION UNPACKING
/**
* @brief Get field usec from global_position message
*
* @return Timestamp (microseconds since unix epoch)
*/
static inline uint64_t mavlink_msg_global_position_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field lat from global_position message
*
* @return Latitude, in degrees
*/
static inline float mavlink_msg_global_position_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field lon from global_position message
*
* @return Longitude, in degrees
*/
static inline float mavlink_msg_global_position_get_lon(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field alt from global_position message
*
* @return Absolute altitude, in meters
*/
static inline float mavlink_msg_global_position_get_alt(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field vx from global_position message
*
* @return X Speed (in Latitude direction, positive: going north)
*/
static inline float mavlink_msg_global_position_get_vx(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field vy from global_position message
*
* @return Y Speed (in Longitude direction, positive: going east)
*/
static inline float mavlink_msg_global_position_get_vy(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 24);
}
/**
* @brief Get field vz from global_position message
*
* @return Z Speed (in Altitude direction, positive: going up)
*/
static inline float mavlink_msg_global_position_get_vz(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Decode a global_position message into a struct
*
* @param msg The message to decode
* @param global_position C-struct to decode the message contents into
*/
static inline void mavlink_msg_global_position_decode(const mavlink_message_t* msg, mavlink_global_position_t* global_position)
{
#if MAVLINK_NEED_BYTE_SWAP
global_position->usec = mavlink_msg_global_position_get_usec(msg);
global_position->lat = mavlink_msg_global_position_get_lat(msg);
global_position->lon = mavlink_msg_global_position_get_lon(msg);
global_position->alt = mavlink_msg_global_position_get_alt(msg);
global_position->vx = mavlink_msg_global_position_get_vx(msg);
global_position->vy = mavlink_msg_global_position_get_vy(msg);
global_position->vz = mavlink_msg_global_position_get_vz(msg);
#else
memcpy(global_position, _MAV_PAYLOAD(msg), 32);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE GLOBAL_POSITION_INT PACKING
#define MAVLINK_MSG_ID_GLOBAL_POSITION_INT 73
typedef struct __mavlink_global_position_int_t
{
int32_t lat; ///< Latitude, expressed as * 1E7
int32_t lon; ///< Longitude, expressed as * 1E7
int32_t alt; ///< Altitude in meters, expressed as * 1000 (millimeters)
int16_t vx; ///< Ground X Speed (Latitude), expressed as m/s * 100
int16_t vy; ///< Ground Y Speed (Longitude), expressed as m/s * 100
int16_t vz; ///< Ground Z Speed (Altitude), expressed as m/s * 100
} mavlink_global_position_int_t;
#define MAVLINK_MSG_ID_GLOBAL_POSITION_INT_LEN 18
#define MAVLINK_MSG_ID_73_LEN 18
#define MAVLINK_MESSAGE_INFO_GLOBAL_POSITION_INT { \
"GLOBAL_POSITION_INT", \
6, \
{ { "lat", NULL, MAVLINK_TYPE_INT32_T, 0, 0, offsetof(mavlink_global_position_int_t, lat) }, \
{ "lon", NULL, MAVLINK_TYPE_INT32_T, 0, 4, offsetof(mavlink_global_position_int_t, lon) }, \
{ "alt", NULL, MAVLINK_TYPE_INT32_T, 0, 8, offsetof(mavlink_global_position_int_t, alt) }, \
{ "vx", NULL, MAVLINK_TYPE_INT16_T, 0, 12, offsetof(mavlink_global_position_int_t, vx) }, \
{ "vy", NULL, MAVLINK_TYPE_INT16_T, 0, 14, offsetof(mavlink_global_position_int_t, vy) }, \
{ "vz", NULL, MAVLINK_TYPE_INT16_T, 0, 16, offsetof(mavlink_global_position_int_t, vz) }, \
} \
}
/**
* @brief Pack a global_position_int message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param lat Latitude, expressed as * 1E7
* @param lon Longitude, expressed as * 1E7
* @param alt Altitude in meters, expressed as * 1000 (millimeters)
* @param vx Ground X Speed (Latitude), expressed as m/s * 100
* @param vy Ground Y Speed (Longitude), expressed as m/s * 100
* @param vz Ground Z Speed (Altitude), expressed as m/s * 100
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_global_position_int_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
int32_t lat, int32_t lon, int32_t alt, int16_t vx, int16_t vy, int16_t vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_int32_t(buf, 0, lat);
_mav_put_int32_t(buf, 4, lon);
_mav_put_int32_t(buf, 8, alt);
_mav_put_int16_t(buf, 12, vx);
_mav_put_int16_t(buf, 14, vy);
_mav_put_int16_t(buf, 16, vz);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_global_position_int_t packet;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_GLOBAL_POSITION_INT;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a global_position_int message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param lat Latitude, expressed as * 1E7
* @param lon Longitude, expressed as * 1E7
* @param alt Altitude in meters, expressed as * 1000 (millimeters)
* @param vx Ground X Speed (Latitude), expressed as m/s * 100
* @param vy Ground Y Speed (Longitude), expressed as m/s * 100
* @param vz Ground Z Speed (Altitude), expressed as m/s * 100
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_global_position_int_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
int32_t lat,int32_t lon,int32_t alt,int16_t vx,int16_t vy,int16_t vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_int32_t(buf, 0, lat);
_mav_put_int32_t(buf, 4, lon);
_mav_put_int32_t(buf, 8, alt);
_mav_put_int16_t(buf, 12, vx);
_mav_put_int16_t(buf, 14, vy);
_mav_put_int16_t(buf, 16, vz);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_global_position_int_t packet;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_GLOBAL_POSITION_INT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a global_position_int struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param global_position_int C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_global_position_int_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_global_position_int_t* global_position_int)
{
return mavlink_msg_global_position_int_pack(system_id, component_id, msg, global_position_int->lat, global_position_int->lon, global_position_int->alt, global_position_int->vx, global_position_int->vy, global_position_int->vz);
}
/**
* @brief Send a global_position_int message
* @param chan MAVLink channel to send the message
*
* @param lat Latitude, expressed as * 1E7
* @param lon Longitude, expressed as * 1E7
* @param alt Altitude in meters, expressed as * 1000 (millimeters)
* @param vx Ground X Speed (Latitude), expressed as m/s * 100
* @param vy Ground Y Speed (Longitude), expressed as m/s * 100
* @param vz Ground Z Speed (Altitude), expressed as m/s * 100
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_global_position_int_send(mavlink_channel_t chan, int32_t lat, int32_t lon, int32_t alt, int16_t vx, int16_t vy, int16_t vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_int32_t(buf, 0, lat);
_mav_put_int32_t(buf, 4, lon);
_mav_put_int32_t(buf, 8, alt);
_mav_put_int16_t(buf, 12, vx);
_mav_put_int16_t(buf, 14, vy);
_mav_put_int16_t(buf, 16, vz);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GLOBAL_POSITION_INT, buf, 18);
#else
mavlink_global_position_int_t packet;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GLOBAL_POSITION_INT, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE GLOBAL_POSITION_INT UNPACKING
/**
* @brief Get field lat from global_position_int message
*
* @return Latitude, expressed as * 1E7
*/
static inline int32_t mavlink_msg_global_position_int_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 0);
}
/**
* @brief Get field lon from global_position_int message
*
* @return Longitude, expressed as * 1E7
*/
static inline int32_t mavlink_msg_global_position_int_get_lon(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 4);
}
/**
* @brief Get field alt from global_position_int message
*
* @return Altitude in meters, expressed as * 1000 (millimeters)
*/
static inline int32_t mavlink_msg_global_position_int_get_alt(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 8);
}
/**
* @brief Get field vx from global_position_int message
*
* @return Ground X Speed (Latitude), expressed as m/s * 100
*/
static inline int16_t mavlink_msg_global_position_int_get_vx(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 12);
}
/**
* @brief Get field vy from global_position_int message
*
* @return Ground Y Speed (Longitude), expressed as m/s * 100
*/
static inline int16_t mavlink_msg_global_position_int_get_vy(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 14);
}
/**
* @brief Get field vz from global_position_int message
*
* @return Ground Z Speed (Altitude), expressed as m/s * 100
*/
static inline int16_t mavlink_msg_global_position_int_get_vz(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 16);
}
/**
* @brief Decode a global_position_int message into a struct
*
* @param msg The message to decode
* @param global_position_int C-struct to decode the message contents into
*/
static inline void mavlink_msg_global_position_int_decode(const mavlink_message_t* msg, mavlink_global_position_int_t* global_position_int)
{
#if MAVLINK_NEED_BYTE_SWAP
global_position_int->lat = mavlink_msg_global_position_int_get_lat(msg);
global_position_int->lon = mavlink_msg_global_position_int_get_lon(msg);
global_position_int->alt = mavlink_msg_global_position_int_get_alt(msg);
global_position_int->vx = mavlink_msg_global_position_int_get_vx(msg);
global_position_int->vy = mavlink_msg_global_position_int_get_vy(msg);
global_position_int->vz = mavlink_msg_global_position_int_get_vz(msg);
#else
memcpy(global_position_int, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,188 +0,0 @@
// MESSAGE GPS_LOCAL_ORIGIN_SET PACKING
#define MAVLINK_MSG_ID_GPS_LOCAL_ORIGIN_SET 49
typedef struct __mavlink_gps_local_origin_set_t
{
int32_t latitude; ///< Latitude (WGS84), expressed as * 1E7
int32_t longitude; ///< Longitude (WGS84), expressed as * 1E7
int32_t altitude; ///< Altitude(WGS84), expressed as * 1000
} mavlink_gps_local_origin_set_t;
#define MAVLINK_MSG_ID_GPS_LOCAL_ORIGIN_SET_LEN 12
#define MAVLINK_MSG_ID_49_LEN 12
#define MAVLINK_MESSAGE_INFO_GPS_LOCAL_ORIGIN_SET { \
"GPS_LOCAL_ORIGIN_SET", \
3, \
{ { "latitude", NULL, MAVLINK_TYPE_INT32_T, 0, 0, offsetof(mavlink_gps_local_origin_set_t, latitude) }, \
{ "longitude", NULL, MAVLINK_TYPE_INT32_T, 0, 4, offsetof(mavlink_gps_local_origin_set_t, longitude) }, \
{ "altitude", NULL, MAVLINK_TYPE_INT32_T, 0, 8, offsetof(mavlink_gps_local_origin_set_t, altitude) }, \
} \
}
/**
* @brief Pack a gps_local_origin_set message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param latitude Latitude (WGS84), expressed as * 1E7
* @param longitude Longitude (WGS84), expressed as * 1E7
* @param altitude Altitude(WGS84), expressed as * 1000
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_local_origin_set_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
int32_t latitude, int32_t longitude, int32_t altitude)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_int32_t(buf, 0, latitude);
_mav_put_int32_t(buf, 4, longitude);
_mav_put_int32_t(buf, 8, altitude);
memcpy(_MAV_PAYLOAD(msg), buf, 12);
#else
mavlink_gps_local_origin_set_t packet;
packet.latitude = latitude;
packet.longitude = longitude;
packet.altitude = altitude;
memcpy(_MAV_PAYLOAD(msg), &packet, 12);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_LOCAL_ORIGIN_SET;
return mavlink_finalize_message(msg, system_id, component_id, 12);
}
/**
* @brief Pack a gps_local_origin_set message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param latitude Latitude (WGS84), expressed as * 1E7
* @param longitude Longitude (WGS84), expressed as * 1E7
* @param altitude Altitude(WGS84), expressed as * 1000
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_local_origin_set_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
int32_t latitude,int32_t longitude,int32_t altitude)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_int32_t(buf, 0, latitude);
_mav_put_int32_t(buf, 4, longitude);
_mav_put_int32_t(buf, 8, altitude);
memcpy(_MAV_PAYLOAD(msg), buf, 12);
#else
mavlink_gps_local_origin_set_t packet;
packet.latitude = latitude;
packet.longitude = longitude;
packet.altitude = altitude;
memcpy(_MAV_PAYLOAD(msg), &packet, 12);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_LOCAL_ORIGIN_SET;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 12);
}
/**
* @brief Encode a gps_local_origin_set struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param gps_local_origin_set C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_gps_local_origin_set_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_gps_local_origin_set_t* gps_local_origin_set)
{
return mavlink_msg_gps_local_origin_set_pack(system_id, component_id, msg, gps_local_origin_set->latitude, gps_local_origin_set->longitude, gps_local_origin_set->altitude);
}
/**
* @brief Send a gps_local_origin_set message
* @param chan MAVLink channel to send the message
*
* @param latitude Latitude (WGS84), expressed as * 1E7
* @param longitude Longitude (WGS84), expressed as * 1E7
* @param altitude Altitude(WGS84), expressed as * 1000
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_gps_local_origin_set_send(mavlink_channel_t chan, int32_t latitude, int32_t longitude, int32_t altitude)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_int32_t(buf, 0, latitude);
_mav_put_int32_t(buf, 4, longitude);
_mav_put_int32_t(buf, 8, altitude);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_LOCAL_ORIGIN_SET, buf, 12);
#else
mavlink_gps_local_origin_set_t packet;
packet.latitude = latitude;
packet.longitude = longitude;
packet.altitude = altitude;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_LOCAL_ORIGIN_SET, (const char *)&packet, 12);
#endif
}
#endif
// MESSAGE GPS_LOCAL_ORIGIN_SET UNPACKING
/**
* @brief Get field latitude from gps_local_origin_set message
*
* @return Latitude (WGS84), expressed as * 1E7
*/
static inline int32_t mavlink_msg_gps_local_origin_set_get_latitude(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 0);
}
/**
* @brief Get field longitude from gps_local_origin_set message
*
* @return Longitude (WGS84), expressed as * 1E7
*/
static inline int32_t mavlink_msg_gps_local_origin_set_get_longitude(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 4);
}
/**
* @brief Get field altitude from gps_local_origin_set message
*
* @return Altitude(WGS84), expressed as * 1000
*/
static inline int32_t mavlink_msg_gps_local_origin_set_get_altitude(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 8);
}
/**
* @brief Decode a gps_local_origin_set message into a struct
*
* @param msg The message to decode
* @param gps_local_origin_set C-struct to decode the message contents into
*/
static inline void mavlink_msg_gps_local_origin_set_decode(const mavlink_message_t* msg, mavlink_gps_local_origin_set_t* gps_local_origin_set)
{
#if MAVLINK_NEED_BYTE_SWAP
gps_local_origin_set->latitude = mavlink_msg_gps_local_origin_set_get_latitude(msg);
gps_local_origin_set->longitude = mavlink_msg_gps_local_origin_set_get_longitude(msg);
gps_local_origin_set->altitude = mavlink_msg_gps_local_origin_set_get_altitude(msg);
#else
memcpy(gps_local_origin_set, _MAV_PAYLOAD(msg), 12);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE GPS_RAW PACKING
#define MAVLINK_MSG_ID_GPS_RAW 32
typedef struct __mavlink_gps_raw_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
uint8_t fix_type; ///< 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
float lat; ///< Latitude in degrees
float lon; ///< Longitude in degrees
float alt; ///< Altitude in meters
float eph; ///< GPS HDOP
float epv; ///< GPS VDOP
float v; ///< GPS ground speed
float hdg; ///< Compass heading in degrees, 0..360 degrees
} mavlink_gps_raw_t;
#define MAVLINK_MSG_ID_GPS_RAW_LEN 37
#define MAVLINK_MSG_ID_32_LEN 37
#define MAVLINK_MESSAGE_INFO_GPS_RAW { \
"GPS_RAW", \
9, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_gps_raw_t, usec) }, \
{ "fix_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_gps_raw_t, fix_type) }, \
{ "lat", NULL, MAVLINK_TYPE_FLOAT, 0, 9, offsetof(mavlink_gps_raw_t, lat) }, \
{ "lon", NULL, MAVLINK_TYPE_FLOAT, 0, 13, offsetof(mavlink_gps_raw_t, lon) }, \
{ "alt", NULL, MAVLINK_TYPE_FLOAT, 0, 17, offsetof(mavlink_gps_raw_t, alt) }, \
{ "eph", NULL, MAVLINK_TYPE_FLOAT, 0, 21, offsetof(mavlink_gps_raw_t, eph) }, \
{ "epv", NULL, MAVLINK_TYPE_FLOAT, 0, 25, offsetof(mavlink_gps_raw_t, epv) }, \
{ "v", NULL, MAVLINK_TYPE_FLOAT, 0, 29, offsetof(mavlink_gps_raw_t, v) }, \
{ "hdg", NULL, MAVLINK_TYPE_FLOAT, 0, 33, offsetof(mavlink_gps_raw_t, hdg) }, \
} \
}
/**
* @brief Pack a gps_raw message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param fix_type 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
* @param lat Latitude in degrees
* @param lon Longitude in degrees
* @param alt Altitude in meters
* @param eph GPS HDOP
* @param epv GPS VDOP
* @param v GPS ground speed
* @param hdg Compass heading in degrees, 0..360 degrees
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_raw_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, uint8_t fix_type, float lat, float lon, float alt, float eph, float epv, float v, float hdg)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[37];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_uint8_t(buf, 8, fix_type);
_mav_put_float(buf, 9, lat);
_mav_put_float(buf, 13, lon);
_mav_put_float(buf, 17, alt);
_mav_put_float(buf, 21, eph);
_mav_put_float(buf, 25, epv);
_mav_put_float(buf, 29, v);
_mav_put_float(buf, 33, hdg);
memcpy(_MAV_PAYLOAD(msg), buf, 37);
#else
mavlink_gps_raw_t packet;
packet.usec = usec;
packet.fix_type = fix_type;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.eph = eph;
packet.epv = epv;
packet.v = v;
packet.hdg = hdg;
memcpy(_MAV_PAYLOAD(msg), &packet, 37);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_RAW;
return mavlink_finalize_message(msg, system_id, component_id, 37);
}
/**
* @brief Pack a gps_raw message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param fix_type 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
* @param lat Latitude in degrees
* @param lon Longitude in degrees
* @param alt Altitude in meters
* @param eph GPS HDOP
* @param epv GPS VDOP
* @param v GPS ground speed
* @param hdg Compass heading in degrees, 0..360 degrees
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_raw_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,uint8_t fix_type,float lat,float lon,float alt,float eph,float epv,float v,float hdg)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[37];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_uint8_t(buf, 8, fix_type);
_mav_put_float(buf, 9, lat);
_mav_put_float(buf, 13, lon);
_mav_put_float(buf, 17, alt);
_mav_put_float(buf, 21, eph);
_mav_put_float(buf, 25, epv);
_mav_put_float(buf, 29, v);
_mav_put_float(buf, 33, hdg);
memcpy(_MAV_PAYLOAD(msg), buf, 37);
#else
mavlink_gps_raw_t packet;
packet.usec = usec;
packet.fix_type = fix_type;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.eph = eph;
packet.epv = epv;
packet.v = v;
packet.hdg = hdg;
memcpy(_MAV_PAYLOAD(msg), &packet, 37);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_RAW;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 37);
}
/**
* @brief Encode a gps_raw struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param gps_raw C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_gps_raw_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_gps_raw_t* gps_raw)
{
return mavlink_msg_gps_raw_pack(system_id, component_id, msg, gps_raw->usec, gps_raw->fix_type, gps_raw->lat, gps_raw->lon, gps_raw->alt, gps_raw->eph, gps_raw->epv, gps_raw->v, gps_raw->hdg);
}
/**
* @brief Send a gps_raw message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param fix_type 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
* @param lat Latitude in degrees
* @param lon Longitude in degrees
* @param alt Altitude in meters
* @param eph GPS HDOP
* @param epv GPS VDOP
* @param v GPS ground speed
* @param hdg Compass heading in degrees, 0..360 degrees
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_gps_raw_send(mavlink_channel_t chan, uint64_t usec, uint8_t fix_type, float lat, float lon, float alt, float eph, float epv, float v, float hdg)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[37];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_uint8_t(buf, 8, fix_type);
_mav_put_float(buf, 9, lat);
_mav_put_float(buf, 13, lon);
_mav_put_float(buf, 17, alt);
_mav_put_float(buf, 21, eph);
_mav_put_float(buf, 25, epv);
_mav_put_float(buf, 29, v);
_mav_put_float(buf, 33, hdg);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_RAW, buf, 37);
#else
mavlink_gps_raw_t packet;
packet.usec = usec;
packet.fix_type = fix_type;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.eph = eph;
packet.epv = epv;
packet.v = v;
packet.hdg = hdg;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_RAW, (const char *)&packet, 37);
#endif
}
#endif
// MESSAGE GPS_RAW UNPACKING
/**
* @brief Get field usec from gps_raw message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_gps_raw_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field fix_type from gps_raw message
*
* @return 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
*/
static inline uint8_t mavlink_msg_gps_raw_get_fix_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 8);
}
/**
* @brief Get field lat from gps_raw message
*
* @return Latitude in degrees
*/
static inline float mavlink_msg_gps_raw_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 9);
}
/**
* @brief Get field lon from gps_raw message
*
* @return Longitude in degrees
*/
static inline float mavlink_msg_gps_raw_get_lon(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 13);
}
/**
* @brief Get field alt from gps_raw message
*
* @return Altitude in meters
*/
static inline float mavlink_msg_gps_raw_get_alt(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 17);
}
/**
* @brief Get field eph from gps_raw message
*
* @return GPS HDOP
*/
static inline float mavlink_msg_gps_raw_get_eph(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 21);
}
/**
* @brief Get field epv from gps_raw message
*
* @return GPS VDOP
*/
static inline float mavlink_msg_gps_raw_get_epv(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 25);
}
/**
* @brief Get field v from gps_raw message
*
* @return GPS ground speed
*/
static inline float mavlink_msg_gps_raw_get_v(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 29);
}
/**
* @brief Get field hdg from gps_raw message
*
* @return Compass heading in degrees, 0..360 degrees
*/
static inline float mavlink_msg_gps_raw_get_hdg(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 33);
}
/**
* @brief Decode a gps_raw message into a struct
*
* @param msg The message to decode
* @param gps_raw C-struct to decode the message contents into
*/
static inline void mavlink_msg_gps_raw_decode(const mavlink_message_t* msg, mavlink_gps_raw_t* gps_raw)
{
#if MAVLINK_NEED_BYTE_SWAP
gps_raw->usec = mavlink_msg_gps_raw_get_usec(msg);
gps_raw->fix_type = mavlink_msg_gps_raw_get_fix_type(msg);
gps_raw->lat = mavlink_msg_gps_raw_get_lat(msg);
gps_raw->lon = mavlink_msg_gps_raw_get_lon(msg);
gps_raw->alt = mavlink_msg_gps_raw_get_alt(msg);
gps_raw->eph = mavlink_msg_gps_raw_get_eph(msg);
gps_raw->epv = mavlink_msg_gps_raw_get_epv(msg);
gps_raw->v = mavlink_msg_gps_raw_get_v(msg);
gps_raw->hdg = mavlink_msg_gps_raw_get_hdg(msg);
#else
memcpy(gps_raw, _MAV_PAYLOAD(msg), 37);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE GPS_RAW_INT PACKING
#define MAVLINK_MSG_ID_GPS_RAW_INT 25
typedef struct __mavlink_gps_raw_int_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
uint8_t fix_type; ///< 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
int32_t lat; ///< Latitude in 1E7 degrees
int32_t lon; ///< Longitude in 1E7 degrees
int32_t alt; ///< Altitude in 1E3 meters (millimeters)
float eph; ///< GPS HDOP
float epv; ///< GPS VDOP
float v; ///< GPS ground speed (m/s)
float hdg; ///< Compass heading in degrees, 0..360 degrees
} mavlink_gps_raw_int_t;
#define MAVLINK_MSG_ID_GPS_RAW_INT_LEN 37
#define MAVLINK_MSG_ID_25_LEN 37
#define MAVLINK_MESSAGE_INFO_GPS_RAW_INT { \
"GPS_RAW_INT", \
9, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_gps_raw_int_t, usec) }, \
{ "fix_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_gps_raw_int_t, fix_type) }, \
{ "lat", NULL, MAVLINK_TYPE_INT32_T, 0, 9, offsetof(mavlink_gps_raw_int_t, lat) }, \
{ "lon", NULL, MAVLINK_TYPE_INT32_T, 0, 13, offsetof(mavlink_gps_raw_int_t, lon) }, \
{ "alt", NULL, MAVLINK_TYPE_INT32_T, 0, 17, offsetof(mavlink_gps_raw_int_t, alt) }, \
{ "eph", NULL, MAVLINK_TYPE_FLOAT, 0, 21, offsetof(mavlink_gps_raw_int_t, eph) }, \
{ "epv", NULL, MAVLINK_TYPE_FLOAT, 0, 25, offsetof(mavlink_gps_raw_int_t, epv) }, \
{ "v", NULL, MAVLINK_TYPE_FLOAT, 0, 29, offsetof(mavlink_gps_raw_int_t, v) }, \
{ "hdg", NULL, MAVLINK_TYPE_FLOAT, 0, 33, offsetof(mavlink_gps_raw_int_t, hdg) }, \
} \
}
/**
* @brief Pack a gps_raw_int message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param fix_type 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
* @param lat Latitude in 1E7 degrees
* @param lon Longitude in 1E7 degrees
* @param alt Altitude in 1E3 meters (millimeters)
* @param eph GPS HDOP
* @param epv GPS VDOP
* @param v GPS ground speed (m/s)
* @param hdg Compass heading in degrees, 0..360 degrees
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_raw_int_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, uint8_t fix_type, int32_t lat, int32_t lon, int32_t alt, float eph, float epv, float v, float hdg)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[37];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_uint8_t(buf, 8, fix_type);
_mav_put_int32_t(buf, 9, lat);
_mav_put_int32_t(buf, 13, lon);
_mav_put_int32_t(buf, 17, alt);
_mav_put_float(buf, 21, eph);
_mav_put_float(buf, 25, epv);
_mav_put_float(buf, 29, v);
_mav_put_float(buf, 33, hdg);
memcpy(_MAV_PAYLOAD(msg), buf, 37);
#else
mavlink_gps_raw_int_t packet;
packet.usec = usec;
packet.fix_type = fix_type;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.eph = eph;
packet.epv = epv;
packet.v = v;
packet.hdg = hdg;
memcpy(_MAV_PAYLOAD(msg), &packet, 37);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_RAW_INT;
return mavlink_finalize_message(msg, system_id, component_id, 37);
}
/**
* @brief Pack a gps_raw_int message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param fix_type 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
* @param lat Latitude in 1E7 degrees
* @param lon Longitude in 1E7 degrees
* @param alt Altitude in 1E3 meters (millimeters)
* @param eph GPS HDOP
* @param epv GPS VDOP
* @param v GPS ground speed (m/s)
* @param hdg Compass heading in degrees, 0..360 degrees
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_raw_int_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,uint8_t fix_type,int32_t lat,int32_t lon,int32_t alt,float eph,float epv,float v,float hdg)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[37];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_uint8_t(buf, 8, fix_type);
_mav_put_int32_t(buf, 9, lat);
_mav_put_int32_t(buf, 13, lon);
_mav_put_int32_t(buf, 17, alt);
_mav_put_float(buf, 21, eph);
_mav_put_float(buf, 25, epv);
_mav_put_float(buf, 29, v);
_mav_put_float(buf, 33, hdg);
memcpy(_MAV_PAYLOAD(msg), buf, 37);
#else
mavlink_gps_raw_int_t packet;
packet.usec = usec;
packet.fix_type = fix_type;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.eph = eph;
packet.epv = epv;
packet.v = v;
packet.hdg = hdg;
memcpy(_MAV_PAYLOAD(msg), &packet, 37);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_RAW_INT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 37);
}
/**
* @brief Encode a gps_raw_int struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param gps_raw_int C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_gps_raw_int_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_gps_raw_int_t* gps_raw_int)
{
return mavlink_msg_gps_raw_int_pack(system_id, component_id, msg, gps_raw_int->usec, gps_raw_int->fix_type, gps_raw_int->lat, gps_raw_int->lon, gps_raw_int->alt, gps_raw_int->eph, gps_raw_int->epv, gps_raw_int->v, gps_raw_int->hdg);
}
/**
* @brief Send a gps_raw_int message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param fix_type 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
* @param lat Latitude in 1E7 degrees
* @param lon Longitude in 1E7 degrees
* @param alt Altitude in 1E3 meters (millimeters)
* @param eph GPS HDOP
* @param epv GPS VDOP
* @param v GPS ground speed (m/s)
* @param hdg Compass heading in degrees, 0..360 degrees
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_gps_raw_int_send(mavlink_channel_t chan, uint64_t usec, uint8_t fix_type, int32_t lat, int32_t lon, int32_t alt, float eph, float epv, float v, float hdg)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[37];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_uint8_t(buf, 8, fix_type);
_mav_put_int32_t(buf, 9, lat);
_mav_put_int32_t(buf, 13, lon);
_mav_put_int32_t(buf, 17, alt);
_mav_put_float(buf, 21, eph);
_mav_put_float(buf, 25, epv);
_mav_put_float(buf, 29, v);
_mav_put_float(buf, 33, hdg);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_RAW_INT, buf, 37);
#else
mavlink_gps_raw_int_t packet;
packet.usec = usec;
packet.fix_type = fix_type;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.eph = eph;
packet.epv = epv;
packet.v = v;
packet.hdg = hdg;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_RAW_INT, (const char *)&packet, 37);
#endif
}
#endif
// MESSAGE GPS_RAW_INT UNPACKING
/**
* @brief Get field usec from gps_raw_int message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_gps_raw_int_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field fix_type from gps_raw_int message
*
* @return 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.
*/
static inline uint8_t mavlink_msg_gps_raw_int_get_fix_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 8);
}
/**
* @brief Get field lat from gps_raw_int message
*
* @return Latitude in 1E7 degrees
*/
static inline int32_t mavlink_msg_gps_raw_int_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 9);
}
/**
* @brief Get field lon from gps_raw_int message
*
* @return Longitude in 1E7 degrees
*/
static inline int32_t mavlink_msg_gps_raw_int_get_lon(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 13);
}
/**
* @brief Get field alt from gps_raw_int message
*
* @return Altitude in 1E3 meters (millimeters)
*/
static inline int32_t mavlink_msg_gps_raw_int_get_alt(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 17);
}
/**
* @brief Get field eph from gps_raw_int message
*
* @return GPS HDOP
*/
static inline float mavlink_msg_gps_raw_int_get_eph(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 21);
}
/**
* @brief Get field epv from gps_raw_int message
*
* @return GPS VDOP
*/
static inline float mavlink_msg_gps_raw_int_get_epv(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 25);
}
/**
* @brief Get field v from gps_raw_int message
*
* @return GPS ground speed (m/s)
*/
static inline float mavlink_msg_gps_raw_int_get_v(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 29);
}
/**
* @brief Get field hdg from gps_raw_int message
*
* @return Compass heading in degrees, 0..360 degrees
*/
static inline float mavlink_msg_gps_raw_int_get_hdg(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 33);
}
/**
* @brief Decode a gps_raw_int message into a struct
*
* @param msg The message to decode
* @param gps_raw_int C-struct to decode the message contents into
*/
static inline void mavlink_msg_gps_raw_int_decode(const mavlink_message_t* msg, mavlink_gps_raw_int_t* gps_raw_int)
{
#if MAVLINK_NEED_BYTE_SWAP
gps_raw_int->usec = mavlink_msg_gps_raw_int_get_usec(msg);
gps_raw_int->fix_type = mavlink_msg_gps_raw_int_get_fix_type(msg);
gps_raw_int->lat = mavlink_msg_gps_raw_int_get_lat(msg);
gps_raw_int->lon = mavlink_msg_gps_raw_int_get_lon(msg);
gps_raw_int->alt = mavlink_msg_gps_raw_int_get_alt(msg);
gps_raw_int->eph = mavlink_msg_gps_raw_int_get_eph(msg);
gps_raw_int->epv = mavlink_msg_gps_raw_int_get_epv(msg);
gps_raw_int->v = mavlink_msg_gps_raw_int_get_v(msg);
gps_raw_int->hdg = mavlink_msg_gps_raw_int_get_hdg(msg);
#else
memcpy(gps_raw_int, _MAV_PAYLOAD(msg), 37);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE GPS_SET_GLOBAL_ORIGIN PACKING
#define MAVLINK_MSG_ID_GPS_SET_GLOBAL_ORIGIN 48
typedef struct __mavlink_gps_set_global_origin_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
int32_t latitude; ///< global position * 1E7
int32_t longitude; ///< global position * 1E7
int32_t altitude; ///< global position * 1000
} mavlink_gps_set_global_origin_t;
#define MAVLINK_MSG_ID_GPS_SET_GLOBAL_ORIGIN_LEN 14
#define MAVLINK_MSG_ID_48_LEN 14
#define MAVLINK_MESSAGE_INFO_GPS_SET_GLOBAL_ORIGIN { \
"GPS_SET_GLOBAL_ORIGIN", \
5, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_gps_set_global_origin_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_gps_set_global_origin_t, target_component) }, \
{ "latitude", NULL, MAVLINK_TYPE_INT32_T, 0, 2, offsetof(mavlink_gps_set_global_origin_t, latitude) }, \
{ "longitude", NULL, MAVLINK_TYPE_INT32_T, 0, 6, offsetof(mavlink_gps_set_global_origin_t, longitude) }, \
{ "altitude", NULL, MAVLINK_TYPE_INT32_T, 0, 10, offsetof(mavlink_gps_set_global_origin_t, altitude) }, \
} \
}
/**
* @brief Pack a gps_set_global_origin message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param latitude global position * 1E7
* @param longitude global position * 1E7
* @param altitude global position * 1000
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_set_global_origin_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, int32_t latitude, int32_t longitude, int32_t altitude)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, latitude);
_mav_put_int32_t(buf, 6, longitude);
_mav_put_int32_t(buf, 10, altitude);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_gps_set_global_origin_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.latitude = latitude;
packet.longitude = longitude;
packet.altitude = altitude;
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_SET_GLOBAL_ORIGIN;
return mavlink_finalize_message(msg, system_id, component_id, 14);
}
/**
* @brief Pack a gps_set_global_origin message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param latitude global position * 1E7
* @param longitude global position * 1E7
* @param altitude global position * 1000
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_set_global_origin_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,int32_t latitude,int32_t longitude,int32_t altitude)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, latitude);
_mav_put_int32_t(buf, 6, longitude);
_mav_put_int32_t(buf, 10, altitude);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_gps_set_global_origin_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.latitude = latitude;
packet.longitude = longitude;
packet.altitude = altitude;
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_SET_GLOBAL_ORIGIN;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 14);
}
/**
* @brief Encode a gps_set_global_origin struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param gps_set_global_origin C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_gps_set_global_origin_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_gps_set_global_origin_t* gps_set_global_origin)
{
return mavlink_msg_gps_set_global_origin_pack(system_id, component_id, msg, gps_set_global_origin->target_system, gps_set_global_origin->target_component, gps_set_global_origin->latitude, gps_set_global_origin->longitude, gps_set_global_origin->altitude);
}
/**
* @brief Send a gps_set_global_origin message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param latitude global position * 1E7
* @param longitude global position * 1E7
* @param altitude global position * 1000
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_gps_set_global_origin_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, int32_t latitude, int32_t longitude, int32_t altitude)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int32_t(buf, 2, latitude);
_mav_put_int32_t(buf, 6, longitude);
_mav_put_int32_t(buf, 10, altitude);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_SET_GLOBAL_ORIGIN, buf, 14);
#else
mavlink_gps_set_global_origin_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.latitude = latitude;
packet.longitude = longitude;
packet.altitude = altitude;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_SET_GLOBAL_ORIGIN, (const char *)&packet, 14);
#endif
}
#endif
// MESSAGE GPS_SET_GLOBAL_ORIGIN UNPACKING
/**
* @brief Get field target_system from gps_set_global_origin message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_gps_set_global_origin_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from gps_set_global_origin message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_gps_set_global_origin_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field latitude from gps_set_global_origin message
*
* @return global position * 1E7
*/
static inline int32_t mavlink_msg_gps_set_global_origin_get_latitude(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 2);
}
/**
* @brief Get field longitude from gps_set_global_origin message
*
* @return global position * 1E7
*/
static inline int32_t mavlink_msg_gps_set_global_origin_get_longitude(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 6);
}
/**
* @brief Get field altitude from gps_set_global_origin message
*
* @return global position * 1000
*/
static inline int32_t mavlink_msg_gps_set_global_origin_get_altitude(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 10);
}
/**
* @brief Decode a gps_set_global_origin message into a struct
*
* @param msg The message to decode
* @param gps_set_global_origin C-struct to decode the message contents into
*/
static inline void mavlink_msg_gps_set_global_origin_decode(const mavlink_message_t* msg, mavlink_gps_set_global_origin_t* gps_set_global_origin)
{
#if MAVLINK_NEED_BYTE_SWAP
gps_set_global_origin->target_system = mavlink_msg_gps_set_global_origin_get_target_system(msg);
gps_set_global_origin->target_component = mavlink_msg_gps_set_global_origin_get_target_component(msg);
gps_set_global_origin->latitude = mavlink_msg_gps_set_global_origin_get_latitude(msg);
gps_set_global_origin->longitude = mavlink_msg_gps_set_global_origin_get_longitude(msg);
gps_set_global_origin->altitude = mavlink_msg_gps_set_global_origin_get_altitude(msg);
#else
memcpy(gps_set_global_origin, _MAV_PAYLOAD(msg), 14);
#endif
}
@@ -1,252 +0,0 @@
// MESSAGE GPS_STATUS PACKING
#define MAVLINK_MSG_ID_GPS_STATUS 27
typedef struct __mavlink_gps_status_t
{
uint8_t satellites_visible; ///< Number of satellites visible
int8_t satellite_prn[20]; ///< Global satellite ID
int8_t satellite_used[20]; ///< 0: Satellite not used, 1: used for localization
int8_t satellite_elevation[20]; ///< Elevation (0: right on top of receiver, 90: on the horizon) of satellite
int8_t satellite_azimuth[20]; ///< Direction of satellite, 0: 0 deg, 255: 360 deg.
int8_t satellite_snr[20]; ///< Signal to noise ratio of satellite
} mavlink_gps_status_t;
#define MAVLINK_MSG_ID_GPS_STATUS_LEN 101
#define MAVLINK_MSG_ID_27_LEN 101
#define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_PRN_LEN 20
#define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_USED_LEN 20
#define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_ELEVATION_LEN 20
#define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_AZIMUTH_LEN 20
#define MAVLINK_MSG_GPS_STATUS_FIELD_SATELLITE_SNR_LEN 20
#define MAVLINK_MESSAGE_INFO_GPS_STATUS { \
"GPS_STATUS", \
6, \
{ { "satellites_visible", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_gps_status_t, satellites_visible) }, \
{ "satellite_prn", NULL, MAVLINK_TYPE_INT8_T, 20, 1, offsetof(mavlink_gps_status_t, satellite_prn) }, \
{ "satellite_used", NULL, MAVLINK_TYPE_INT8_T, 20, 21, offsetof(mavlink_gps_status_t, satellite_used) }, \
{ "satellite_elevation", NULL, MAVLINK_TYPE_INT8_T, 20, 41, offsetof(mavlink_gps_status_t, satellite_elevation) }, \
{ "satellite_azimuth", NULL, MAVLINK_TYPE_INT8_T, 20, 61, offsetof(mavlink_gps_status_t, satellite_azimuth) }, \
{ "satellite_snr", NULL, MAVLINK_TYPE_INT8_T, 20, 81, offsetof(mavlink_gps_status_t, satellite_snr) }, \
} \
}
/**
* @brief Pack a gps_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param satellites_visible Number of satellites visible
* @param satellite_prn Global satellite ID
* @param satellite_used 0: Satellite not used, 1: used for localization
* @param satellite_elevation Elevation (0: right on top of receiver, 90: on the horizon) of satellite
* @param satellite_azimuth Direction of satellite, 0: 0 deg, 255: 360 deg.
* @param satellite_snr Signal to noise ratio of satellite
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t satellites_visible, const int8_t *satellite_prn, const int8_t *satellite_used, const int8_t *satellite_elevation, const int8_t *satellite_azimuth, const int8_t *satellite_snr)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[101];
_mav_put_uint8_t(buf, 0, satellites_visible);
_mav_put_int8_t_array(buf, 1, satellite_prn, 20);
_mav_put_int8_t_array(buf, 21, satellite_used, 20);
_mav_put_int8_t_array(buf, 41, satellite_elevation, 20);
_mav_put_int8_t_array(buf, 61, satellite_azimuth, 20);
_mav_put_int8_t_array(buf, 81, satellite_snr, 20);
memcpy(_MAV_PAYLOAD(msg), buf, 101);
#else
mavlink_gps_status_t packet;
packet.satellites_visible = satellites_visible;
mav_array_memcpy(packet.satellite_prn, satellite_prn, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_used, satellite_used, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_elevation, satellite_elevation, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_azimuth, satellite_azimuth, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_snr, satellite_snr, sizeof(int8_t)*20);
memcpy(_MAV_PAYLOAD(msg), &packet, 101);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_STATUS;
return mavlink_finalize_message(msg, system_id, component_id, 101);
}
/**
* @brief Pack a gps_status message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param satellites_visible Number of satellites visible
* @param satellite_prn Global satellite ID
* @param satellite_used 0: Satellite not used, 1: used for localization
* @param satellite_elevation Elevation (0: right on top of receiver, 90: on the horizon) of satellite
* @param satellite_azimuth Direction of satellite, 0: 0 deg, 255: 360 deg.
* @param satellite_snr Signal to noise ratio of satellite
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_gps_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t satellites_visible,const int8_t *satellite_prn,const int8_t *satellite_used,const int8_t *satellite_elevation,const int8_t *satellite_azimuth,const int8_t *satellite_snr)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[101];
_mav_put_uint8_t(buf, 0, satellites_visible);
_mav_put_int8_t_array(buf, 1, satellite_prn, 20);
_mav_put_int8_t_array(buf, 21, satellite_used, 20);
_mav_put_int8_t_array(buf, 41, satellite_elevation, 20);
_mav_put_int8_t_array(buf, 61, satellite_azimuth, 20);
_mav_put_int8_t_array(buf, 81, satellite_snr, 20);
memcpy(_MAV_PAYLOAD(msg), buf, 101);
#else
mavlink_gps_status_t packet;
packet.satellites_visible = satellites_visible;
mav_array_memcpy(packet.satellite_prn, satellite_prn, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_used, satellite_used, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_elevation, satellite_elevation, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_azimuth, satellite_azimuth, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_snr, satellite_snr, sizeof(int8_t)*20);
memcpy(_MAV_PAYLOAD(msg), &packet, 101);
#endif
msg->msgid = MAVLINK_MSG_ID_GPS_STATUS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 101);
}
/**
* @brief Encode a gps_status struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param gps_status C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_gps_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_gps_status_t* gps_status)
{
return mavlink_msg_gps_status_pack(system_id, component_id, msg, gps_status->satellites_visible, gps_status->satellite_prn, gps_status->satellite_used, gps_status->satellite_elevation, gps_status->satellite_azimuth, gps_status->satellite_snr);
}
/**
* @brief Send a gps_status message
* @param chan MAVLink channel to send the message
*
* @param satellites_visible Number of satellites visible
* @param satellite_prn Global satellite ID
* @param satellite_used 0: Satellite not used, 1: used for localization
* @param satellite_elevation Elevation (0: right on top of receiver, 90: on the horizon) of satellite
* @param satellite_azimuth Direction of satellite, 0: 0 deg, 255: 360 deg.
* @param satellite_snr Signal to noise ratio of satellite
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_gps_status_send(mavlink_channel_t chan, uint8_t satellites_visible, const int8_t *satellite_prn, const int8_t *satellite_used, const int8_t *satellite_elevation, const int8_t *satellite_azimuth, const int8_t *satellite_snr)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[101];
_mav_put_uint8_t(buf, 0, satellites_visible);
_mav_put_int8_t_array(buf, 1, satellite_prn, 20);
_mav_put_int8_t_array(buf, 21, satellite_used, 20);
_mav_put_int8_t_array(buf, 41, satellite_elevation, 20);
_mav_put_int8_t_array(buf, 61, satellite_azimuth, 20);
_mav_put_int8_t_array(buf, 81, satellite_snr, 20);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_STATUS, buf, 101);
#else
mavlink_gps_status_t packet;
packet.satellites_visible = satellites_visible;
mav_array_memcpy(packet.satellite_prn, satellite_prn, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_used, satellite_used, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_elevation, satellite_elevation, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_azimuth, satellite_azimuth, sizeof(int8_t)*20);
mav_array_memcpy(packet.satellite_snr, satellite_snr, sizeof(int8_t)*20);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GPS_STATUS, (const char *)&packet, 101);
#endif
}
#endif
// MESSAGE GPS_STATUS UNPACKING
/**
* @brief Get field satellites_visible from gps_status message
*
* @return Number of satellites visible
*/
static inline uint8_t mavlink_msg_gps_status_get_satellites_visible(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field satellite_prn from gps_status message
*
* @return Global satellite ID
*/
static inline uint16_t mavlink_msg_gps_status_get_satellite_prn(const mavlink_message_t* msg, int8_t *satellite_prn)
{
return _MAV_RETURN_int8_t_array(msg, satellite_prn, 20, 1);
}
/**
* @brief Get field satellite_used from gps_status message
*
* @return 0: Satellite not used, 1: used for localization
*/
static inline uint16_t mavlink_msg_gps_status_get_satellite_used(const mavlink_message_t* msg, int8_t *satellite_used)
{
return _MAV_RETURN_int8_t_array(msg, satellite_used, 20, 21);
}
/**
* @brief Get field satellite_elevation from gps_status message
*
* @return Elevation (0: right on top of receiver, 90: on the horizon) of satellite
*/
static inline uint16_t mavlink_msg_gps_status_get_satellite_elevation(const mavlink_message_t* msg, int8_t *satellite_elevation)
{
return _MAV_RETURN_int8_t_array(msg, satellite_elevation, 20, 41);
}
/**
* @brief Get field satellite_azimuth from gps_status message
*
* @return Direction of satellite, 0: 0 deg, 255: 360 deg.
*/
static inline uint16_t mavlink_msg_gps_status_get_satellite_azimuth(const mavlink_message_t* msg, int8_t *satellite_azimuth)
{
return _MAV_RETURN_int8_t_array(msg, satellite_azimuth, 20, 61);
}
/**
* @brief Get field satellite_snr from gps_status message
*
* @return Signal to noise ratio of satellite
*/
static inline uint16_t mavlink_msg_gps_status_get_satellite_snr(const mavlink_message_t* msg, int8_t *satellite_snr)
{
return _MAV_RETURN_int8_t_array(msg, satellite_snr, 20, 81);
}
/**
* @brief Decode a gps_status message into a struct
*
* @param msg The message to decode
* @param gps_status C-struct to decode the message contents into
*/
static inline void mavlink_msg_gps_status_decode(const mavlink_message_t* msg, mavlink_gps_status_t* gps_status)
{
#if MAVLINK_NEED_BYTE_SWAP
gps_status->satellites_visible = mavlink_msg_gps_status_get_satellites_visible(msg);
mavlink_msg_gps_status_get_satellite_prn(msg, gps_status->satellite_prn);
mavlink_msg_gps_status_get_satellite_used(msg, gps_status->satellite_used);
mavlink_msg_gps_status_get_satellite_elevation(msg, gps_status->satellite_elevation);
mavlink_msg_gps_status_get_satellite_azimuth(msg, gps_status->satellite_azimuth);
mavlink_msg_gps_status_get_satellite_snr(msg, gps_status->satellite_snr);
#else
memcpy(gps_status, _MAV_PAYLOAD(msg), 101);
#endif
}
@@ -1,185 +0,0 @@
// MESSAGE HEARTBEAT PACKING
#define MAVLINK_MSG_ID_HEARTBEAT 0
typedef struct __mavlink_heartbeat_t
{
uint8_t type; ///< Type of the MAV (quadrotor, helicopter, etc., up to 15 types, defined in MAV_TYPE ENUM)
uint8_t autopilot; ///< Type of the Autopilot: 0: Generic, 1: PIXHAWK, 2: SLUGS, 3: Ardupilot (up to 15 types), defined in MAV_AUTOPILOT_TYPE ENUM
uint8_t mavlink_version; ///< MAVLink version
} mavlink_heartbeat_t;
#define MAVLINK_MSG_ID_HEARTBEAT_LEN 3
#define MAVLINK_MSG_ID_0_LEN 3
#define MAVLINK_MESSAGE_INFO_HEARTBEAT { \
"HEARTBEAT", \
3, \
{ { "type", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_heartbeat_t, type) }, \
{ "autopilot", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_heartbeat_t, autopilot) }, \
{ "mavlink_version", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_heartbeat_t, mavlink_version) }, \
} \
}
/**
* @brief Pack a heartbeat message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param type Type of the MAV (quadrotor, helicopter, etc., up to 15 types, defined in MAV_TYPE ENUM)
* @param autopilot Type of the Autopilot: 0: Generic, 1: PIXHAWK, 2: SLUGS, 3: Ardupilot (up to 15 types), defined in MAV_AUTOPILOT_TYPE ENUM
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_heartbeat_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t type, uint8_t autopilot)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, type);
_mav_put_uint8_t(buf, 1, autopilot);
_mav_put_uint8_t(buf, 2, 2);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_heartbeat_t packet;
packet.type = type;
packet.autopilot = autopilot;
packet.mavlink_version = 2;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_HEARTBEAT;
return mavlink_finalize_message(msg, system_id, component_id, 3);
}
/**
* @brief Pack a heartbeat message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param type Type of the MAV (quadrotor, helicopter, etc., up to 15 types, defined in MAV_TYPE ENUM)
* @param autopilot Type of the Autopilot: 0: Generic, 1: PIXHAWK, 2: SLUGS, 3: Ardupilot (up to 15 types), defined in MAV_AUTOPILOT_TYPE ENUM
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_heartbeat_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t type,uint8_t autopilot)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, type);
_mav_put_uint8_t(buf, 1, autopilot);
_mav_put_uint8_t(buf, 2, 2);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_heartbeat_t packet;
packet.type = type;
packet.autopilot = autopilot;
packet.mavlink_version = 2;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_HEARTBEAT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 3);
}
/**
* @brief Encode a heartbeat struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param heartbeat C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_heartbeat_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_heartbeat_t* heartbeat)
{
return mavlink_msg_heartbeat_pack(system_id, component_id, msg, heartbeat->type, heartbeat->autopilot);
}
/**
* @brief Send a heartbeat message
* @param chan MAVLink channel to send the message
*
* @param type Type of the MAV (quadrotor, helicopter, etc., up to 15 types, defined in MAV_TYPE ENUM)
* @param autopilot Type of the Autopilot: 0: Generic, 1: PIXHAWK, 2: SLUGS, 3: Ardupilot (up to 15 types), defined in MAV_AUTOPILOT_TYPE ENUM
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_heartbeat_send(mavlink_channel_t chan, uint8_t type, uint8_t autopilot)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, type);
_mav_put_uint8_t(buf, 1, autopilot);
_mav_put_uint8_t(buf, 2, 2);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_HEARTBEAT, buf, 3);
#else
mavlink_heartbeat_t packet;
packet.type = type;
packet.autopilot = autopilot;
packet.mavlink_version = 2;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_HEARTBEAT, (const char *)&packet, 3);
#endif
}
#endif
// MESSAGE HEARTBEAT UNPACKING
/**
* @brief Get field type from heartbeat message
*
* @return Type of the MAV (quadrotor, helicopter, etc., up to 15 types, defined in MAV_TYPE ENUM)
*/
static inline uint8_t mavlink_msg_heartbeat_get_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field autopilot from heartbeat message
*
* @return Type of the Autopilot: 0: Generic, 1: PIXHAWK, 2: SLUGS, 3: Ardupilot (up to 15 types), defined in MAV_AUTOPILOT_TYPE ENUM
*/
static inline uint8_t mavlink_msg_heartbeat_get_autopilot(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field mavlink_version from heartbeat message
*
* @return MAVLink version
*/
static inline uint8_t mavlink_msg_heartbeat_get_mavlink_version(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Decode a heartbeat message into a struct
*
* @param msg The message to decode
* @param heartbeat C-struct to decode the message contents into
*/
static inline void mavlink_msg_heartbeat_decode(const mavlink_message_t* msg, mavlink_heartbeat_t* heartbeat)
{
#if MAVLINK_NEED_BYTE_SWAP
heartbeat->type = mavlink_msg_heartbeat_get_type(msg);
heartbeat->autopilot = mavlink_msg_heartbeat_get_autopilot(msg);
heartbeat->mavlink_version = mavlink_msg_heartbeat_get_mavlink_version(msg);
#else
memcpy(heartbeat, _MAV_PAYLOAD(msg), 3);
#endif
}
@@ -1,276 +0,0 @@
// MESSAGE HIL_CONTROLS PACKING
#define MAVLINK_MSG_ID_HIL_CONTROLS 68
typedef struct __mavlink_hil_controls_t
{
uint64_t time_us; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
float roll_ailerons; ///< Control output -3 .. 1
float pitch_elevator; ///< Control output -1 .. 1
float yaw_rudder; ///< Control output -1 .. 1
float throttle; ///< Throttle 0 .. 1
uint8_t mode; ///< System mode (MAV_MODE)
uint8_t nav_mode; ///< Navigation mode (MAV_NAV_MODE)
} mavlink_hil_controls_t;
#define MAVLINK_MSG_ID_HIL_CONTROLS_LEN 26
#define MAVLINK_MSG_ID_68_LEN 26
#define MAVLINK_MESSAGE_INFO_HIL_CONTROLS { \
"HIL_CONTROLS", \
7, \
{ { "time_us", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_hil_controls_t, time_us) }, \
{ "roll_ailerons", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_hil_controls_t, roll_ailerons) }, \
{ "pitch_elevator", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_hil_controls_t, pitch_elevator) }, \
{ "yaw_rudder", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_hil_controls_t, yaw_rudder) }, \
{ "throttle", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_hil_controls_t, throttle) }, \
{ "mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 24, offsetof(mavlink_hil_controls_t, mode) }, \
{ "nav_mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 25, offsetof(mavlink_hil_controls_t, nav_mode) }, \
} \
}
/**
* @brief Pack a hil_controls message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time_us Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll_ailerons Control output -3 .. 1
* @param pitch_elevator Control output -1 .. 1
* @param yaw_rudder Control output -1 .. 1
* @param throttle Throttle 0 .. 1
* @param mode System mode (MAV_MODE)
* @param nav_mode Navigation mode (MAV_NAV_MODE)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_hil_controls_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t time_us, float roll_ailerons, float pitch_elevator, float yaw_rudder, float throttle, uint8_t mode, uint8_t nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll_ailerons);
_mav_put_float(buf, 12, pitch_elevator);
_mav_put_float(buf, 16, yaw_rudder);
_mav_put_float(buf, 20, throttle);
_mav_put_uint8_t(buf, 24, mode);
_mav_put_uint8_t(buf, 25, nav_mode);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_hil_controls_t packet;
packet.time_us = time_us;
packet.roll_ailerons = roll_ailerons;
packet.pitch_elevator = pitch_elevator;
packet.yaw_rudder = yaw_rudder;
packet.throttle = throttle;
packet.mode = mode;
packet.nav_mode = nav_mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_HIL_CONTROLS;
return mavlink_finalize_message(msg, system_id, component_id, 26);
}
/**
* @brief Pack a hil_controls message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time_us Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll_ailerons Control output -3 .. 1
* @param pitch_elevator Control output -1 .. 1
* @param yaw_rudder Control output -1 .. 1
* @param throttle Throttle 0 .. 1
* @param mode System mode (MAV_MODE)
* @param nav_mode Navigation mode (MAV_NAV_MODE)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_hil_controls_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t time_us,float roll_ailerons,float pitch_elevator,float yaw_rudder,float throttle,uint8_t mode,uint8_t nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll_ailerons);
_mav_put_float(buf, 12, pitch_elevator);
_mav_put_float(buf, 16, yaw_rudder);
_mav_put_float(buf, 20, throttle);
_mav_put_uint8_t(buf, 24, mode);
_mav_put_uint8_t(buf, 25, nav_mode);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_hil_controls_t packet;
packet.time_us = time_us;
packet.roll_ailerons = roll_ailerons;
packet.pitch_elevator = pitch_elevator;
packet.yaw_rudder = yaw_rudder;
packet.throttle = throttle;
packet.mode = mode;
packet.nav_mode = nav_mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_HIL_CONTROLS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 26);
}
/**
* @brief Encode a hil_controls struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param hil_controls C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_hil_controls_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_hil_controls_t* hil_controls)
{
return mavlink_msg_hil_controls_pack(system_id, component_id, msg, hil_controls->time_us, hil_controls->roll_ailerons, hil_controls->pitch_elevator, hil_controls->yaw_rudder, hil_controls->throttle, hil_controls->mode, hil_controls->nav_mode);
}
/**
* @brief Send a hil_controls message
* @param chan MAVLink channel to send the message
*
* @param time_us Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll_ailerons Control output -3 .. 1
* @param pitch_elevator Control output -1 .. 1
* @param yaw_rudder Control output -1 .. 1
* @param throttle Throttle 0 .. 1
* @param mode System mode (MAV_MODE)
* @param nav_mode Navigation mode (MAV_NAV_MODE)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_hil_controls_send(mavlink_channel_t chan, uint64_t time_us, float roll_ailerons, float pitch_elevator, float yaw_rudder, float throttle, uint8_t mode, uint8_t nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll_ailerons);
_mav_put_float(buf, 12, pitch_elevator);
_mav_put_float(buf, 16, yaw_rudder);
_mav_put_float(buf, 20, throttle);
_mav_put_uint8_t(buf, 24, mode);
_mav_put_uint8_t(buf, 25, nav_mode);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_HIL_CONTROLS, buf, 26);
#else
mavlink_hil_controls_t packet;
packet.time_us = time_us;
packet.roll_ailerons = roll_ailerons;
packet.pitch_elevator = pitch_elevator;
packet.yaw_rudder = yaw_rudder;
packet.throttle = throttle;
packet.mode = mode;
packet.nav_mode = nav_mode;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_HIL_CONTROLS, (const char *)&packet, 26);
#endif
}
#endif
// MESSAGE HIL_CONTROLS UNPACKING
/**
* @brief Get field time_us from hil_controls message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_hil_controls_get_time_us(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field roll_ailerons from hil_controls message
*
* @return Control output -3 .. 1
*/
static inline float mavlink_msg_hil_controls_get_roll_ailerons(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field pitch_elevator from hil_controls message
*
* @return Control output -1 .. 1
*/
static inline float mavlink_msg_hil_controls_get_pitch_elevator(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field yaw_rudder from hil_controls message
*
* @return Control output -1 .. 1
*/
static inline float mavlink_msg_hil_controls_get_yaw_rudder(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field throttle from hil_controls message
*
* @return Throttle 0 .. 1
*/
static inline float mavlink_msg_hil_controls_get_throttle(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field mode from hil_controls message
*
* @return System mode (MAV_MODE)
*/
static inline uint8_t mavlink_msg_hil_controls_get_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 24);
}
/**
* @brief Get field nav_mode from hil_controls message
*
* @return Navigation mode (MAV_NAV_MODE)
*/
static inline uint8_t mavlink_msg_hil_controls_get_nav_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 25);
}
/**
* @brief Decode a hil_controls message into a struct
*
* @param msg The message to decode
* @param hil_controls C-struct to decode the message contents into
*/
static inline void mavlink_msg_hil_controls_decode(const mavlink_message_t* msg, mavlink_hil_controls_t* hil_controls)
{
#if MAVLINK_NEED_BYTE_SWAP
hil_controls->time_us = mavlink_msg_hil_controls_get_time_us(msg);
hil_controls->roll_ailerons = mavlink_msg_hil_controls_get_roll_ailerons(msg);
hil_controls->pitch_elevator = mavlink_msg_hil_controls_get_pitch_elevator(msg);
hil_controls->yaw_rudder = mavlink_msg_hil_controls_get_yaw_rudder(msg);
hil_controls->throttle = mavlink_msg_hil_controls_get_throttle(msg);
hil_controls->mode = mavlink_msg_hil_controls_get_mode(msg);
hil_controls->nav_mode = mavlink_msg_hil_controls_get_nav_mode(msg);
#else
memcpy(hil_controls, _MAV_PAYLOAD(msg), 26);
#endif
}
@@ -1,474 +0,0 @@
// MESSAGE HIL_STATE PACKING
#define MAVLINK_MSG_ID_HIL_STATE 67
typedef struct __mavlink_hil_state_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
float roll; ///< Roll angle (rad)
float pitch; ///< Pitch angle (rad)
float yaw; ///< Yaw angle (rad)
float rollspeed; ///< Roll angular speed (rad/s)
float pitchspeed; ///< Pitch angular speed (rad/s)
float yawspeed; ///< Yaw angular speed (rad/s)
int32_t lat; ///< Latitude, expressed as * 1E7
int32_t lon; ///< Longitude, expressed as * 1E7
int32_t alt; ///< Altitude in meters, expressed as * 1000 (millimeters)
int16_t vx; ///< Ground X Speed (Latitude), expressed as m/s * 100
int16_t vy; ///< Ground Y Speed (Longitude), expressed as m/s * 100
int16_t vz; ///< Ground Z Speed (Altitude), expressed as m/s * 100
int16_t xacc; ///< X acceleration (mg)
int16_t yacc; ///< Y acceleration (mg)
int16_t zacc; ///< Z acceleration (mg)
} mavlink_hil_state_t;
#define MAVLINK_MSG_ID_HIL_STATE_LEN 56
#define MAVLINK_MSG_ID_67_LEN 56
#define MAVLINK_MESSAGE_INFO_HIL_STATE { \
"HIL_STATE", \
16, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_hil_state_t, usec) }, \
{ "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_hil_state_t, roll) }, \
{ "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_hil_state_t, pitch) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_hil_state_t, yaw) }, \
{ "rollspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_hil_state_t, rollspeed) }, \
{ "pitchspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_hil_state_t, pitchspeed) }, \
{ "yawspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_hil_state_t, yawspeed) }, \
{ "lat", NULL, MAVLINK_TYPE_INT32_T, 0, 32, offsetof(mavlink_hil_state_t, lat) }, \
{ "lon", NULL, MAVLINK_TYPE_INT32_T, 0, 36, offsetof(mavlink_hil_state_t, lon) }, \
{ "alt", NULL, MAVLINK_TYPE_INT32_T, 0, 40, offsetof(mavlink_hil_state_t, alt) }, \
{ "vx", NULL, MAVLINK_TYPE_INT16_T, 0, 44, offsetof(mavlink_hil_state_t, vx) }, \
{ "vy", NULL, MAVLINK_TYPE_INT16_T, 0, 46, offsetof(mavlink_hil_state_t, vy) }, \
{ "vz", NULL, MAVLINK_TYPE_INT16_T, 0, 48, offsetof(mavlink_hil_state_t, vz) }, \
{ "xacc", NULL, MAVLINK_TYPE_INT16_T, 0, 50, offsetof(mavlink_hil_state_t, xacc) }, \
{ "yacc", NULL, MAVLINK_TYPE_INT16_T, 0, 52, offsetof(mavlink_hil_state_t, yacc) }, \
{ "zacc", NULL, MAVLINK_TYPE_INT16_T, 0, 54, offsetof(mavlink_hil_state_t, zacc) }, \
} \
}
/**
* @brief Pack a hil_state message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll Roll angle (rad)
* @param pitch Pitch angle (rad)
* @param yaw Yaw angle (rad)
* @param rollspeed Roll angular speed (rad/s)
* @param pitchspeed Pitch angular speed (rad/s)
* @param yawspeed Yaw angular speed (rad/s)
* @param lat Latitude, expressed as * 1E7
* @param lon Longitude, expressed as * 1E7
* @param alt Altitude in meters, expressed as * 1000 (millimeters)
* @param vx Ground X Speed (Latitude), expressed as m/s * 100
* @param vy Ground Y Speed (Longitude), expressed as m/s * 100
* @param vz Ground Z Speed (Altitude), expressed as m/s * 100
* @param xacc X acceleration (mg)
* @param yacc Y acceleration (mg)
* @param zacc Z acceleration (mg)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_hil_state_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, float roll, float pitch, float yaw, float rollspeed, float pitchspeed, float yawspeed, int32_t lat, int32_t lon, int32_t alt, int16_t vx, int16_t vy, int16_t vz, int16_t xacc, int16_t yacc, int16_t zacc)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[56];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, rollspeed);
_mav_put_float(buf, 24, pitchspeed);
_mav_put_float(buf, 28, yawspeed);
_mav_put_int32_t(buf, 32, lat);
_mav_put_int32_t(buf, 36, lon);
_mav_put_int32_t(buf, 40, alt);
_mav_put_int16_t(buf, 44, vx);
_mav_put_int16_t(buf, 46, vy);
_mav_put_int16_t(buf, 48, vz);
_mav_put_int16_t(buf, 50, xacc);
_mav_put_int16_t(buf, 52, yacc);
_mav_put_int16_t(buf, 54, zacc);
memcpy(_MAV_PAYLOAD(msg), buf, 56);
#else
mavlink_hil_state_t packet;
packet.usec = usec;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.rollspeed = rollspeed;
packet.pitchspeed = pitchspeed;
packet.yawspeed = yawspeed;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
memcpy(_MAV_PAYLOAD(msg), &packet, 56);
#endif
msg->msgid = MAVLINK_MSG_ID_HIL_STATE;
return mavlink_finalize_message(msg, system_id, component_id, 56);
}
/**
* @brief Pack a hil_state message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll Roll angle (rad)
* @param pitch Pitch angle (rad)
* @param yaw Yaw angle (rad)
* @param rollspeed Roll angular speed (rad/s)
* @param pitchspeed Pitch angular speed (rad/s)
* @param yawspeed Yaw angular speed (rad/s)
* @param lat Latitude, expressed as * 1E7
* @param lon Longitude, expressed as * 1E7
* @param alt Altitude in meters, expressed as * 1000 (millimeters)
* @param vx Ground X Speed (Latitude), expressed as m/s * 100
* @param vy Ground Y Speed (Longitude), expressed as m/s * 100
* @param vz Ground Z Speed (Altitude), expressed as m/s * 100
* @param xacc X acceleration (mg)
* @param yacc Y acceleration (mg)
* @param zacc Z acceleration (mg)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_hil_state_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,float roll,float pitch,float yaw,float rollspeed,float pitchspeed,float yawspeed,int32_t lat,int32_t lon,int32_t alt,int16_t vx,int16_t vy,int16_t vz,int16_t xacc,int16_t yacc,int16_t zacc)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[56];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, rollspeed);
_mav_put_float(buf, 24, pitchspeed);
_mav_put_float(buf, 28, yawspeed);
_mav_put_int32_t(buf, 32, lat);
_mav_put_int32_t(buf, 36, lon);
_mav_put_int32_t(buf, 40, alt);
_mav_put_int16_t(buf, 44, vx);
_mav_put_int16_t(buf, 46, vy);
_mav_put_int16_t(buf, 48, vz);
_mav_put_int16_t(buf, 50, xacc);
_mav_put_int16_t(buf, 52, yacc);
_mav_put_int16_t(buf, 54, zacc);
memcpy(_MAV_PAYLOAD(msg), buf, 56);
#else
mavlink_hil_state_t packet;
packet.usec = usec;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.rollspeed = rollspeed;
packet.pitchspeed = pitchspeed;
packet.yawspeed = yawspeed;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
memcpy(_MAV_PAYLOAD(msg), &packet, 56);
#endif
msg->msgid = MAVLINK_MSG_ID_HIL_STATE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 56);
}
/**
* @brief Encode a hil_state struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param hil_state C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_hil_state_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_hil_state_t* hil_state)
{
return mavlink_msg_hil_state_pack(system_id, component_id, msg, hil_state->usec, hil_state->roll, hil_state->pitch, hil_state->yaw, hil_state->rollspeed, hil_state->pitchspeed, hil_state->yawspeed, hil_state->lat, hil_state->lon, hil_state->alt, hil_state->vx, hil_state->vy, hil_state->vz, hil_state->xacc, hil_state->yacc, hil_state->zacc);
}
/**
* @brief Send a hil_state message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param roll Roll angle (rad)
* @param pitch Pitch angle (rad)
* @param yaw Yaw angle (rad)
* @param rollspeed Roll angular speed (rad/s)
* @param pitchspeed Pitch angular speed (rad/s)
* @param yawspeed Yaw angular speed (rad/s)
* @param lat Latitude, expressed as * 1E7
* @param lon Longitude, expressed as * 1E7
* @param alt Altitude in meters, expressed as * 1000 (millimeters)
* @param vx Ground X Speed (Latitude), expressed as m/s * 100
* @param vy Ground Y Speed (Longitude), expressed as m/s * 100
* @param vz Ground Z Speed (Altitude), expressed as m/s * 100
* @param xacc X acceleration (mg)
* @param yacc Y acceleration (mg)
* @param zacc Z acceleration (mg)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_hil_state_send(mavlink_channel_t chan, uint64_t usec, float roll, float pitch, float yaw, float rollspeed, float pitchspeed, float yawspeed, int32_t lat, int32_t lon, int32_t alt, int16_t vx, int16_t vy, int16_t vz, int16_t xacc, int16_t yacc, int16_t zacc)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[56];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, rollspeed);
_mav_put_float(buf, 24, pitchspeed);
_mav_put_float(buf, 28, yawspeed);
_mav_put_int32_t(buf, 32, lat);
_mav_put_int32_t(buf, 36, lon);
_mav_put_int32_t(buf, 40, alt);
_mav_put_int16_t(buf, 44, vx);
_mav_put_int16_t(buf, 46, vy);
_mav_put_int16_t(buf, 48, vz);
_mav_put_int16_t(buf, 50, xacc);
_mav_put_int16_t(buf, 52, yacc);
_mav_put_int16_t(buf, 54, zacc);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_HIL_STATE, buf, 56);
#else
mavlink_hil_state_t packet;
packet.usec = usec;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.rollspeed = rollspeed;
packet.pitchspeed = pitchspeed;
packet.yawspeed = yawspeed;
packet.lat = lat;
packet.lon = lon;
packet.alt = alt;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_HIL_STATE, (const char *)&packet, 56);
#endif
}
#endif
// MESSAGE HIL_STATE UNPACKING
/**
* @brief Get field usec from hil_state message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_hil_state_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field roll from hil_state message
*
* @return Roll angle (rad)
*/
static inline float mavlink_msg_hil_state_get_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field pitch from hil_state message
*
* @return Pitch angle (rad)
*/
static inline float mavlink_msg_hil_state_get_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field yaw from hil_state message
*
* @return Yaw angle (rad)
*/
static inline float mavlink_msg_hil_state_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field rollspeed from hil_state message
*
* @return Roll angular speed (rad/s)
*/
static inline float mavlink_msg_hil_state_get_rollspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field pitchspeed from hil_state message
*
* @return Pitch angular speed (rad/s)
*/
static inline float mavlink_msg_hil_state_get_pitchspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 24);
}
/**
* @brief Get field yawspeed from hil_state message
*
* @return Yaw angular speed (rad/s)
*/
static inline float mavlink_msg_hil_state_get_yawspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Get field lat from hil_state message
*
* @return Latitude, expressed as * 1E7
*/
static inline int32_t mavlink_msg_hil_state_get_lat(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 32);
}
/**
* @brief Get field lon from hil_state message
*
* @return Longitude, expressed as * 1E7
*/
static inline int32_t mavlink_msg_hil_state_get_lon(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 36);
}
/**
* @brief Get field alt from hil_state message
*
* @return Altitude in meters, expressed as * 1000 (millimeters)
*/
static inline int32_t mavlink_msg_hil_state_get_alt(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 40);
}
/**
* @brief Get field vx from hil_state message
*
* @return Ground X Speed (Latitude), expressed as m/s * 100
*/
static inline int16_t mavlink_msg_hil_state_get_vx(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 44);
}
/**
* @brief Get field vy from hil_state message
*
* @return Ground Y Speed (Longitude), expressed as m/s * 100
*/
static inline int16_t mavlink_msg_hil_state_get_vy(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 46);
}
/**
* @brief Get field vz from hil_state message
*
* @return Ground Z Speed (Altitude), expressed as m/s * 100
*/
static inline int16_t mavlink_msg_hil_state_get_vz(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 48);
}
/**
* @brief Get field xacc from hil_state message
*
* @return X acceleration (mg)
*/
static inline int16_t mavlink_msg_hil_state_get_xacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 50);
}
/**
* @brief Get field yacc from hil_state message
*
* @return Y acceleration (mg)
*/
static inline int16_t mavlink_msg_hil_state_get_yacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 52);
}
/**
* @brief Get field zacc from hil_state message
*
* @return Z acceleration (mg)
*/
static inline int16_t mavlink_msg_hil_state_get_zacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 54);
}
/**
* @brief Decode a hil_state message into a struct
*
* @param msg The message to decode
* @param hil_state C-struct to decode the message contents into
*/
static inline void mavlink_msg_hil_state_decode(const mavlink_message_t* msg, mavlink_hil_state_t* hil_state)
{
#if MAVLINK_NEED_BYTE_SWAP
hil_state->usec = mavlink_msg_hil_state_get_usec(msg);
hil_state->roll = mavlink_msg_hil_state_get_roll(msg);
hil_state->pitch = mavlink_msg_hil_state_get_pitch(msg);
hil_state->yaw = mavlink_msg_hil_state_get_yaw(msg);
hil_state->rollspeed = mavlink_msg_hil_state_get_rollspeed(msg);
hil_state->pitchspeed = mavlink_msg_hil_state_get_pitchspeed(msg);
hil_state->yawspeed = mavlink_msg_hil_state_get_yawspeed(msg);
hil_state->lat = mavlink_msg_hil_state_get_lat(msg);
hil_state->lon = mavlink_msg_hil_state_get_lon(msg);
hil_state->alt = mavlink_msg_hil_state_get_alt(msg);
hil_state->vx = mavlink_msg_hil_state_get_vx(msg);
hil_state->vy = mavlink_msg_hil_state_get_vy(msg);
hil_state->vz = mavlink_msg_hil_state_get_vz(msg);
hil_state->xacc = mavlink_msg_hil_state_get_xacc(msg);
hil_state->yacc = mavlink_msg_hil_state_get_yacc(msg);
hil_state->zacc = mavlink_msg_hil_state_get_zacc(msg);
#else
memcpy(hil_state, _MAV_PAYLOAD(msg), 56);
#endif
}
@@ -1,276 +0,0 @@
// MESSAGE LOCAL_POSITION PACKING
#define MAVLINK_MSG_ID_LOCAL_POSITION 31
typedef struct __mavlink_local_position_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
float x; ///< X Position
float y; ///< Y Position
float z; ///< Z Position
float vx; ///< X Speed
float vy; ///< Y Speed
float vz; ///< Z Speed
} mavlink_local_position_t;
#define MAVLINK_MSG_ID_LOCAL_POSITION_LEN 32
#define MAVLINK_MSG_ID_31_LEN 32
#define MAVLINK_MESSAGE_INFO_LOCAL_POSITION { \
"LOCAL_POSITION", \
7, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_local_position_t, usec) }, \
{ "x", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_local_position_t, x) }, \
{ "y", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_local_position_t, y) }, \
{ "z", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_local_position_t, z) }, \
{ "vx", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_local_position_t, vx) }, \
{ "vy", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_local_position_t, vy) }, \
{ "vz", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_local_position_t, vz) }, \
} \
}
/**
* @brief Pack a local_position message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param x X Position
* @param y Y Position
* @param z Z Position
* @param vx X Speed
* @param vy Y Speed
* @param vz Z Speed
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_local_position_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, float x, float y, float z, float vx, float vy, float vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, x);
_mav_put_float(buf, 12, y);
_mav_put_float(buf, 16, z);
_mav_put_float(buf, 20, vx);
_mav_put_float(buf, 24, vy);
_mav_put_float(buf, 28, vz);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_local_position_t packet;
packet.usec = usec;
packet.x = x;
packet.y = y;
packet.z = z;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_LOCAL_POSITION;
return mavlink_finalize_message(msg, system_id, component_id, 32);
}
/**
* @brief Pack a local_position message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param x X Position
* @param y Y Position
* @param z Z Position
* @param vx X Speed
* @param vy Y Speed
* @param vz Z Speed
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_local_position_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,float x,float y,float z,float vx,float vy,float vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, x);
_mav_put_float(buf, 12, y);
_mav_put_float(buf, 16, z);
_mav_put_float(buf, 20, vx);
_mav_put_float(buf, 24, vy);
_mav_put_float(buf, 28, vz);
memcpy(_MAV_PAYLOAD(msg), buf, 32);
#else
mavlink_local_position_t packet;
packet.usec = usec;
packet.x = x;
packet.y = y;
packet.z = z;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
memcpy(_MAV_PAYLOAD(msg), &packet, 32);
#endif
msg->msgid = MAVLINK_MSG_ID_LOCAL_POSITION;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 32);
}
/**
* @brief Encode a local_position struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param local_position C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_local_position_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_local_position_t* local_position)
{
return mavlink_msg_local_position_pack(system_id, component_id, msg, local_position->usec, local_position->x, local_position->y, local_position->z, local_position->vx, local_position->vy, local_position->vz);
}
/**
* @brief Send a local_position message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param x X Position
* @param y Y Position
* @param z Z Position
* @param vx X Speed
* @param vy Y Speed
* @param vz Z Speed
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_local_position_send(mavlink_channel_t chan, uint64_t usec, float x, float y, float z, float vx, float vy, float vz)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[32];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, x);
_mav_put_float(buf, 12, y);
_mav_put_float(buf, 16, z);
_mav_put_float(buf, 20, vx);
_mav_put_float(buf, 24, vy);
_mav_put_float(buf, 28, vz);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_LOCAL_POSITION, buf, 32);
#else
mavlink_local_position_t packet;
packet.usec = usec;
packet.x = x;
packet.y = y;
packet.z = z;
packet.vx = vx;
packet.vy = vy;
packet.vz = vz;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_LOCAL_POSITION, (const char *)&packet, 32);
#endif
}
#endif
// MESSAGE LOCAL_POSITION UNPACKING
/**
* @brief Get field usec from local_position message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_local_position_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field x from local_position message
*
* @return X Position
*/
static inline float mavlink_msg_local_position_get_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field y from local_position message
*
* @return Y Position
*/
static inline float mavlink_msg_local_position_get_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field z from local_position message
*
* @return Z Position
*/
static inline float mavlink_msg_local_position_get_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field vx from local_position message
*
* @return X Speed
*/
static inline float mavlink_msg_local_position_get_vx(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field vy from local_position message
*
* @return Y Speed
*/
static inline float mavlink_msg_local_position_get_vy(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 24);
}
/**
* @brief Get field vz from local_position message
*
* @return Z Speed
*/
static inline float mavlink_msg_local_position_get_vz(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Decode a local_position message into a struct
*
* @param msg The message to decode
* @param local_position C-struct to decode the message contents into
*/
static inline void mavlink_msg_local_position_decode(const mavlink_message_t* msg, mavlink_local_position_t* local_position)
{
#if MAVLINK_NEED_BYTE_SWAP
local_position->usec = mavlink_msg_local_position_get_usec(msg);
local_position->x = mavlink_msg_local_position_get_x(msg);
local_position->y = mavlink_msg_local_position_get_y(msg);
local_position->z = mavlink_msg_local_position_get_z(msg);
local_position->vx = mavlink_msg_local_position_get_vx(msg);
local_position->vy = mavlink_msg_local_position_get_vy(msg);
local_position->vz = mavlink_msg_local_position_get_vz(msg);
#else
memcpy(local_position, _MAV_PAYLOAD(msg), 32);
#endif
}
@@ -1,210 +0,0 @@
// MESSAGE LOCAL_POSITION_SETPOINT PACKING
#define MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT 51
typedef struct __mavlink_local_position_setpoint_t
{
float x; ///< x position
float y; ///< y position
float z; ///< z position
float yaw; ///< Desired yaw angle
} mavlink_local_position_setpoint_t;
#define MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_LEN 16
#define MAVLINK_MSG_ID_51_LEN 16
#define MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT { \
"LOCAL_POSITION_SETPOINT", \
4, \
{ { "x", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_local_position_setpoint_t, x) }, \
{ "y", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_local_position_setpoint_t, y) }, \
{ "z", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_local_position_setpoint_t, z) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_local_position_setpoint_t, yaw) }, \
} \
}
/**
* @brief Pack a local_position_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param x x position
* @param y y position
* @param z z position
* @param yaw Desired yaw angle
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_local_position_setpoint_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
float x, float y, float z, float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_float(buf, 0, x);
_mav_put_float(buf, 4, y);
_mav_put_float(buf, 8, z);
_mav_put_float(buf, 12, yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_local_position_setpoint_t packet;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT;
return mavlink_finalize_message(msg, system_id, component_id, 16);
}
/**
* @brief Pack a local_position_setpoint message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param x x position
* @param y y position
* @param z z position
* @param yaw Desired yaw angle
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_local_position_setpoint_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
float x,float y,float z,float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_float(buf, 0, x);
_mav_put_float(buf, 4, y);
_mav_put_float(buf, 8, z);
_mav_put_float(buf, 12, yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_local_position_setpoint_t packet;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 16);
}
/**
* @brief Encode a local_position_setpoint struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param local_position_setpoint C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_local_position_setpoint_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_local_position_setpoint_t* local_position_setpoint)
{
return mavlink_msg_local_position_setpoint_pack(system_id, component_id, msg, local_position_setpoint->x, local_position_setpoint->y, local_position_setpoint->z, local_position_setpoint->yaw);
}
/**
* @brief Send a local_position_setpoint message
* @param chan MAVLink channel to send the message
*
* @param x x position
* @param y y position
* @param z z position
* @param yaw Desired yaw angle
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_local_position_setpoint_send(mavlink_channel_t chan, float x, float y, float z, float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_float(buf, 0, x);
_mav_put_float(buf, 4, y);
_mav_put_float(buf, 8, z);
_mav_put_float(buf, 12, yaw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT, buf, 16);
#else
mavlink_local_position_setpoint_t packet;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT, (const char *)&packet, 16);
#endif
}
#endif
// MESSAGE LOCAL_POSITION_SETPOINT UNPACKING
/**
* @brief Get field x from local_position_setpoint message
*
* @return x position
*/
static inline float mavlink_msg_local_position_setpoint_get_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field y from local_position_setpoint message
*
* @return y position
*/
static inline float mavlink_msg_local_position_setpoint_get_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field z from local_position_setpoint message
*
* @return z position
*/
static inline float mavlink_msg_local_position_setpoint_get_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field yaw from local_position_setpoint message
*
* @return Desired yaw angle
*/
static inline float mavlink_msg_local_position_setpoint_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Decode a local_position_setpoint message into a struct
*
* @param msg The message to decode
* @param local_position_setpoint C-struct to decode the message contents into
*/
static inline void mavlink_msg_local_position_setpoint_decode(const mavlink_message_t* msg, mavlink_local_position_setpoint_t* local_position_setpoint)
{
#if MAVLINK_NEED_BYTE_SWAP
local_position_setpoint->x = mavlink_msg_local_position_setpoint_get_x(msg);
local_position_setpoint->y = mavlink_msg_local_position_setpoint_get_y(msg);
local_position_setpoint->z = mavlink_msg_local_position_setpoint_get_z(msg);
local_position_setpoint->yaw = mavlink_msg_local_position_setpoint_get_yaw(msg);
#else
memcpy(local_position_setpoint, _MAV_PAYLOAD(msg), 16);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE LOCAL_POSITION_SETPOINT_SET PACKING
#define MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_SET 50
typedef struct __mavlink_local_position_setpoint_set_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
float x; ///< x position
float y; ///< y position
float z; ///< z position
float yaw; ///< Desired yaw angle
} mavlink_local_position_setpoint_set_t;
#define MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_SET_LEN 18
#define MAVLINK_MSG_ID_50_LEN 18
#define MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT_SET { \
"LOCAL_POSITION_SETPOINT_SET", \
6, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_local_position_setpoint_set_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_local_position_setpoint_set_t, target_component) }, \
{ "x", NULL, MAVLINK_TYPE_FLOAT, 0, 2, offsetof(mavlink_local_position_setpoint_set_t, x) }, \
{ "y", NULL, MAVLINK_TYPE_FLOAT, 0, 6, offsetof(mavlink_local_position_setpoint_set_t, y) }, \
{ "z", NULL, MAVLINK_TYPE_FLOAT, 0, 10, offsetof(mavlink_local_position_setpoint_set_t, z) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 14, offsetof(mavlink_local_position_setpoint_set_t, yaw) }, \
} \
}
/**
* @brief Pack a local_position_setpoint_set message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param x x position
* @param y y position
* @param z z position
* @param yaw Desired yaw angle
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_local_position_setpoint_set_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, float x, float y, float z, float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, x);
_mav_put_float(buf, 6, y);
_mav_put_float(buf, 10, z);
_mav_put_float(buf, 14, yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_local_position_setpoint_set_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_SET;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a local_position_setpoint_set message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param x x position
* @param y y position
* @param z z position
* @param yaw Desired yaw angle
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_local_position_setpoint_set_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,float x,float y,float z,float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, x);
_mav_put_float(buf, 6, y);
_mav_put_float(buf, 10, z);
_mav_put_float(buf, 14, yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_local_position_setpoint_set_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_SET;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a local_position_setpoint_set struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param local_position_setpoint_set C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_local_position_setpoint_set_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_local_position_setpoint_set_t* local_position_setpoint_set)
{
return mavlink_msg_local_position_setpoint_set_pack(system_id, component_id, msg, local_position_setpoint_set->target_system, local_position_setpoint_set->target_component, local_position_setpoint_set->x, local_position_setpoint_set->y, local_position_setpoint_set->z, local_position_setpoint_set->yaw);
}
/**
* @brief Send a local_position_setpoint_set message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param x x position
* @param y y position
* @param z z position
* @param yaw Desired yaw angle
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_local_position_setpoint_set_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, float x, float y, float z, float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, x);
_mav_put_float(buf, 6, y);
_mav_put_float(buf, 10, z);
_mav_put_float(buf, 14, yaw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_SET, buf, 18);
#else
mavlink_local_position_setpoint_set_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_LOCAL_POSITION_SETPOINT_SET, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE LOCAL_POSITION_SETPOINT_SET UNPACKING
/**
* @brief Get field target_system from local_position_setpoint_set message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_local_position_setpoint_set_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from local_position_setpoint_set message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_local_position_setpoint_set_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field x from local_position_setpoint_set message
*
* @return x position
*/
static inline float mavlink_msg_local_position_setpoint_set_get_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 2);
}
/**
* @brief Get field y from local_position_setpoint_set message
*
* @return y position
*/
static inline float mavlink_msg_local_position_setpoint_set_get_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 6);
}
/**
* @brief Get field z from local_position_setpoint_set message
*
* @return z position
*/
static inline float mavlink_msg_local_position_setpoint_set_get_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 10);
}
/**
* @brief Get field yaw from local_position_setpoint_set message
*
* @return Desired yaw angle
*/
static inline float mavlink_msg_local_position_setpoint_set_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 14);
}
/**
* @brief Decode a local_position_setpoint_set message into a struct
*
* @param msg The message to decode
* @param local_position_setpoint_set C-struct to decode the message contents into
*/
static inline void mavlink_msg_local_position_setpoint_set_decode(const mavlink_message_t* msg, mavlink_local_position_setpoint_set_t* local_position_setpoint_set)
{
#if MAVLINK_NEED_BYTE_SWAP
local_position_setpoint_set->target_system = mavlink_msg_local_position_setpoint_set_get_target_system(msg);
local_position_setpoint_set->target_component = mavlink_msg_local_position_setpoint_set_get_target_component(msg);
local_position_setpoint_set->x = mavlink_msg_local_position_setpoint_set_get_x(msg);
local_position_setpoint_set->y = mavlink_msg_local_position_setpoint_set_get_y(msg);
local_position_setpoint_set->z = mavlink_msg_local_position_setpoint_set_get_z(msg);
local_position_setpoint_set->yaw = mavlink_msg_local_position_setpoint_set_get_yaw(msg);
#else
memcpy(local_position_setpoint_set, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE MANUAL_CONTROL PACKING
#define MAVLINK_MSG_ID_MANUAL_CONTROL 69
typedef struct __mavlink_manual_control_t
{
uint8_t target; ///< The system to be controlled
float roll; ///< roll
float pitch; ///< pitch
float yaw; ///< yaw
float thrust; ///< thrust
uint8_t roll_manual; ///< roll control enabled auto:0, manual:1
uint8_t pitch_manual; ///< pitch auto:0, manual:1
uint8_t yaw_manual; ///< yaw auto:0, manual:1
uint8_t thrust_manual; ///< thrust auto:0, manual:1
} mavlink_manual_control_t;
#define MAVLINK_MSG_ID_MANUAL_CONTROL_LEN 21
#define MAVLINK_MSG_ID_69_LEN 21
#define MAVLINK_MESSAGE_INFO_MANUAL_CONTROL { \
"MANUAL_CONTROL", \
9, \
{ { "target", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_manual_control_t, target) }, \
{ "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 1, offsetof(mavlink_manual_control_t, roll) }, \
{ "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 5, offsetof(mavlink_manual_control_t, pitch) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 9, offsetof(mavlink_manual_control_t, yaw) }, \
{ "thrust", NULL, MAVLINK_TYPE_FLOAT, 0, 13, offsetof(mavlink_manual_control_t, thrust) }, \
{ "roll_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 17, offsetof(mavlink_manual_control_t, roll_manual) }, \
{ "pitch_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 18, offsetof(mavlink_manual_control_t, pitch_manual) }, \
{ "yaw_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 19, offsetof(mavlink_manual_control_t, yaw_manual) }, \
{ "thrust_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 20, offsetof(mavlink_manual_control_t, thrust_manual) }, \
} \
}
/**
* @brief Pack a manual_control message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target The system to be controlled
* @param roll roll
* @param pitch pitch
* @param yaw yaw
* @param thrust thrust
* @param roll_manual roll control enabled auto:0, manual:1
* @param pitch_manual pitch auto:0, manual:1
* @param yaw_manual yaw auto:0, manual:1
* @param thrust_manual thrust auto:0, manual:1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_manual_control_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target, float roll, float pitch, float yaw, float thrust, uint8_t roll_manual, uint8_t pitch_manual, uint8_t yaw_manual, uint8_t thrust_manual)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_uint8_t(buf, 0, target);
_mav_put_float(buf, 1, roll);
_mav_put_float(buf, 5, pitch);
_mav_put_float(buf, 9, yaw);
_mav_put_float(buf, 13, thrust);
_mav_put_uint8_t(buf, 17, roll_manual);
_mav_put_uint8_t(buf, 18, pitch_manual);
_mav_put_uint8_t(buf, 19, yaw_manual);
_mav_put_uint8_t(buf, 20, thrust_manual);
memcpy(_MAV_PAYLOAD(msg), buf, 21);
#else
mavlink_manual_control_t packet;
packet.target = target;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
packet.roll_manual = roll_manual;
packet.pitch_manual = pitch_manual;
packet.yaw_manual = yaw_manual;
packet.thrust_manual = thrust_manual;
memcpy(_MAV_PAYLOAD(msg), &packet, 21);
#endif
msg->msgid = MAVLINK_MSG_ID_MANUAL_CONTROL;
return mavlink_finalize_message(msg, system_id, component_id, 21);
}
/**
* @brief Pack a manual_control message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target The system to be controlled
* @param roll roll
* @param pitch pitch
* @param yaw yaw
* @param thrust thrust
* @param roll_manual roll control enabled auto:0, manual:1
* @param pitch_manual pitch auto:0, manual:1
* @param yaw_manual yaw auto:0, manual:1
* @param thrust_manual thrust auto:0, manual:1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_manual_control_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target,float roll,float pitch,float yaw,float thrust,uint8_t roll_manual,uint8_t pitch_manual,uint8_t yaw_manual,uint8_t thrust_manual)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_uint8_t(buf, 0, target);
_mav_put_float(buf, 1, roll);
_mav_put_float(buf, 5, pitch);
_mav_put_float(buf, 9, yaw);
_mav_put_float(buf, 13, thrust);
_mav_put_uint8_t(buf, 17, roll_manual);
_mav_put_uint8_t(buf, 18, pitch_manual);
_mav_put_uint8_t(buf, 19, yaw_manual);
_mav_put_uint8_t(buf, 20, thrust_manual);
memcpy(_MAV_PAYLOAD(msg), buf, 21);
#else
mavlink_manual_control_t packet;
packet.target = target;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
packet.roll_manual = roll_manual;
packet.pitch_manual = pitch_manual;
packet.yaw_manual = yaw_manual;
packet.thrust_manual = thrust_manual;
memcpy(_MAV_PAYLOAD(msg), &packet, 21);
#endif
msg->msgid = MAVLINK_MSG_ID_MANUAL_CONTROL;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 21);
}
/**
* @brief Encode a manual_control struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param manual_control C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_manual_control_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_manual_control_t* manual_control)
{
return mavlink_msg_manual_control_pack(system_id, component_id, msg, manual_control->target, manual_control->roll, manual_control->pitch, manual_control->yaw, manual_control->thrust, manual_control->roll_manual, manual_control->pitch_manual, manual_control->yaw_manual, manual_control->thrust_manual);
}
/**
* @brief Send a manual_control message
* @param chan MAVLink channel to send the message
*
* @param target The system to be controlled
* @param roll roll
* @param pitch pitch
* @param yaw yaw
* @param thrust thrust
* @param roll_manual roll control enabled auto:0, manual:1
* @param pitch_manual pitch auto:0, manual:1
* @param yaw_manual yaw auto:0, manual:1
* @param thrust_manual thrust auto:0, manual:1
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_manual_control_send(mavlink_channel_t chan, uint8_t target, float roll, float pitch, float yaw, float thrust, uint8_t roll_manual, uint8_t pitch_manual, uint8_t yaw_manual, uint8_t thrust_manual)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_uint8_t(buf, 0, target);
_mav_put_float(buf, 1, roll);
_mav_put_float(buf, 5, pitch);
_mav_put_float(buf, 9, yaw);
_mav_put_float(buf, 13, thrust);
_mav_put_uint8_t(buf, 17, roll_manual);
_mav_put_uint8_t(buf, 18, pitch_manual);
_mav_put_uint8_t(buf, 19, yaw_manual);
_mav_put_uint8_t(buf, 20, thrust_manual);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MANUAL_CONTROL, buf, 21);
#else
mavlink_manual_control_t packet;
packet.target = target;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
packet.roll_manual = roll_manual;
packet.pitch_manual = pitch_manual;
packet.yaw_manual = yaw_manual;
packet.thrust_manual = thrust_manual;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MANUAL_CONTROL, (const char *)&packet, 21);
#endif
}
#endif
// MESSAGE MANUAL_CONTROL UNPACKING
/**
* @brief Get field target from manual_control message
*
* @return The system to be controlled
*/
static inline uint8_t mavlink_msg_manual_control_get_target(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field roll from manual_control message
*
* @return roll
*/
static inline float mavlink_msg_manual_control_get_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 1);
}
/**
* @brief Get field pitch from manual_control message
*
* @return pitch
*/
static inline float mavlink_msg_manual_control_get_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 5);
}
/**
* @brief Get field yaw from manual_control message
*
* @return yaw
*/
static inline float mavlink_msg_manual_control_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 9);
}
/**
* @brief Get field thrust from manual_control message
*
* @return thrust
*/
static inline float mavlink_msg_manual_control_get_thrust(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 13);
}
/**
* @brief Get field roll_manual from manual_control message
*
* @return roll control enabled auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_roll_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 17);
}
/**
* @brief Get field pitch_manual from manual_control message
*
* @return pitch auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_pitch_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 18);
}
/**
* @brief Get field yaw_manual from manual_control message
*
* @return yaw auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_yaw_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 19);
}
/**
* @brief Get field thrust_manual from manual_control message
*
* @return thrust auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_thrust_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 20);
}
/**
* @brief Decode a manual_control message into a struct
*
* @param msg The message to decode
* @param manual_control C-struct to decode the message contents into
*/
static inline void mavlink_msg_manual_control_decode(const mavlink_message_t* msg, mavlink_manual_control_t* manual_control)
{
#if MAVLINK_NEED_BYTE_SWAP
manual_control->target = mavlink_msg_manual_control_get_target(msg);
manual_control->roll = mavlink_msg_manual_control_get_roll(msg);
manual_control->pitch = mavlink_msg_manual_control_get_pitch(msg);
manual_control->yaw = mavlink_msg_manual_control_get_yaw(msg);
manual_control->thrust = mavlink_msg_manual_control_get_thrust(msg);
manual_control->roll_manual = mavlink_msg_manual_control_get_roll_manual(msg);
manual_control->pitch_manual = mavlink_msg_manual_control_get_pitch_manual(msg);
manual_control->yaw_manual = mavlink_msg_manual_control_get_yaw_manual(msg);
manual_control->thrust_manual = mavlink_msg_manual_control_get_thrust_manual(msg);
#else
memcpy(manual_control, _MAV_PAYLOAD(msg), 21);
#endif
}
@@ -1,160 +0,0 @@
// MESSAGE NAMED_VALUE_FLOAT PACKING
#define MAVLINK_MSG_ID_NAMED_VALUE_FLOAT 252
typedef struct __mavlink_named_value_float_t
{
char name[10]; ///< Name of the debug variable
float value; ///< Floating point value
} mavlink_named_value_float_t;
#define MAVLINK_MSG_ID_NAMED_VALUE_FLOAT_LEN 14
#define MAVLINK_MSG_ID_252_LEN 14
#define MAVLINK_MSG_NAMED_VALUE_FLOAT_FIELD_NAME_LEN 10
#define MAVLINK_MESSAGE_INFO_NAMED_VALUE_FLOAT { \
"NAMED_VALUE_FLOAT", \
2, \
{ { "name", NULL, MAVLINK_TYPE_CHAR, 10, 0, offsetof(mavlink_named_value_float_t, name) }, \
{ "value", NULL, MAVLINK_TYPE_FLOAT, 0, 10, offsetof(mavlink_named_value_float_t, value) }, \
} \
}
/**
* @brief Pack a named_value_float message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param name Name of the debug variable
* @param value Floating point value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_named_value_float_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
const char *name, float value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_float(buf, 10, value);
_mav_put_char_array(buf, 0, name, 10);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_named_value_float_t packet;
packet.value = value;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_NAMED_VALUE_FLOAT;
return mavlink_finalize_message(msg, system_id, component_id, 14);
}
/**
* @brief Pack a named_value_float message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param name Name of the debug variable
* @param value Floating point value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_named_value_float_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
const char *name,float value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_float(buf, 10, value);
_mav_put_char_array(buf, 0, name, 10);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_named_value_float_t packet;
packet.value = value;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_NAMED_VALUE_FLOAT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 14);
}
/**
* @brief Encode a named_value_float struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param named_value_float C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_named_value_float_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_named_value_float_t* named_value_float)
{
return mavlink_msg_named_value_float_pack(system_id, component_id, msg, named_value_float->name, named_value_float->value);
}
/**
* @brief Send a named_value_float message
* @param chan MAVLink channel to send the message
*
* @param name Name of the debug variable
* @param value Floating point value
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_named_value_float_send(mavlink_channel_t chan, const char *name, float value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_float(buf, 10, value);
_mav_put_char_array(buf, 0, name, 10);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_NAMED_VALUE_FLOAT, buf, 14);
#else
mavlink_named_value_float_t packet;
packet.value = value;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_NAMED_VALUE_FLOAT, (const char *)&packet, 14);
#endif
}
#endif
// MESSAGE NAMED_VALUE_FLOAT UNPACKING
/**
* @brief Get field name from named_value_float message
*
* @return Name of the debug variable
*/
static inline uint16_t mavlink_msg_named_value_float_get_name(const mavlink_message_t* msg, char *name)
{
return _MAV_RETURN_char_array(msg, name, 10, 0);
}
/**
* @brief Get field value from named_value_float message
*
* @return Floating point value
*/
static inline float mavlink_msg_named_value_float_get_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 10);
}
/**
* @brief Decode a named_value_float message into a struct
*
* @param msg The message to decode
* @param named_value_float C-struct to decode the message contents into
*/
static inline void mavlink_msg_named_value_float_decode(const mavlink_message_t* msg, mavlink_named_value_float_t* named_value_float)
{
#if MAVLINK_NEED_BYTE_SWAP
mavlink_msg_named_value_float_get_name(msg, named_value_float->name);
named_value_float->value = mavlink_msg_named_value_float_get_value(msg);
#else
memcpy(named_value_float, _MAV_PAYLOAD(msg), 14);
#endif
}
@@ -1,160 +0,0 @@
// MESSAGE NAMED_VALUE_INT PACKING
#define MAVLINK_MSG_ID_NAMED_VALUE_INT 253
typedef struct __mavlink_named_value_int_t
{
char name[10]; ///< Name of the debug variable
int32_t value; ///< Signed integer value
} mavlink_named_value_int_t;
#define MAVLINK_MSG_ID_NAMED_VALUE_INT_LEN 14
#define MAVLINK_MSG_ID_253_LEN 14
#define MAVLINK_MSG_NAMED_VALUE_INT_FIELD_NAME_LEN 10
#define MAVLINK_MESSAGE_INFO_NAMED_VALUE_INT { \
"NAMED_VALUE_INT", \
2, \
{ { "name", NULL, MAVLINK_TYPE_CHAR, 10, 0, offsetof(mavlink_named_value_int_t, name) }, \
{ "value", NULL, MAVLINK_TYPE_INT32_T, 0, 10, offsetof(mavlink_named_value_int_t, value) }, \
} \
}
/**
* @brief Pack a named_value_int message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param name Name of the debug variable
* @param value Signed integer value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_named_value_int_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
const char *name, int32_t value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_int32_t(buf, 10, value);
_mav_put_char_array(buf, 0, name, 10);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_named_value_int_t packet;
packet.value = value;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_NAMED_VALUE_INT;
return mavlink_finalize_message(msg, system_id, component_id, 14);
}
/**
* @brief Pack a named_value_int message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param name Name of the debug variable
* @param value Signed integer value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_named_value_int_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
const char *name,int32_t value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_int32_t(buf, 10, value);
_mav_put_char_array(buf, 0, name, 10);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_named_value_int_t packet;
packet.value = value;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_NAMED_VALUE_INT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 14);
}
/**
* @brief Encode a named_value_int struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param named_value_int C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_named_value_int_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_named_value_int_t* named_value_int)
{
return mavlink_msg_named_value_int_pack(system_id, component_id, msg, named_value_int->name, named_value_int->value);
}
/**
* @brief Send a named_value_int message
* @param chan MAVLink channel to send the message
*
* @param name Name of the debug variable
* @param value Signed integer value
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_named_value_int_send(mavlink_channel_t chan, const char *name, int32_t value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_int32_t(buf, 10, value);
_mav_put_char_array(buf, 0, name, 10);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_NAMED_VALUE_INT, buf, 14);
#else
mavlink_named_value_int_t packet;
packet.value = value;
mav_array_memcpy(packet.name, name, sizeof(char)*10);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_NAMED_VALUE_INT, (const char *)&packet, 14);
#endif
}
#endif
// MESSAGE NAMED_VALUE_INT UNPACKING
/**
* @brief Get field name from named_value_int message
*
* @return Name of the debug variable
*/
static inline uint16_t mavlink_msg_named_value_int_get_name(const mavlink_message_t* msg, char *name)
{
return _MAV_RETURN_char_array(msg, name, 10, 0);
}
/**
* @brief Get field value from named_value_int message
*
* @return Signed integer value
*/
static inline int32_t mavlink_msg_named_value_int_get_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_int32_t(msg, 10);
}
/**
* @brief Decode a named_value_int message into a struct
*
* @param msg The message to decode
* @param named_value_int C-struct to decode the message contents into
*/
static inline void mavlink_msg_named_value_int_decode(const mavlink_message_t* msg, mavlink_named_value_int_t* named_value_int)
{
#if MAVLINK_NEED_BYTE_SWAP
mavlink_msg_named_value_int_get_name(msg, named_value_int->name);
named_value_int->value = mavlink_msg_named_value_int_get_value(msg);
#else
memcpy(named_value_int, _MAV_PAYLOAD(msg), 14);
#endif
}
@@ -1,298 +0,0 @@
// MESSAGE NAV_CONTROLLER_OUTPUT PACKING
#define MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT 62
typedef struct __mavlink_nav_controller_output_t
{
float nav_roll; ///< Current desired roll in degrees
float nav_pitch; ///< Current desired pitch in degrees
int16_t nav_bearing; ///< Current desired heading in degrees
int16_t target_bearing; ///< Bearing to current waypoint/target in degrees
uint16_t wp_dist; ///< Distance to active waypoint in meters
float alt_error; ///< Current altitude error in meters
float aspd_error; ///< Current airspeed error in meters/second
float xtrack_error; ///< Current crosstrack error on x-y plane in meters
} mavlink_nav_controller_output_t;
#define MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT_LEN 26
#define MAVLINK_MSG_ID_62_LEN 26
#define MAVLINK_MESSAGE_INFO_NAV_CONTROLLER_OUTPUT { \
"NAV_CONTROLLER_OUTPUT", \
8, \
{ { "nav_roll", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_nav_controller_output_t, nav_roll) }, \
{ "nav_pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_nav_controller_output_t, nav_pitch) }, \
{ "nav_bearing", NULL, MAVLINK_TYPE_INT16_T, 0, 8, offsetof(mavlink_nav_controller_output_t, nav_bearing) }, \
{ "target_bearing", NULL, MAVLINK_TYPE_INT16_T, 0, 10, offsetof(mavlink_nav_controller_output_t, target_bearing) }, \
{ "wp_dist", NULL, MAVLINK_TYPE_UINT16_T, 0, 12, offsetof(mavlink_nav_controller_output_t, wp_dist) }, \
{ "alt_error", NULL, MAVLINK_TYPE_FLOAT, 0, 14, offsetof(mavlink_nav_controller_output_t, alt_error) }, \
{ "aspd_error", NULL, MAVLINK_TYPE_FLOAT, 0, 18, offsetof(mavlink_nav_controller_output_t, aspd_error) }, \
{ "xtrack_error", NULL, MAVLINK_TYPE_FLOAT, 0, 22, offsetof(mavlink_nav_controller_output_t, xtrack_error) }, \
} \
}
/**
* @brief Pack a nav_controller_output message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param nav_roll Current desired roll in degrees
* @param nav_pitch Current desired pitch in degrees
* @param nav_bearing Current desired heading in degrees
* @param target_bearing Bearing to current waypoint/target in degrees
* @param wp_dist Distance to active waypoint in meters
* @param alt_error Current altitude error in meters
* @param aspd_error Current airspeed error in meters/second
* @param xtrack_error Current crosstrack error on x-y plane in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_nav_controller_output_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
float nav_roll, float nav_pitch, int16_t nav_bearing, int16_t target_bearing, uint16_t wp_dist, float alt_error, float aspd_error, float xtrack_error)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_float(buf, 0, nav_roll);
_mav_put_float(buf, 4, nav_pitch);
_mav_put_int16_t(buf, 8, nav_bearing);
_mav_put_int16_t(buf, 10, target_bearing);
_mav_put_uint16_t(buf, 12, wp_dist);
_mav_put_float(buf, 14, alt_error);
_mav_put_float(buf, 18, aspd_error);
_mav_put_float(buf, 22, xtrack_error);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_nav_controller_output_t packet;
packet.nav_roll = nav_roll;
packet.nav_pitch = nav_pitch;
packet.nav_bearing = nav_bearing;
packet.target_bearing = target_bearing;
packet.wp_dist = wp_dist;
packet.alt_error = alt_error;
packet.aspd_error = aspd_error;
packet.xtrack_error = xtrack_error;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT;
return mavlink_finalize_message(msg, system_id, component_id, 26);
}
/**
* @brief Pack a nav_controller_output message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param nav_roll Current desired roll in degrees
* @param nav_pitch Current desired pitch in degrees
* @param nav_bearing Current desired heading in degrees
* @param target_bearing Bearing to current waypoint/target in degrees
* @param wp_dist Distance to active waypoint in meters
* @param alt_error Current altitude error in meters
* @param aspd_error Current airspeed error in meters/second
* @param xtrack_error Current crosstrack error on x-y plane in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_nav_controller_output_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
float nav_roll,float nav_pitch,int16_t nav_bearing,int16_t target_bearing,uint16_t wp_dist,float alt_error,float aspd_error,float xtrack_error)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_float(buf, 0, nav_roll);
_mav_put_float(buf, 4, nav_pitch);
_mav_put_int16_t(buf, 8, nav_bearing);
_mav_put_int16_t(buf, 10, target_bearing);
_mav_put_uint16_t(buf, 12, wp_dist);
_mav_put_float(buf, 14, alt_error);
_mav_put_float(buf, 18, aspd_error);
_mav_put_float(buf, 22, xtrack_error);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_nav_controller_output_t packet;
packet.nav_roll = nav_roll;
packet.nav_pitch = nav_pitch;
packet.nav_bearing = nav_bearing;
packet.target_bearing = target_bearing;
packet.wp_dist = wp_dist;
packet.alt_error = alt_error;
packet.aspd_error = aspd_error;
packet.xtrack_error = xtrack_error;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 26);
}
/**
* @brief Encode a nav_controller_output struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param nav_controller_output C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_nav_controller_output_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_nav_controller_output_t* nav_controller_output)
{
return mavlink_msg_nav_controller_output_pack(system_id, component_id, msg, nav_controller_output->nav_roll, nav_controller_output->nav_pitch, nav_controller_output->nav_bearing, nav_controller_output->target_bearing, nav_controller_output->wp_dist, nav_controller_output->alt_error, nav_controller_output->aspd_error, nav_controller_output->xtrack_error);
}
/**
* @brief Send a nav_controller_output message
* @param chan MAVLink channel to send the message
*
* @param nav_roll Current desired roll in degrees
* @param nav_pitch Current desired pitch in degrees
* @param nav_bearing Current desired heading in degrees
* @param target_bearing Bearing to current waypoint/target in degrees
* @param wp_dist Distance to active waypoint in meters
* @param alt_error Current altitude error in meters
* @param aspd_error Current airspeed error in meters/second
* @param xtrack_error Current crosstrack error on x-y plane in meters
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_nav_controller_output_send(mavlink_channel_t chan, float nav_roll, float nav_pitch, int16_t nav_bearing, int16_t target_bearing, uint16_t wp_dist, float alt_error, float aspd_error, float xtrack_error)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_float(buf, 0, nav_roll);
_mav_put_float(buf, 4, nav_pitch);
_mav_put_int16_t(buf, 8, nav_bearing);
_mav_put_int16_t(buf, 10, target_bearing);
_mav_put_uint16_t(buf, 12, wp_dist);
_mav_put_float(buf, 14, alt_error);
_mav_put_float(buf, 18, aspd_error);
_mav_put_float(buf, 22, xtrack_error);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT, buf, 26);
#else
mavlink_nav_controller_output_t packet;
packet.nav_roll = nav_roll;
packet.nav_pitch = nav_pitch;
packet.nav_bearing = nav_bearing;
packet.target_bearing = target_bearing;
packet.wp_dist = wp_dist;
packet.alt_error = alt_error;
packet.aspd_error = aspd_error;
packet.xtrack_error = xtrack_error;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT, (const char *)&packet, 26);
#endif
}
#endif
// MESSAGE NAV_CONTROLLER_OUTPUT UNPACKING
/**
* @brief Get field nav_roll from nav_controller_output message
*
* @return Current desired roll in degrees
*/
static inline float mavlink_msg_nav_controller_output_get_nav_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field nav_pitch from nav_controller_output message
*
* @return Current desired pitch in degrees
*/
static inline float mavlink_msg_nav_controller_output_get_nav_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field nav_bearing from nav_controller_output message
*
* @return Current desired heading in degrees
*/
static inline int16_t mavlink_msg_nav_controller_output_get_nav_bearing(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 8);
}
/**
* @brief Get field target_bearing from nav_controller_output message
*
* @return Bearing to current waypoint/target in degrees
*/
static inline int16_t mavlink_msg_nav_controller_output_get_target_bearing(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 10);
}
/**
* @brief Get field wp_dist from nav_controller_output message
*
* @return Distance to active waypoint in meters
*/
static inline uint16_t mavlink_msg_nav_controller_output_get_wp_dist(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 12);
}
/**
* @brief Get field alt_error from nav_controller_output message
*
* @return Current altitude error in meters
*/
static inline float mavlink_msg_nav_controller_output_get_alt_error(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 14);
}
/**
* @brief Get field aspd_error from nav_controller_output message
*
* @return Current airspeed error in meters/second
*/
static inline float mavlink_msg_nav_controller_output_get_aspd_error(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 18);
}
/**
* @brief Get field xtrack_error from nav_controller_output message
*
* @return Current crosstrack error on x-y plane in meters
*/
static inline float mavlink_msg_nav_controller_output_get_xtrack_error(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 22);
}
/**
* @brief Decode a nav_controller_output message into a struct
*
* @param msg The message to decode
* @param nav_controller_output C-struct to decode the message contents into
*/
static inline void mavlink_msg_nav_controller_output_decode(const mavlink_message_t* msg, mavlink_nav_controller_output_t* nav_controller_output)
{
#if MAVLINK_NEED_BYTE_SWAP
nav_controller_output->nav_roll = mavlink_msg_nav_controller_output_get_nav_roll(msg);
nav_controller_output->nav_pitch = mavlink_msg_nav_controller_output_get_nav_pitch(msg);
nav_controller_output->nav_bearing = mavlink_msg_nav_controller_output_get_nav_bearing(msg);
nav_controller_output->target_bearing = mavlink_msg_nav_controller_output_get_target_bearing(msg);
nav_controller_output->wp_dist = mavlink_msg_nav_controller_output_get_wp_dist(msg);
nav_controller_output->alt_error = mavlink_msg_nav_controller_output_get_alt_error(msg);
nav_controller_output->aspd_error = mavlink_msg_nav_controller_output_get_aspd_error(msg);
nav_controller_output->xtrack_error = mavlink_msg_nav_controller_output_get_xtrack_error(msg);
#else
memcpy(nav_controller_output, _MAV_PAYLOAD(msg), 26);
#endif
}
@@ -1,270 +0,0 @@
// MESSAGE OBJECT_DETECTION_EVENT PACKING
#define MAVLINK_MSG_ID_OBJECT_DETECTION_EVENT 140
typedef struct __mavlink_object_detection_event_t
{
uint32_t time; ///< Timestamp in milliseconds since system boot
uint16_t object_id; ///< Object ID
uint8_t type; ///< Object type: 0: image, 1: letter, 2: ground vehicle, 3: air vehicle, 4: surface vehicle, 5: sub-surface vehicle, 6: human, 7: animal
char name[20]; ///< Name of the object as defined by the detector
uint8_t quality; ///< Detection quality / confidence. 0: bad, 255: maximum confidence
float bearing; ///< Angle of the object with respect to the body frame in NED coordinates in radians. 0: front
float distance; ///< Ground distance in meters
} mavlink_object_detection_event_t;
#define MAVLINK_MSG_ID_OBJECT_DETECTION_EVENT_LEN 36
#define MAVLINK_MSG_ID_140_LEN 36
#define MAVLINK_MSG_OBJECT_DETECTION_EVENT_FIELD_NAME_LEN 20
#define MAVLINK_MESSAGE_INFO_OBJECT_DETECTION_EVENT { \
"OBJECT_DETECTION_EVENT", \
7, \
{ { "time", NULL, MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_object_detection_event_t, time) }, \
{ "object_id", NULL, MAVLINK_TYPE_UINT16_T, 0, 4, offsetof(mavlink_object_detection_event_t, object_id) }, \
{ "type", NULL, MAVLINK_TYPE_UINT8_T, 0, 6, offsetof(mavlink_object_detection_event_t, type) }, \
{ "name", NULL, MAVLINK_TYPE_CHAR, 20, 7, offsetof(mavlink_object_detection_event_t, name) }, \
{ "quality", NULL, MAVLINK_TYPE_UINT8_T, 0, 27, offsetof(mavlink_object_detection_event_t, quality) }, \
{ "bearing", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_object_detection_event_t, bearing) }, \
{ "distance", NULL, MAVLINK_TYPE_FLOAT, 0, 32, offsetof(mavlink_object_detection_event_t, distance) }, \
} \
}
/**
* @brief Pack a object_detection_event message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time Timestamp in milliseconds since system boot
* @param object_id Object ID
* @param type Object type: 0: image, 1: letter, 2: ground vehicle, 3: air vehicle, 4: surface vehicle, 5: sub-surface vehicle, 6: human, 7: animal
* @param name Name of the object as defined by the detector
* @param quality Detection quality / confidence. 0: bad, 255: maximum confidence
* @param bearing Angle of the object with respect to the body frame in NED coordinates in radians. 0: front
* @param distance Ground distance in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_object_detection_event_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint32_t time, uint16_t object_id, uint8_t type, const char *name, uint8_t quality, float bearing, float distance)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_uint32_t(buf, 0, time);
_mav_put_uint16_t(buf, 4, object_id);
_mav_put_uint8_t(buf, 6, type);
_mav_put_uint8_t(buf, 27, quality);
_mav_put_float(buf, 28, bearing);
_mav_put_float(buf, 32, distance);
_mav_put_char_array(buf, 7, name, 20);
memcpy(_MAV_PAYLOAD(msg), buf, 36);
#else
mavlink_object_detection_event_t packet;
packet.time = time;
packet.object_id = object_id;
packet.type = type;
packet.quality = quality;
packet.bearing = bearing;
packet.distance = distance;
mav_array_memcpy(packet.name, name, sizeof(char)*20);
memcpy(_MAV_PAYLOAD(msg), &packet, 36);
#endif
msg->msgid = MAVLINK_MSG_ID_OBJECT_DETECTION_EVENT;
return mavlink_finalize_message(msg, system_id, component_id, 36);
}
/**
* @brief Pack a object_detection_event message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time Timestamp in milliseconds since system boot
* @param object_id Object ID
* @param type Object type: 0: image, 1: letter, 2: ground vehicle, 3: air vehicle, 4: surface vehicle, 5: sub-surface vehicle, 6: human, 7: animal
* @param name Name of the object as defined by the detector
* @param quality Detection quality / confidence. 0: bad, 255: maximum confidence
* @param bearing Angle of the object with respect to the body frame in NED coordinates in radians. 0: front
* @param distance Ground distance in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_object_detection_event_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint32_t time,uint16_t object_id,uint8_t type,const char *name,uint8_t quality,float bearing,float distance)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_uint32_t(buf, 0, time);
_mav_put_uint16_t(buf, 4, object_id);
_mav_put_uint8_t(buf, 6, type);
_mav_put_uint8_t(buf, 27, quality);
_mav_put_float(buf, 28, bearing);
_mav_put_float(buf, 32, distance);
_mav_put_char_array(buf, 7, name, 20);
memcpy(_MAV_PAYLOAD(msg), buf, 36);
#else
mavlink_object_detection_event_t packet;
packet.time = time;
packet.object_id = object_id;
packet.type = type;
packet.quality = quality;
packet.bearing = bearing;
packet.distance = distance;
mav_array_memcpy(packet.name, name, sizeof(char)*20);
memcpy(_MAV_PAYLOAD(msg), &packet, 36);
#endif
msg->msgid = MAVLINK_MSG_ID_OBJECT_DETECTION_EVENT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 36);
}
/**
* @brief Encode a object_detection_event struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param object_detection_event C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_object_detection_event_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_object_detection_event_t* object_detection_event)
{
return mavlink_msg_object_detection_event_pack(system_id, component_id, msg, object_detection_event->time, object_detection_event->object_id, object_detection_event->type, object_detection_event->name, object_detection_event->quality, object_detection_event->bearing, object_detection_event->distance);
}
/**
* @brief Send a object_detection_event message
* @param chan MAVLink channel to send the message
*
* @param time Timestamp in milliseconds since system boot
* @param object_id Object ID
* @param type Object type: 0: image, 1: letter, 2: ground vehicle, 3: air vehicle, 4: surface vehicle, 5: sub-surface vehicle, 6: human, 7: animal
* @param name Name of the object as defined by the detector
* @param quality Detection quality / confidence. 0: bad, 255: maximum confidence
* @param bearing Angle of the object with respect to the body frame in NED coordinates in radians. 0: front
* @param distance Ground distance in meters
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_object_detection_event_send(mavlink_channel_t chan, uint32_t time, uint16_t object_id, uint8_t type, const char *name, uint8_t quality, float bearing, float distance)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_uint32_t(buf, 0, time);
_mav_put_uint16_t(buf, 4, object_id);
_mav_put_uint8_t(buf, 6, type);
_mav_put_uint8_t(buf, 27, quality);
_mav_put_float(buf, 28, bearing);
_mav_put_float(buf, 32, distance);
_mav_put_char_array(buf, 7, name, 20);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OBJECT_DETECTION_EVENT, buf, 36);
#else
mavlink_object_detection_event_t packet;
packet.time = time;
packet.object_id = object_id;
packet.type = type;
packet.quality = quality;
packet.bearing = bearing;
packet.distance = distance;
mav_array_memcpy(packet.name, name, sizeof(char)*20);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OBJECT_DETECTION_EVENT, (const char *)&packet, 36);
#endif
}
#endif
// MESSAGE OBJECT_DETECTION_EVENT UNPACKING
/**
* @brief Get field time from object_detection_event message
*
* @return Timestamp in milliseconds since system boot
*/
static inline uint32_t mavlink_msg_object_detection_event_get_time(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 0);
}
/**
* @brief Get field object_id from object_detection_event message
*
* @return Object ID
*/
static inline uint16_t mavlink_msg_object_detection_event_get_object_id(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 4);
}
/**
* @brief Get field type from object_detection_event message
*
* @return Object type: 0: image, 1: letter, 2: ground vehicle, 3: air vehicle, 4: surface vehicle, 5: sub-surface vehicle, 6: human, 7: animal
*/
static inline uint8_t mavlink_msg_object_detection_event_get_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 6);
}
/**
* @brief Get field name from object_detection_event message
*
* @return Name of the object as defined by the detector
*/
static inline uint16_t mavlink_msg_object_detection_event_get_name(const mavlink_message_t* msg, char *name)
{
return _MAV_RETURN_char_array(msg, name, 20, 7);
}
/**
* @brief Get field quality from object_detection_event message
*
* @return Detection quality / confidence. 0: bad, 255: maximum confidence
*/
static inline uint8_t mavlink_msg_object_detection_event_get_quality(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 27);
}
/**
* @brief Get field bearing from object_detection_event message
*
* @return Angle of the object with respect to the body frame in NED coordinates in radians. 0: front
*/
static inline float mavlink_msg_object_detection_event_get_bearing(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Get field distance from object_detection_event message
*
* @return Ground distance in meters
*/
static inline float mavlink_msg_object_detection_event_get_distance(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 32);
}
/**
* @brief Decode a object_detection_event message into a struct
*
* @param msg The message to decode
* @param object_detection_event C-struct to decode the message contents into
*/
static inline void mavlink_msg_object_detection_event_decode(const mavlink_message_t* msg, mavlink_object_detection_event_t* object_detection_event)
{
#if MAVLINK_NEED_BYTE_SWAP
object_detection_event->time = mavlink_msg_object_detection_event_get_time(msg);
object_detection_event->object_id = mavlink_msg_object_detection_event_get_object_id(msg);
object_detection_event->type = mavlink_msg_object_detection_event_get_type(msg);
mavlink_msg_object_detection_event_get_name(msg, object_detection_event->name);
object_detection_event->quality = mavlink_msg_object_detection_event_get_quality(msg);
object_detection_event->bearing = mavlink_msg_object_detection_event_get_bearing(msg);
object_detection_event->distance = mavlink_msg_object_detection_event_get_distance(msg);
#else
memcpy(object_detection_event, _MAV_PAYLOAD(msg), 36);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE OPTICAL_FLOW PACKING
#define MAVLINK_MSG_ID_OPTICAL_FLOW 100
typedef struct __mavlink_optical_flow_t
{
uint64_t time; ///< Timestamp (UNIX)
uint8_t sensor_id; ///< Sensor ID
int16_t flow_x; ///< Flow in pixels in x-sensor direction
int16_t flow_y; ///< Flow in pixels in y-sensor direction
uint8_t quality; ///< Optical flow quality / confidence. 0: bad, 255: maximum quality
float ground_distance; ///< Ground distance in meters
} mavlink_optical_flow_t;
#define MAVLINK_MSG_ID_OPTICAL_FLOW_LEN 18
#define MAVLINK_MSG_ID_100_LEN 18
#define MAVLINK_MESSAGE_INFO_OPTICAL_FLOW { \
"OPTICAL_FLOW", \
6, \
{ { "time", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_optical_flow_t, time) }, \
{ "sensor_id", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_optical_flow_t, sensor_id) }, \
{ "flow_x", NULL, MAVLINK_TYPE_INT16_T, 0, 9, offsetof(mavlink_optical_flow_t, flow_x) }, \
{ "flow_y", NULL, MAVLINK_TYPE_INT16_T, 0, 11, offsetof(mavlink_optical_flow_t, flow_y) }, \
{ "quality", NULL, MAVLINK_TYPE_UINT8_T, 0, 13, offsetof(mavlink_optical_flow_t, quality) }, \
{ "ground_distance", NULL, MAVLINK_TYPE_FLOAT, 0, 14, offsetof(mavlink_optical_flow_t, ground_distance) }, \
} \
}
/**
* @brief Pack a optical_flow message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time Timestamp (UNIX)
* @param sensor_id Sensor ID
* @param flow_x Flow in pixels in x-sensor direction
* @param flow_y Flow in pixels in y-sensor direction
* @param quality Optical flow quality / confidence. 0: bad, 255: maximum quality
* @param ground_distance Ground distance in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_optical_flow_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t time, uint8_t sensor_id, int16_t flow_x, int16_t flow_y, uint8_t quality, float ground_distance)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint64_t(buf, 0, time);
_mav_put_uint8_t(buf, 8, sensor_id);
_mav_put_int16_t(buf, 9, flow_x);
_mav_put_int16_t(buf, 11, flow_y);
_mav_put_uint8_t(buf, 13, quality);
_mav_put_float(buf, 14, ground_distance);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_optical_flow_t packet;
packet.time = time;
packet.sensor_id = sensor_id;
packet.flow_x = flow_x;
packet.flow_y = flow_y;
packet.quality = quality;
packet.ground_distance = ground_distance;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_OPTICAL_FLOW;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a optical_flow message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time Timestamp (UNIX)
* @param sensor_id Sensor ID
* @param flow_x Flow in pixels in x-sensor direction
* @param flow_y Flow in pixels in y-sensor direction
* @param quality Optical flow quality / confidence. 0: bad, 255: maximum quality
* @param ground_distance Ground distance in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_optical_flow_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t time,uint8_t sensor_id,int16_t flow_x,int16_t flow_y,uint8_t quality,float ground_distance)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint64_t(buf, 0, time);
_mav_put_uint8_t(buf, 8, sensor_id);
_mav_put_int16_t(buf, 9, flow_x);
_mav_put_int16_t(buf, 11, flow_y);
_mav_put_uint8_t(buf, 13, quality);
_mav_put_float(buf, 14, ground_distance);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_optical_flow_t packet;
packet.time = time;
packet.sensor_id = sensor_id;
packet.flow_x = flow_x;
packet.flow_y = flow_y;
packet.quality = quality;
packet.ground_distance = ground_distance;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_OPTICAL_FLOW;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a optical_flow struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param optical_flow C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_optical_flow_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_optical_flow_t* optical_flow)
{
return mavlink_msg_optical_flow_pack(system_id, component_id, msg, optical_flow->time, optical_flow->sensor_id, optical_flow->flow_x, optical_flow->flow_y, optical_flow->quality, optical_flow->ground_distance);
}
/**
* @brief Send a optical_flow message
* @param chan MAVLink channel to send the message
*
* @param time Timestamp (UNIX)
* @param sensor_id Sensor ID
* @param flow_x Flow in pixels in x-sensor direction
* @param flow_y Flow in pixels in y-sensor direction
* @param quality Optical flow quality / confidence. 0: bad, 255: maximum quality
* @param ground_distance Ground distance in meters
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_optical_flow_send(mavlink_channel_t chan, uint64_t time, uint8_t sensor_id, int16_t flow_x, int16_t flow_y, uint8_t quality, float ground_distance)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint64_t(buf, 0, time);
_mav_put_uint8_t(buf, 8, sensor_id);
_mav_put_int16_t(buf, 9, flow_x);
_mav_put_int16_t(buf, 11, flow_y);
_mav_put_uint8_t(buf, 13, quality);
_mav_put_float(buf, 14, ground_distance);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPTICAL_FLOW, buf, 18);
#else
mavlink_optical_flow_t packet;
packet.time = time;
packet.sensor_id = sensor_id;
packet.flow_x = flow_x;
packet.flow_y = flow_y;
packet.quality = quality;
packet.ground_distance = ground_distance;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPTICAL_FLOW, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE OPTICAL_FLOW UNPACKING
/**
* @brief Get field time from optical_flow message
*
* @return Timestamp (UNIX)
*/
static inline uint64_t mavlink_msg_optical_flow_get_time(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field sensor_id from optical_flow message
*
* @return Sensor ID
*/
static inline uint8_t mavlink_msg_optical_flow_get_sensor_id(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 8);
}
/**
* @brief Get field flow_x from optical_flow message
*
* @return Flow in pixels in x-sensor direction
*/
static inline int16_t mavlink_msg_optical_flow_get_flow_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 9);
}
/**
* @brief Get field flow_y from optical_flow message
*
* @return Flow in pixels in y-sensor direction
*/
static inline int16_t mavlink_msg_optical_flow_get_flow_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 11);
}
/**
* @brief Get field quality from optical_flow message
*
* @return Optical flow quality / confidence. 0: bad, 255: maximum quality
*/
static inline uint8_t mavlink_msg_optical_flow_get_quality(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 13);
}
/**
* @brief Get field ground_distance from optical_flow message
*
* @return Ground distance in meters
*/
static inline float mavlink_msg_optical_flow_get_ground_distance(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 14);
}
/**
* @brief Decode a optical_flow message into a struct
*
* @param msg The message to decode
* @param optical_flow C-struct to decode the message contents into
*/
static inline void mavlink_msg_optical_flow_decode(const mavlink_message_t* msg, mavlink_optical_flow_t* optical_flow)
{
#if MAVLINK_NEED_BYTE_SWAP
optical_flow->time = mavlink_msg_optical_flow_get_time(msg);
optical_flow->sensor_id = mavlink_msg_optical_flow_get_sensor_id(msg);
optical_flow->flow_x = mavlink_msg_optical_flow_get_flow_x(msg);
optical_flow->flow_y = mavlink_msg_optical_flow_get_flow_y(msg);
optical_flow->quality = mavlink_msg_optical_flow_get_quality(msg);
optical_flow->ground_distance = mavlink_msg_optical_flow_get_ground_distance(msg);
#else
memcpy(optical_flow, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE PARAM_REQUEST_LIST PACKING
#define MAVLINK_MSG_ID_PARAM_REQUEST_LIST 21
typedef struct __mavlink_param_request_list_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
} mavlink_param_request_list_t;
#define MAVLINK_MSG_ID_PARAM_REQUEST_LIST_LEN 2
#define MAVLINK_MSG_ID_21_LEN 2
#define MAVLINK_MESSAGE_INFO_PARAM_REQUEST_LIST { \
"PARAM_REQUEST_LIST", \
2, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_param_request_list_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_param_request_list_t, target_component) }, \
} \
}
/**
* @brief Pack a param_request_list message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_request_list_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_param_request_list_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_REQUEST_LIST;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a param_request_list message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_request_list_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_param_request_list_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_REQUEST_LIST;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a param_request_list struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param param_request_list C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_param_request_list_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_param_request_list_t* param_request_list)
{
return mavlink_msg_param_request_list_pack(system_id, component_id, msg, param_request_list->target_system, param_request_list->target_component);
}
/**
* @brief Send a param_request_list message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_param_request_list_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_REQUEST_LIST, buf, 2);
#else
mavlink_param_request_list_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_REQUEST_LIST, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE PARAM_REQUEST_LIST UNPACKING
/**
* @brief Get field target_system from param_request_list message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_param_request_list_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from param_request_list message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_param_request_list_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Decode a param_request_list message into a struct
*
* @param msg The message to decode
* @param param_request_list C-struct to decode the message contents into
*/
static inline void mavlink_msg_param_request_list_decode(const mavlink_message_t* msg, mavlink_param_request_list_t* param_request_list)
{
#if MAVLINK_NEED_BYTE_SWAP
param_request_list->target_system = mavlink_msg_param_request_list_get_target_system(msg);
param_request_list->target_component = mavlink_msg_param_request_list_get_target_component(msg);
#else
memcpy(param_request_list, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,204 +0,0 @@
// MESSAGE PARAM_REQUEST_READ PACKING
#define MAVLINK_MSG_ID_PARAM_REQUEST_READ 20
typedef struct __mavlink_param_request_read_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
int8_t param_id[15]; ///< Onboard parameter id
int16_t param_index; ///< Parameter index. Send -1 to use the param ID field as identifier
} mavlink_param_request_read_t;
#define MAVLINK_MSG_ID_PARAM_REQUEST_READ_LEN 19
#define MAVLINK_MSG_ID_20_LEN 19
#define MAVLINK_MSG_PARAM_REQUEST_READ_FIELD_PARAM_ID_LEN 15
#define MAVLINK_MESSAGE_INFO_PARAM_REQUEST_READ { \
"PARAM_REQUEST_READ", \
4, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_param_request_read_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_param_request_read_t, target_component) }, \
{ "param_id", NULL, MAVLINK_TYPE_INT8_T, 15, 2, offsetof(mavlink_param_request_read_t, param_id) }, \
{ "param_index", NULL, MAVLINK_TYPE_INT16_T, 0, 17, offsetof(mavlink_param_request_read_t, param_index) }, \
} \
}
/**
* @brief Pack a param_request_read message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param param_id Onboard parameter id
* @param param_index Parameter index. Send -1 to use the param ID field as identifier
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_request_read_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, const int8_t *param_id, int16_t param_index)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[19];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int16_t(buf, 17, param_index);
_mav_put_int8_t_array(buf, 2, param_id, 15);
memcpy(_MAV_PAYLOAD(msg), buf, 19);
#else
mavlink_param_request_read_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.param_index = param_index;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
memcpy(_MAV_PAYLOAD(msg), &packet, 19);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_REQUEST_READ;
return mavlink_finalize_message(msg, system_id, component_id, 19);
}
/**
* @brief Pack a param_request_read message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param param_id Onboard parameter id
* @param param_index Parameter index. Send -1 to use the param ID field as identifier
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_request_read_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,const int8_t *param_id,int16_t param_index)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[19];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int16_t(buf, 17, param_index);
_mav_put_int8_t_array(buf, 2, param_id, 15);
memcpy(_MAV_PAYLOAD(msg), buf, 19);
#else
mavlink_param_request_read_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.param_index = param_index;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
memcpy(_MAV_PAYLOAD(msg), &packet, 19);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_REQUEST_READ;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 19);
}
/**
* @brief Encode a param_request_read struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param param_request_read C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_param_request_read_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_param_request_read_t* param_request_read)
{
return mavlink_msg_param_request_read_pack(system_id, component_id, msg, param_request_read->target_system, param_request_read->target_component, param_request_read->param_id, param_request_read->param_index);
}
/**
* @brief Send a param_request_read message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param param_id Onboard parameter id
* @param param_index Parameter index. Send -1 to use the param ID field as identifier
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_param_request_read_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, const int8_t *param_id, int16_t param_index)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[19];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_int16_t(buf, 17, param_index);
_mav_put_int8_t_array(buf, 2, param_id, 15);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_REQUEST_READ, buf, 19);
#else
mavlink_param_request_read_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.param_index = param_index;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_REQUEST_READ, (const char *)&packet, 19);
#endif
}
#endif
// MESSAGE PARAM_REQUEST_READ UNPACKING
/**
* @brief Get field target_system from param_request_read message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_param_request_read_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from param_request_read message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_param_request_read_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field param_id from param_request_read message
*
* @return Onboard parameter id
*/
static inline uint16_t mavlink_msg_param_request_read_get_param_id(const mavlink_message_t* msg, int8_t *param_id)
{
return _MAV_RETURN_int8_t_array(msg, param_id, 15, 2);
}
/**
* @brief Get field param_index from param_request_read message
*
* @return Parameter index. Send -1 to use the param ID field as identifier
*/
static inline int16_t mavlink_msg_param_request_read_get_param_index(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 17);
}
/**
* @brief Decode a param_request_read message into a struct
*
* @param msg The message to decode
* @param param_request_read C-struct to decode the message contents into
*/
static inline void mavlink_msg_param_request_read_decode(const mavlink_message_t* msg, mavlink_param_request_read_t* param_request_read)
{
#if MAVLINK_NEED_BYTE_SWAP
param_request_read->target_system = mavlink_msg_param_request_read_get_target_system(msg);
param_request_read->target_component = mavlink_msg_param_request_read_get_target_component(msg);
mavlink_msg_param_request_read_get_param_id(msg, param_request_read->param_id);
param_request_read->param_index = mavlink_msg_param_request_read_get_param_index(msg);
#else
memcpy(param_request_read, _MAV_PAYLOAD(msg), 19);
#endif
}
@@ -1,204 +0,0 @@
// MESSAGE PARAM_SET PACKING
#define MAVLINK_MSG_ID_PARAM_SET 23
typedef struct __mavlink_param_set_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
int8_t param_id[15]; ///< Onboard parameter id
float param_value; ///< Onboard parameter value
} mavlink_param_set_t;
#define MAVLINK_MSG_ID_PARAM_SET_LEN 21
#define MAVLINK_MSG_ID_23_LEN 21
#define MAVLINK_MSG_PARAM_SET_FIELD_PARAM_ID_LEN 15
#define MAVLINK_MESSAGE_INFO_PARAM_SET { \
"PARAM_SET", \
4, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_param_set_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_param_set_t, target_component) }, \
{ "param_id", NULL, MAVLINK_TYPE_INT8_T, 15, 2, offsetof(mavlink_param_set_t, param_id) }, \
{ "param_value", NULL, MAVLINK_TYPE_FLOAT, 0, 17, offsetof(mavlink_param_set_t, param_value) }, \
} \
}
/**
* @brief Pack a param_set message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param param_id Onboard parameter id
* @param param_value Onboard parameter value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_set_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, const int8_t *param_id, float param_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 17, param_value);
_mav_put_int8_t_array(buf, 2, param_id, 15);
memcpy(_MAV_PAYLOAD(msg), buf, 21);
#else
mavlink_param_set_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.param_value = param_value;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
memcpy(_MAV_PAYLOAD(msg), &packet, 21);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_SET;
return mavlink_finalize_message(msg, system_id, component_id, 21);
}
/**
* @brief Pack a param_set message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param param_id Onboard parameter id
* @param param_value Onboard parameter value
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_set_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,const int8_t *param_id,float param_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 17, param_value);
_mav_put_int8_t_array(buf, 2, param_id, 15);
memcpy(_MAV_PAYLOAD(msg), buf, 21);
#else
mavlink_param_set_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.param_value = param_value;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
memcpy(_MAV_PAYLOAD(msg), &packet, 21);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_SET;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 21);
}
/**
* @brief Encode a param_set struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param param_set C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_param_set_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_param_set_t* param_set)
{
return mavlink_msg_param_set_pack(system_id, component_id, msg, param_set->target_system, param_set->target_component, param_set->param_id, param_set->param_value);
}
/**
* @brief Send a param_set message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param param_id Onboard parameter id
* @param param_value Onboard parameter value
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_param_set_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, const int8_t *param_id, float param_value)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 17, param_value);
_mav_put_int8_t_array(buf, 2, param_id, 15);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_SET, buf, 21);
#else
mavlink_param_set_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.param_value = param_value;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_SET, (const char *)&packet, 21);
#endif
}
#endif
// MESSAGE PARAM_SET UNPACKING
/**
* @brief Get field target_system from param_set message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_param_set_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from param_set message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_param_set_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field param_id from param_set message
*
* @return Onboard parameter id
*/
static inline uint16_t mavlink_msg_param_set_get_param_id(const mavlink_message_t* msg, int8_t *param_id)
{
return _MAV_RETURN_int8_t_array(msg, param_id, 15, 2);
}
/**
* @brief Get field param_value from param_set message
*
* @return Onboard parameter value
*/
static inline float mavlink_msg_param_set_get_param_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 17);
}
/**
* @brief Decode a param_set message into a struct
*
* @param msg The message to decode
* @param param_set C-struct to decode the message contents into
*/
static inline void mavlink_msg_param_set_decode(const mavlink_message_t* msg, mavlink_param_set_t* param_set)
{
#if MAVLINK_NEED_BYTE_SWAP
param_set->target_system = mavlink_msg_param_set_get_target_system(msg);
param_set->target_component = mavlink_msg_param_set_get_target_component(msg);
mavlink_msg_param_set_get_param_id(msg, param_set->param_id);
param_set->param_value = mavlink_msg_param_set_get_param_value(msg);
#else
memcpy(param_set, _MAV_PAYLOAD(msg), 21);
#endif
}
@@ -1,204 +0,0 @@
// MESSAGE PARAM_VALUE PACKING
#define MAVLINK_MSG_ID_PARAM_VALUE 22
typedef struct __mavlink_param_value_t
{
int8_t param_id[15]; ///< Onboard parameter id
float param_value; ///< Onboard parameter value
uint16_t param_count; ///< Total number of onboard parameters
uint16_t param_index; ///< Index of this onboard parameter
} mavlink_param_value_t;
#define MAVLINK_MSG_ID_PARAM_VALUE_LEN 23
#define MAVLINK_MSG_ID_22_LEN 23
#define MAVLINK_MSG_PARAM_VALUE_FIELD_PARAM_ID_LEN 15
#define MAVLINK_MESSAGE_INFO_PARAM_VALUE { \
"PARAM_VALUE", \
4, \
{ { "param_id", NULL, MAVLINK_TYPE_INT8_T, 15, 0, offsetof(mavlink_param_value_t, param_id) }, \
{ "param_value", NULL, MAVLINK_TYPE_FLOAT, 0, 15, offsetof(mavlink_param_value_t, param_value) }, \
{ "param_count", NULL, MAVLINK_TYPE_UINT16_T, 0, 19, offsetof(mavlink_param_value_t, param_count) }, \
{ "param_index", NULL, MAVLINK_TYPE_UINT16_T, 0, 21, offsetof(mavlink_param_value_t, param_index) }, \
} \
}
/**
* @brief Pack a param_value message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param param_id Onboard parameter id
* @param param_value Onboard parameter value
* @param param_count Total number of onboard parameters
* @param param_index Index of this onboard parameter
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_value_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
const int8_t *param_id, float param_value, uint16_t param_count, uint16_t param_index)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[23];
_mav_put_float(buf, 15, param_value);
_mav_put_uint16_t(buf, 19, param_count);
_mav_put_uint16_t(buf, 21, param_index);
_mav_put_int8_t_array(buf, 0, param_id, 15);
memcpy(_MAV_PAYLOAD(msg), buf, 23);
#else
mavlink_param_value_t packet;
packet.param_value = param_value;
packet.param_count = param_count;
packet.param_index = param_index;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
memcpy(_MAV_PAYLOAD(msg), &packet, 23);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_VALUE;
return mavlink_finalize_message(msg, system_id, component_id, 23);
}
/**
* @brief Pack a param_value message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param param_id Onboard parameter id
* @param param_value Onboard parameter value
* @param param_count Total number of onboard parameters
* @param param_index Index of this onboard parameter
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_param_value_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
const int8_t *param_id,float param_value,uint16_t param_count,uint16_t param_index)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[23];
_mav_put_float(buf, 15, param_value);
_mav_put_uint16_t(buf, 19, param_count);
_mav_put_uint16_t(buf, 21, param_index);
_mav_put_int8_t_array(buf, 0, param_id, 15);
memcpy(_MAV_PAYLOAD(msg), buf, 23);
#else
mavlink_param_value_t packet;
packet.param_value = param_value;
packet.param_count = param_count;
packet.param_index = param_index;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
memcpy(_MAV_PAYLOAD(msg), &packet, 23);
#endif
msg->msgid = MAVLINK_MSG_ID_PARAM_VALUE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 23);
}
/**
* @brief Encode a param_value struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param param_value C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_param_value_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_param_value_t* param_value)
{
return mavlink_msg_param_value_pack(system_id, component_id, msg, param_value->param_id, param_value->param_value, param_value->param_count, param_value->param_index);
}
/**
* @brief Send a param_value message
* @param chan MAVLink channel to send the message
*
* @param param_id Onboard parameter id
* @param param_value Onboard parameter value
* @param param_count Total number of onboard parameters
* @param param_index Index of this onboard parameter
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_param_value_send(mavlink_channel_t chan, const int8_t *param_id, float param_value, uint16_t param_count, uint16_t param_index)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[23];
_mav_put_float(buf, 15, param_value);
_mav_put_uint16_t(buf, 19, param_count);
_mav_put_uint16_t(buf, 21, param_index);
_mav_put_int8_t_array(buf, 0, param_id, 15);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_VALUE, buf, 23);
#else
mavlink_param_value_t packet;
packet.param_value = param_value;
packet.param_count = param_count;
packet.param_index = param_index;
mav_array_memcpy(packet.param_id, param_id, sizeof(int8_t)*15);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PARAM_VALUE, (const char *)&packet, 23);
#endif
}
#endif
// MESSAGE PARAM_VALUE UNPACKING
/**
* @brief Get field param_id from param_value message
*
* @return Onboard parameter id
*/
static inline uint16_t mavlink_msg_param_value_get_param_id(const mavlink_message_t* msg, int8_t *param_id)
{
return _MAV_RETURN_int8_t_array(msg, param_id, 15, 0);
}
/**
* @brief Get field param_value from param_value message
*
* @return Onboard parameter value
*/
static inline float mavlink_msg_param_value_get_param_value(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 15);
}
/**
* @brief Get field param_count from param_value message
*
* @return Total number of onboard parameters
*/
static inline uint16_t mavlink_msg_param_value_get_param_count(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 19);
}
/**
* @brief Get field param_index from param_value message
*
* @return Index of this onboard parameter
*/
static inline uint16_t mavlink_msg_param_value_get_param_index(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 21);
}
/**
* @brief Decode a param_value message into a struct
*
* @param msg The message to decode
* @param param_value C-struct to decode the message contents into
*/
static inline void mavlink_msg_param_value_decode(const mavlink_message_t* msg, mavlink_param_value_t* param_value)
{
#if MAVLINK_NEED_BYTE_SWAP
mavlink_msg_param_value_get_param_id(msg, param_value->param_id);
param_value->param_value = mavlink_msg_param_value_get_param_value(msg);
param_value->param_count = mavlink_msg_param_value_get_param_count(msg);
param_value->param_index = mavlink_msg_param_value_get_param_index(msg);
#else
memcpy(param_value, _MAV_PAYLOAD(msg), 23);
#endif
}
@@ -1,210 +0,0 @@
// MESSAGE PING PACKING
#define MAVLINK_MSG_ID_PING 3
typedef struct __mavlink_ping_t
{
uint32_t seq; ///< PING sequence
uint8_t target_system; ///< 0: request ping from all receiving systems, if greater than 0: message is a ping response and number is the system id of the requesting system
uint8_t target_component; ///< 0: request ping from all receiving components, if greater than 0: message is a ping response and number is the system id of the requesting system
uint64_t time; ///< Unix timestamp in microseconds
} mavlink_ping_t;
#define MAVLINK_MSG_ID_PING_LEN 14
#define MAVLINK_MSG_ID_3_LEN 14
#define MAVLINK_MESSAGE_INFO_PING { \
"PING", \
4, \
{ { "seq", NULL, MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_ping_t, seq) }, \
{ "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 4, offsetof(mavlink_ping_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_ping_t, target_component) }, \
{ "time", NULL, MAVLINK_TYPE_UINT64_T, 0, 6, offsetof(mavlink_ping_t, time) }, \
} \
}
/**
* @brief Pack a ping message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param seq PING sequence
* @param target_system 0: request ping from all receiving systems, if greater than 0: message is a ping response and number is the system id of the requesting system
* @param target_component 0: request ping from all receiving components, if greater than 0: message is a ping response and number is the system id of the requesting system
* @param time Unix timestamp in microseconds
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_ping_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint32_t seq, uint8_t target_system, uint8_t target_component, uint64_t time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint32_t(buf, 0, seq);
_mav_put_uint8_t(buf, 4, target_system);
_mav_put_uint8_t(buf, 5, target_component);
_mav_put_uint64_t(buf, 6, time);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_ping_t packet;
packet.seq = seq;
packet.target_system = target_system;
packet.target_component = target_component;
packet.time = time;
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_PING;
return mavlink_finalize_message(msg, system_id, component_id, 14);
}
/**
* @brief Pack a ping message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param seq PING sequence
* @param target_system 0: request ping from all receiving systems, if greater than 0: message is a ping response and number is the system id of the requesting system
* @param target_component 0: request ping from all receiving components, if greater than 0: message is a ping response and number is the system id of the requesting system
* @param time Unix timestamp in microseconds
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_ping_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint32_t seq,uint8_t target_system,uint8_t target_component,uint64_t time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint32_t(buf, 0, seq);
_mav_put_uint8_t(buf, 4, target_system);
_mav_put_uint8_t(buf, 5, target_component);
_mav_put_uint64_t(buf, 6, time);
memcpy(_MAV_PAYLOAD(msg), buf, 14);
#else
mavlink_ping_t packet;
packet.seq = seq;
packet.target_system = target_system;
packet.target_component = target_component;
packet.time = time;
memcpy(_MAV_PAYLOAD(msg), &packet, 14);
#endif
msg->msgid = MAVLINK_MSG_ID_PING;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 14);
}
/**
* @brief Encode a ping struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param ping C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_ping_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_ping_t* ping)
{
return mavlink_msg_ping_pack(system_id, component_id, msg, ping->seq, ping->target_system, ping->target_component, ping->time);
}
/**
* @brief Send a ping message
* @param chan MAVLink channel to send the message
*
* @param seq PING sequence
* @param target_system 0: request ping from all receiving systems, if greater than 0: message is a ping response and number is the system id of the requesting system
* @param target_component 0: request ping from all receiving components, if greater than 0: message is a ping response and number is the system id of the requesting system
* @param time Unix timestamp in microseconds
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_ping_send(mavlink_channel_t chan, uint32_t seq, uint8_t target_system, uint8_t target_component, uint64_t time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[14];
_mav_put_uint32_t(buf, 0, seq);
_mav_put_uint8_t(buf, 4, target_system);
_mav_put_uint8_t(buf, 5, target_component);
_mav_put_uint64_t(buf, 6, time);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, buf, 14);
#else
mavlink_ping_t packet;
packet.seq = seq;
packet.target_system = target_system;
packet.target_component = target_component;
packet.time = time;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, (const char *)&packet, 14);
#endif
}
#endif
// MESSAGE PING UNPACKING
/**
* @brief Get field seq from ping message
*
* @return PING sequence
*/
static inline uint32_t mavlink_msg_ping_get_seq(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 0);
}
/**
* @brief Get field target_system from ping message
*
* @return 0: request ping from all receiving systems, if greater than 0: message is a ping response and number is the system id of the requesting system
*/
static inline uint8_t mavlink_msg_ping_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 4);
}
/**
* @brief Get field target_component from ping message
*
* @return 0: request ping from all receiving components, if greater than 0: message is a ping response and number is the system id of the requesting system
*/
static inline uint8_t mavlink_msg_ping_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Get field time from ping message
*
* @return Unix timestamp in microseconds
*/
static inline uint64_t mavlink_msg_ping_get_time(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 6);
}
/**
* @brief Decode a ping message into a struct
*
* @param msg The message to decode
* @param ping C-struct to decode the message contents into
*/
static inline void mavlink_msg_ping_decode(const mavlink_message_t* msg, mavlink_ping_t* ping)
{
#if MAVLINK_NEED_BYTE_SWAP
ping->seq = mavlink_msg_ping_get_seq(msg);
ping->target_system = mavlink_msg_ping_get_target_system(msg);
ping->target_component = mavlink_msg_ping_get_target_component(msg);
ping->time = mavlink_msg_ping_get_time(msg);
#else
memcpy(ping, _MAV_PAYLOAD(msg), 14);
#endif
}
@@ -1,210 +0,0 @@
// MESSAGE POSITION_TARGET PACKING
#define MAVLINK_MSG_ID_POSITION_TARGET 63
typedef struct __mavlink_position_target_t
{
float x; ///< x position
float y; ///< y position
float z; ///< z position
float yaw; ///< yaw orientation in radians, 0 = NORTH
} mavlink_position_target_t;
#define MAVLINK_MSG_ID_POSITION_TARGET_LEN 16
#define MAVLINK_MSG_ID_63_LEN 16
#define MAVLINK_MESSAGE_INFO_POSITION_TARGET { \
"POSITION_TARGET", \
4, \
{ { "x", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_position_target_t, x) }, \
{ "y", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_position_target_t, y) }, \
{ "z", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_position_target_t, z) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_position_target_t, yaw) }, \
} \
}
/**
* @brief Pack a position_target message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param x x position
* @param y y position
* @param z z position
* @param yaw yaw orientation in radians, 0 = NORTH
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_position_target_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
float x, float y, float z, float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_float(buf, 0, x);
_mav_put_float(buf, 4, y);
_mav_put_float(buf, 8, z);
_mav_put_float(buf, 12, yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_position_target_t packet;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_POSITION_TARGET;
return mavlink_finalize_message(msg, system_id, component_id, 16);
}
/**
* @brief Pack a position_target message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param x x position
* @param y y position
* @param z z position
* @param yaw yaw orientation in radians, 0 = NORTH
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_position_target_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
float x,float y,float z,float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_float(buf, 0, x);
_mav_put_float(buf, 4, y);
_mav_put_float(buf, 8, z);
_mav_put_float(buf, 12, yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_position_target_t packet;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_POSITION_TARGET;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 16);
}
/**
* @brief Encode a position_target struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param position_target C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_position_target_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_position_target_t* position_target)
{
return mavlink_msg_position_target_pack(system_id, component_id, msg, position_target->x, position_target->y, position_target->z, position_target->yaw);
}
/**
* @brief Send a position_target message
* @param chan MAVLink channel to send the message
*
* @param x x position
* @param y y position
* @param z z position
* @param yaw yaw orientation in radians, 0 = NORTH
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_position_target_send(mavlink_channel_t chan, float x, float y, float z, float yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_float(buf, 0, x);
_mav_put_float(buf, 4, y);
_mav_put_float(buf, 8, z);
_mav_put_float(buf, 12, yaw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_POSITION_TARGET, buf, 16);
#else
mavlink_position_target_t packet;
packet.x = x;
packet.y = y;
packet.z = z;
packet.yaw = yaw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_POSITION_TARGET, (const char *)&packet, 16);
#endif
}
#endif
// MESSAGE POSITION_TARGET UNPACKING
/**
* @brief Get field x from position_target message
*
* @return x position
*/
static inline float mavlink_msg_position_target_get_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field y from position_target message
*
* @return y position
*/
static inline float mavlink_msg_position_target_get_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field z from position_target message
*
* @return z position
*/
static inline float mavlink_msg_position_target_get_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field yaw from position_target message
*
* @return yaw orientation in radians, 0 = NORTH
*/
static inline float mavlink_msg_position_target_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Decode a position_target message into a struct
*
* @param msg The message to decode
* @param position_target C-struct to decode the message contents into
*/
static inline void mavlink_msg_position_target_decode(const mavlink_message_t* msg, mavlink_position_target_t* position_target)
{
#if MAVLINK_NEED_BYTE_SWAP
position_target->x = mavlink_msg_position_target_get_x(msg);
position_target->y = mavlink_msg_position_target_get_y(msg);
position_target->z = mavlink_msg_position_target_get_z(msg);
position_target->yaw = mavlink_msg_position_target_get_yaw(msg);
#else
memcpy(position_target, _MAV_PAYLOAD(msg), 16);
#endif
}
@@ -1,342 +0,0 @@
// MESSAGE RAW_IMU PACKING
#define MAVLINK_MSG_ID_RAW_IMU 28
typedef struct __mavlink_raw_imu_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
int16_t xacc; ///< X acceleration (raw)
int16_t yacc; ///< Y acceleration (raw)
int16_t zacc; ///< Z acceleration (raw)
int16_t xgyro; ///< Angular speed around X axis (raw)
int16_t ygyro; ///< Angular speed around Y axis (raw)
int16_t zgyro; ///< Angular speed around Z axis (raw)
int16_t xmag; ///< X Magnetic field (raw)
int16_t ymag; ///< Y Magnetic field (raw)
int16_t zmag; ///< Z Magnetic field (raw)
} mavlink_raw_imu_t;
#define MAVLINK_MSG_ID_RAW_IMU_LEN 26
#define MAVLINK_MSG_ID_28_LEN 26
#define MAVLINK_MESSAGE_INFO_RAW_IMU { \
"RAW_IMU", \
10, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_raw_imu_t, usec) }, \
{ "xacc", NULL, MAVLINK_TYPE_INT16_T, 0, 8, offsetof(mavlink_raw_imu_t, xacc) }, \
{ "yacc", NULL, MAVLINK_TYPE_INT16_T, 0, 10, offsetof(mavlink_raw_imu_t, yacc) }, \
{ "zacc", NULL, MAVLINK_TYPE_INT16_T, 0, 12, offsetof(mavlink_raw_imu_t, zacc) }, \
{ "xgyro", NULL, MAVLINK_TYPE_INT16_T, 0, 14, offsetof(mavlink_raw_imu_t, xgyro) }, \
{ "ygyro", NULL, MAVLINK_TYPE_INT16_T, 0, 16, offsetof(mavlink_raw_imu_t, ygyro) }, \
{ "zgyro", NULL, MAVLINK_TYPE_INT16_T, 0, 18, offsetof(mavlink_raw_imu_t, zgyro) }, \
{ "xmag", NULL, MAVLINK_TYPE_INT16_T, 0, 20, offsetof(mavlink_raw_imu_t, xmag) }, \
{ "ymag", NULL, MAVLINK_TYPE_INT16_T, 0, 22, offsetof(mavlink_raw_imu_t, ymag) }, \
{ "zmag", NULL, MAVLINK_TYPE_INT16_T, 0, 24, offsetof(mavlink_raw_imu_t, zmag) }, \
} \
}
/**
* @brief Pack a raw_imu message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param xacc X acceleration (raw)
* @param yacc Y acceleration (raw)
* @param zacc Z acceleration (raw)
* @param xgyro Angular speed around X axis (raw)
* @param ygyro Angular speed around Y axis (raw)
* @param zgyro Angular speed around Z axis (raw)
* @param xmag X Magnetic field (raw)
* @param ymag Y Magnetic field (raw)
* @param zmag Z Magnetic field (raw)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_raw_imu_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, int16_t xacc, int16_t yacc, int16_t zacc, int16_t xgyro, int16_t ygyro, int16_t zgyro, int16_t xmag, int16_t ymag, int16_t zmag)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, xacc);
_mav_put_int16_t(buf, 10, yacc);
_mav_put_int16_t(buf, 12, zacc);
_mav_put_int16_t(buf, 14, xgyro);
_mav_put_int16_t(buf, 16, ygyro);
_mav_put_int16_t(buf, 18, zgyro);
_mav_put_int16_t(buf, 20, xmag);
_mav_put_int16_t(buf, 22, ymag);
_mav_put_int16_t(buf, 24, zmag);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_raw_imu_t packet;
packet.usec = usec;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
packet.xgyro = xgyro;
packet.ygyro = ygyro;
packet.zgyro = zgyro;
packet.xmag = xmag;
packet.ymag = ymag;
packet.zmag = zmag;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_RAW_IMU;
return mavlink_finalize_message(msg, system_id, component_id, 26);
}
/**
* @brief Pack a raw_imu message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param xacc X acceleration (raw)
* @param yacc Y acceleration (raw)
* @param zacc Z acceleration (raw)
* @param xgyro Angular speed around X axis (raw)
* @param ygyro Angular speed around Y axis (raw)
* @param zgyro Angular speed around Z axis (raw)
* @param xmag X Magnetic field (raw)
* @param ymag Y Magnetic field (raw)
* @param zmag Z Magnetic field (raw)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_raw_imu_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,int16_t xacc,int16_t yacc,int16_t zacc,int16_t xgyro,int16_t ygyro,int16_t zgyro,int16_t xmag,int16_t ymag,int16_t zmag)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, xacc);
_mav_put_int16_t(buf, 10, yacc);
_mav_put_int16_t(buf, 12, zacc);
_mav_put_int16_t(buf, 14, xgyro);
_mav_put_int16_t(buf, 16, ygyro);
_mav_put_int16_t(buf, 18, zgyro);
_mav_put_int16_t(buf, 20, xmag);
_mav_put_int16_t(buf, 22, ymag);
_mav_put_int16_t(buf, 24, zmag);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_raw_imu_t packet;
packet.usec = usec;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
packet.xgyro = xgyro;
packet.ygyro = ygyro;
packet.zgyro = zgyro;
packet.xmag = xmag;
packet.ymag = ymag;
packet.zmag = zmag;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_RAW_IMU;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 26);
}
/**
* @brief Encode a raw_imu struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param raw_imu C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_raw_imu_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_raw_imu_t* raw_imu)
{
return mavlink_msg_raw_imu_pack(system_id, component_id, msg, raw_imu->usec, raw_imu->xacc, raw_imu->yacc, raw_imu->zacc, raw_imu->xgyro, raw_imu->ygyro, raw_imu->zgyro, raw_imu->xmag, raw_imu->ymag, raw_imu->zmag);
}
/**
* @brief Send a raw_imu message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param xacc X acceleration (raw)
* @param yacc Y acceleration (raw)
* @param zacc Z acceleration (raw)
* @param xgyro Angular speed around X axis (raw)
* @param ygyro Angular speed around Y axis (raw)
* @param zgyro Angular speed around Z axis (raw)
* @param xmag X Magnetic field (raw)
* @param ymag Y Magnetic field (raw)
* @param zmag Z Magnetic field (raw)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_raw_imu_send(mavlink_channel_t chan, uint64_t usec, int16_t xacc, int16_t yacc, int16_t zacc, int16_t xgyro, int16_t ygyro, int16_t zgyro, int16_t xmag, int16_t ymag, int16_t zmag)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, xacc);
_mav_put_int16_t(buf, 10, yacc);
_mav_put_int16_t(buf, 12, zacc);
_mav_put_int16_t(buf, 14, xgyro);
_mav_put_int16_t(buf, 16, ygyro);
_mav_put_int16_t(buf, 18, zgyro);
_mav_put_int16_t(buf, 20, xmag);
_mav_put_int16_t(buf, 22, ymag);
_mav_put_int16_t(buf, 24, zmag);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RAW_IMU, buf, 26);
#else
mavlink_raw_imu_t packet;
packet.usec = usec;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
packet.xgyro = xgyro;
packet.ygyro = ygyro;
packet.zgyro = zgyro;
packet.xmag = xmag;
packet.ymag = ymag;
packet.zmag = zmag;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RAW_IMU, (const char *)&packet, 26);
#endif
}
#endif
// MESSAGE RAW_IMU UNPACKING
/**
* @brief Get field usec from raw_imu message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_raw_imu_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field xacc from raw_imu message
*
* @return X acceleration (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_xacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 8);
}
/**
* @brief Get field yacc from raw_imu message
*
* @return Y acceleration (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_yacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 10);
}
/**
* @brief Get field zacc from raw_imu message
*
* @return Z acceleration (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_zacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 12);
}
/**
* @brief Get field xgyro from raw_imu message
*
* @return Angular speed around X axis (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_xgyro(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 14);
}
/**
* @brief Get field ygyro from raw_imu message
*
* @return Angular speed around Y axis (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_ygyro(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 16);
}
/**
* @brief Get field zgyro from raw_imu message
*
* @return Angular speed around Z axis (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_zgyro(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 18);
}
/**
* @brief Get field xmag from raw_imu message
*
* @return X Magnetic field (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_xmag(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 20);
}
/**
* @brief Get field ymag from raw_imu message
*
* @return Y Magnetic field (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_ymag(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 22);
}
/**
* @brief Get field zmag from raw_imu message
*
* @return Z Magnetic field (raw)
*/
static inline int16_t mavlink_msg_raw_imu_get_zmag(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 24);
}
/**
* @brief Decode a raw_imu message into a struct
*
* @param msg The message to decode
* @param raw_imu C-struct to decode the message contents into
*/
static inline void mavlink_msg_raw_imu_decode(const mavlink_message_t* msg, mavlink_raw_imu_t* raw_imu)
{
#if MAVLINK_NEED_BYTE_SWAP
raw_imu->usec = mavlink_msg_raw_imu_get_usec(msg);
raw_imu->xacc = mavlink_msg_raw_imu_get_xacc(msg);
raw_imu->yacc = mavlink_msg_raw_imu_get_yacc(msg);
raw_imu->zacc = mavlink_msg_raw_imu_get_zacc(msg);
raw_imu->xgyro = mavlink_msg_raw_imu_get_xgyro(msg);
raw_imu->ygyro = mavlink_msg_raw_imu_get_ygyro(msg);
raw_imu->zgyro = mavlink_msg_raw_imu_get_zgyro(msg);
raw_imu->xmag = mavlink_msg_raw_imu_get_xmag(msg);
raw_imu->ymag = mavlink_msg_raw_imu_get_ymag(msg);
raw_imu->zmag = mavlink_msg_raw_imu_get_zmag(msg);
#else
memcpy(raw_imu, _MAV_PAYLOAD(msg), 26);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE RAW_PRESSURE PACKING
#define MAVLINK_MSG_ID_RAW_PRESSURE 29
typedef struct __mavlink_raw_pressure_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
int16_t press_abs; ///< Absolute pressure (raw)
int16_t press_diff1; ///< Differential pressure 1 (raw)
int16_t press_diff2; ///< Differential pressure 2 (raw)
int16_t temperature; ///< Raw Temperature measurement (raw)
} mavlink_raw_pressure_t;
#define MAVLINK_MSG_ID_RAW_PRESSURE_LEN 16
#define MAVLINK_MSG_ID_29_LEN 16
#define MAVLINK_MESSAGE_INFO_RAW_PRESSURE { \
"RAW_PRESSURE", \
5, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_raw_pressure_t, usec) }, \
{ "press_abs", NULL, MAVLINK_TYPE_INT16_T, 0, 8, offsetof(mavlink_raw_pressure_t, press_abs) }, \
{ "press_diff1", NULL, MAVLINK_TYPE_INT16_T, 0, 10, offsetof(mavlink_raw_pressure_t, press_diff1) }, \
{ "press_diff2", NULL, MAVLINK_TYPE_INT16_T, 0, 12, offsetof(mavlink_raw_pressure_t, press_diff2) }, \
{ "temperature", NULL, MAVLINK_TYPE_INT16_T, 0, 14, offsetof(mavlink_raw_pressure_t, temperature) }, \
} \
}
/**
* @brief Pack a raw_pressure message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param press_abs Absolute pressure (raw)
* @param press_diff1 Differential pressure 1 (raw)
* @param press_diff2 Differential pressure 2 (raw)
* @param temperature Raw Temperature measurement (raw)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_raw_pressure_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, int16_t press_abs, int16_t press_diff1, int16_t press_diff2, int16_t temperature)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, press_abs);
_mav_put_int16_t(buf, 10, press_diff1);
_mav_put_int16_t(buf, 12, press_diff2);
_mav_put_int16_t(buf, 14, temperature);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_raw_pressure_t packet;
packet.usec = usec;
packet.press_abs = press_abs;
packet.press_diff1 = press_diff1;
packet.press_diff2 = press_diff2;
packet.temperature = temperature;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_RAW_PRESSURE;
return mavlink_finalize_message(msg, system_id, component_id, 16);
}
/**
* @brief Pack a raw_pressure message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param press_abs Absolute pressure (raw)
* @param press_diff1 Differential pressure 1 (raw)
* @param press_diff2 Differential pressure 2 (raw)
* @param temperature Raw Temperature measurement (raw)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_raw_pressure_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,int16_t press_abs,int16_t press_diff1,int16_t press_diff2,int16_t temperature)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, press_abs);
_mav_put_int16_t(buf, 10, press_diff1);
_mav_put_int16_t(buf, 12, press_diff2);
_mav_put_int16_t(buf, 14, temperature);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_raw_pressure_t packet;
packet.usec = usec;
packet.press_abs = press_abs;
packet.press_diff1 = press_diff1;
packet.press_diff2 = press_diff2;
packet.temperature = temperature;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_RAW_PRESSURE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 16);
}
/**
* @brief Encode a raw_pressure struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param raw_pressure C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_raw_pressure_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_raw_pressure_t* raw_pressure)
{
return mavlink_msg_raw_pressure_pack(system_id, component_id, msg, raw_pressure->usec, raw_pressure->press_abs, raw_pressure->press_diff1, raw_pressure->press_diff2, raw_pressure->temperature);
}
/**
* @brief Send a raw_pressure message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param press_abs Absolute pressure (raw)
* @param press_diff1 Differential pressure 1 (raw)
* @param press_diff2 Differential pressure 2 (raw)
* @param temperature Raw Temperature measurement (raw)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_raw_pressure_send(mavlink_channel_t chan, uint64_t usec, int16_t press_abs, int16_t press_diff1, int16_t press_diff2, int16_t temperature)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, press_abs);
_mav_put_int16_t(buf, 10, press_diff1);
_mav_put_int16_t(buf, 12, press_diff2);
_mav_put_int16_t(buf, 14, temperature);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RAW_PRESSURE, buf, 16);
#else
mavlink_raw_pressure_t packet;
packet.usec = usec;
packet.press_abs = press_abs;
packet.press_diff1 = press_diff1;
packet.press_diff2 = press_diff2;
packet.temperature = temperature;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RAW_PRESSURE, (const char *)&packet, 16);
#endif
}
#endif
// MESSAGE RAW_PRESSURE UNPACKING
/**
* @brief Get field usec from raw_pressure message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_raw_pressure_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field press_abs from raw_pressure message
*
* @return Absolute pressure (raw)
*/
static inline int16_t mavlink_msg_raw_pressure_get_press_abs(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 8);
}
/**
* @brief Get field press_diff1 from raw_pressure message
*
* @return Differential pressure 1 (raw)
*/
static inline int16_t mavlink_msg_raw_pressure_get_press_diff1(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 10);
}
/**
* @brief Get field press_diff2 from raw_pressure message
*
* @return Differential pressure 2 (raw)
*/
static inline int16_t mavlink_msg_raw_pressure_get_press_diff2(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 12);
}
/**
* @brief Get field temperature from raw_pressure message
*
* @return Raw Temperature measurement (raw)
*/
static inline int16_t mavlink_msg_raw_pressure_get_temperature(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 14);
}
/**
* @brief Decode a raw_pressure message into a struct
*
* @param msg The message to decode
* @param raw_pressure C-struct to decode the message contents into
*/
static inline void mavlink_msg_raw_pressure_decode(const mavlink_message_t* msg, mavlink_raw_pressure_t* raw_pressure)
{
#if MAVLINK_NEED_BYTE_SWAP
raw_pressure->usec = mavlink_msg_raw_pressure_get_usec(msg);
raw_pressure->press_abs = mavlink_msg_raw_pressure_get_press_abs(msg);
raw_pressure->press_diff1 = mavlink_msg_raw_pressure_get_press_diff1(msg);
raw_pressure->press_diff2 = mavlink_msg_raw_pressure_get_press_diff2(msg);
raw_pressure->temperature = mavlink_msg_raw_pressure_get_temperature(msg);
#else
memcpy(raw_pressure, _MAV_PAYLOAD(msg), 16);
#endif
}
@@ -1,342 +0,0 @@
// MESSAGE RC_CHANNELS_OVERRIDE PACKING
#define MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE 70
typedef struct __mavlink_rc_channels_override_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint16_t chan1_raw; ///< RC channel 1 value, in microseconds
uint16_t chan2_raw; ///< RC channel 2 value, in microseconds
uint16_t chan3_raw; ///< RC channel 3 value, in microseconds
uint16_t chan4_raw; ///< RC channel 4 value, in microseconds
uint16_t chan5_raw; ///< RC channel 5 value, in microseconds
uint16_t chan6_raw; ///< RC channel 6 value, in microseconds
uint16_t chan7_raw; ///< RC channel 7 value, in microseconds
uint16_t chan8_raw; ///< RC channel 8 value, in microseconds
} mavlink_rc_channels_override_t;
#define MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE_LEN 18
#define MAVLINK_MSG_ID_70_LEN 18
#define MAVLINK_MESSAGE_INFO_RC_CHANNELS_OVERRIDE { \
"RC_CHANNELS_OVERRIDE", \
10, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_rc_channels_override_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_rc_channels_override_t, target_component) }, \
{ "chan1_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_rc_channels_override_t, chan1_raw) }, \
{ "chan2_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 4, offsetof(mavlink_rc_channels_override_t, chan2_raw) }, \
{ "chan3_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 6, offsetof(mavlink_rc_channels_override_t, chan3_raw) }, \
{ "chan4_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 8, offsetof(mavlink_rc_channels_override_t, chan4_raw) }, \
{ "chan5_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 10, offsetof(mavlink_rc_channels_override_t, chan5_raw) }, \
{ "chan6_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 12, offsetof(mavlink_rc_channels_override_t, chan6_raw) }, \
{ "chan7_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 14, offsetof(mavlink_rc_channels_override_t, chan7_raw) }, \
{ "chan8_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 16, offsetof(mavlink_rc_channels_override_t, chan8_raw) }, \
} \
}
/**
* @brief Pack a rc_channels_override message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param chan1_raw RC channel 1 value, in microseconds
* @param chan2_raw RC channel 2 value, in microseconds
* @param chan3_raw RC channel 3 value, in microseconds
* @param chan4_raw RC channel 4 value, in microseconds
* @param chan5_raw RC channel 5 value, in microseconds
* @param chan6_raw RC channel 6 value, in microseconds
* @param chan7_raw RC channel 7 value, in microseconds
* @param chan8_raw RC channel 8 value, in microseconds
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_rc_channels_override_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint16_t chan1_raw, uint16_t chan2_raw, uint16_t chan3_raw, uint16_t chan4_raw, uint16_t chan5_raw, uint16_t chan6_raw, uint16_t chan7_raw, uint16_t chan8_raw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, chan1_raw);
_mav_put_uint16_t(buf, 4, chan2_raw);
_mav_put_uint16_t(buf, 6, chan3_raw);
_mav_put_uint16_t(buf, 8, chan4_raw);
_mav_put_uint16_t(buf, 10, chan5_raw);
_mav_put_uint16_t(buf, 12, chan6_raw);
_mav_put_uint16_t(buf, 14, chan7_raw);
_mav_put_uint16_t(buf, 16, chan8_raw);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_rc_channels_override_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.chan1_raw = chan1_raw;
packet.chan2_raw = chan2_raw;
packet.chan3_raw = chan3_raw;
packet.chan4_raw = chan4_raw;
packet.chan5_raw = chan5_raw;
packet.chan6_raw = chan6_raw;
packet.chan7_raw = chan7_raw;
packet.chan8_raw = chan8_raw;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a rc_channels_override message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param chan1_raw RC channel 1 value, in microseconds
* @param chan2_raw RC channel 2 value, in microseconds
* @param chan3_raw RC channel 3 value, in microseconds
* @param chan4_raw RC channel 4 value, in microseconds
* @param chan5_raw RC channel 5 value, in microseconds
* @param chan6_raw RC channel 6 value, in microseconds
* @param chan7_raw RC channel 7 value, in microseconds
* @param chan8_raw RC channel 8 value, in microseconds
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_rc_channels_override_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint16_t chan1_raw,uint16_t chan2_raw,uint16_t chan3_raw,uint16_t chan4_raw,uint16_t chan5_raw,uint16_t chan6_raw,uint16_t chan7_raw,uint16_t chan8_raw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, chan1_raw);
_mav_put_uint16_t(buf, 4, chan2_raw);
_mav_put_uint16_t(buf, 6, chan3_raw);
_mav_put_uint16_t(buf, 8, chan4_raw);
_mav_put_uint16_t(buf, 10, chan5_raw);
_mav_put_uint16_t(buf, 12, chan6_raw);
_mav_put_uint16_t(buf, 14, chan7_raw);
_mav_put_uint16_t(buf, 16, chan8_raw);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_rc_channels_override_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.chan1_raw = chan1_raw;
packet.chan2_raw = chan2_raw;
packet.chan3_raw = chan3_raw;
packet.chan4_raw = chan4_raw;
packet.chan5_raw = chan5_raw;
packet.chan6_raw = chan6_raw;
packet.chan7_raw = chan7_raw;
packet.chan8_raw = chan8_raw;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a rc_channels_override struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param rc_channels_override C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_rc_channels_override_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_rc_channels_override_t* rc_channels_override)
{
return mavlink_msg_rc_channels_override_pack(system_id, component_id, msg, rc_channels_override->target_system, rc_channels_override->target_component, rc_channels_override->chan1_raw, rc_channels_override->chan2_raw, rc_channels_override->chan3_raw, rc_channels_override->chan4_raw, rc_channels_override->chan5_raw, rc_channels_override->chan6_raw, rc_channels_override->chan7_raw, rc_channels_override->chan8_raw);
}
/**
* @brief Send a rc_channels_override message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param chan1_raw RC channel 1 value, in microseconds
* @param chan2_raw RC channel 2 value, in microseconds
* @param chan3_raw RC channel 3 value, in microseconds
* @param chan4_raw RC channel 4 value, in microseconds
* @param chan5_raw RC channel 5 value, in microseconds
* @param chan6_raw RC channel 6 value, in microseconds
* @param chan7_raw RC channel 7 value, in microseconds
* @param chan8_raw RC channel 8 value, in microseconds
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_rc_channels_override_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t chan1_raw, uint16_t chan2_raw, uint16_t chan3_raw, uint16_t chan4_raw, uint16_t chan5_raw, uint16_t chan6_raw, uint16_t chan7_raw, uint16_t chan8_raw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, chan1_raw);
_mav_put_uint16_t(buf, 4, chan2_raw);
_mav_put_uint16_t(buf, 6, chan3_raw);
_mav_put_uint16_t(buf, 8, chan4_raw);
_mav_put_uint16_t(buf, 10, chan5_raw);
_mav_put_uint16_t(buf, 12, chan6_raw);
_mav_put_uint16_t(buf, 14, chan7_raw);
_mav_put_uint16_t(buf, 16, chan8_raw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE, buf, 18);
#else
mavlink_rc_channels_override_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.chan1_raw = chan1_raw;
packet.chan2_raw = chan2_raw;
packet.chan3_raw = chan3_raw;
packet.chan4_raw = chan4_raw;
packet.chan5_raw = chan5_raw;
packet.chan6_raw = chan6_raw;
packet.chan7_raw = chan7_raw;
packet.chan8_raw = chan8_raw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE RC_CHANNELS_OVERRIDE UNPACKING
/**
* @brief Get field target_system from rc_channels_override message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_rc_channels_override_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from rc_channels_override message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_rc_channels_override_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field chan1_raw from rc_channels_override message
*
* @return RC channel 1 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan1_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Get field chan2_raw from rc_channels_override message
*
* @return RC channel 2 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan2_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 4);
}
/**
* @brief Get field chan3_raw from rc_channels_override message
*
* @return RC channel 3 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan3_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 6);
}
/**
* @brief Get field chan4_raw from rc_channels_override message
*
* @return RC channel 4 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan4_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 8);
}
/**
* @brief Get field chan5_raw from rc_channels_override message
*
* @return RC channel 5 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan5_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 10);
}
/**
* @brief Get field chan6_raw from rc_channels_override message
*
* @return RC channel 6 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan6_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 12);
}
/**
* @brief Get field chan7_raw from rc_channels_override message
*
* @return RC channel 7 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan7_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 14);
}
/**
* @brief Get field chan8_raw from rc_channels_override message
*
* @return RC channel 8 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_override_get_chan8_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 16);
}
/**
* @brief Decode a rc_channels_override message into a struct
*
* @param msg The message to decode
* @param rc_channels_override C-struct to decode the message contents into
*/
static inline void mavlink_msg_rc_channels_override_decode(const mavlink_message_t* msg, mavlink_rc_channels_override_t* rc_channels_override)
{
#if MAVLINK_NEED_BYTE_SWAP
rc_channels_override->target_system = mavlink_msg_rc_channels_override_get_target_system(msg);
rc_channels_override->target_component = mavlink_msg_rc_channels_override_get_target_component(msg);
rc_channels_override->chan1_raw = mavlink_msg_rc_channels_override_get_chan1_raw(msg);
rc_channels_override->chan2_raw = mavlink_msg_rc_channels_override_get_chan2_raw(msg);
rc_channels_override->chan3_raw = mavlink_msg_rc_channels_override_get_chan3_raw(msg);
rc_channels_override->chan4_raw = mavlink_msg_rc_channels_override_get_chan4_raw(msg);
rc_channels_override->chan5_raw = mavlink_msg_rc_channels_override_get_chan5_raw(msg);
rc_channels_override->chan6_raw = mavlink_msg_rc_channels_override_get_chan6_raw(msg);
rc_channels_override->chan7_raw = mavlink_msg_rc_channels_override_get_chan7_raw(msg);
rc_channels_override->chan8_raw = mavlink_msg_rc_channels_override_get_chan8_raw(msg);
#else
memcpy(rc_channels_override, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE RC_CHANNELS_RAW PACKING
#define MAVLINK_MSG_ID_RC_CHANNELS_RAW 35
typedef struct __mavlink_rc_channels_raw_t
{
uint16_t chan1_raw; ///< RC channel 1 value, in microseconds
uint16_t chan2_raw; ///< RC channel 2 value, in microseconds
uint16_t chan3_raw; ///< RC channel 3 value, in microseconds
uint16_t chan4_raw; ///< RC channel 4 value, in microseconds
uint16_t chan5_raw; ///< RC channel 5 value, in microseconds
uint16_t chan6_raw; ///< RC channel 6 value, in microseconds
uint16_t chan7_raw; ///< RC channel 7 value, in microseconds
uint16_t chan8_raw; ///< RC channel 8 value, in microseconds
uint8_t rssi; ///< Receive signal strength indicator, 0: 0%, 255: 100%
} mavlink_rc_channels_raw_t;
#define MAVLINK_MSG_ID_RC_CHANNELS_RAW_LEN 17
#define MAVLINK_MSG_ID_35_LEN 17
#define MAVLINK_MESSAGE_INFO_RC_CHANNELS_RAW { \
"RC_CHANNELS_RAW", \
9, \
{ { "chan1_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_rc_channels_raw_t, chan1_raw) }, \
{ "chan2_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_rc_channels_raw_t, chan2_raw) }, \
{ "chan3_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 4, offsetof(mavlink_rc_channels_raw_t, chan3_raw) }, \
{ "chan4_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 6, offsetof(mavlink_rc_channels_raw_t, chan4_raw) }, \
{ "chan5_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 8, offsetof(mavlink_rc_channels_raw_t, chan5_raw) }, \
{ "chan6_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 10, offsetof(mavlink_rc_channels_raw_t, chan6_raw) }, \
{ "chan7_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 12, offsetof(mavlink_rc_channels_raw_t, chan7_raw) }, \
{ "chan8_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 14, offsetof(mavlink_rc_channels_raw_t, chan8_raw) }, \
{ "rssi", NULL, MAVLINK_TYPE_UINT8_T, 0, 16, offsetof(mavlink_rc_channels_raw_t, rssi) }, \
} \
}
/**
* @brief Pack a rc_channels_raw message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param chan1_raw RC channel 1 value, in microseconds
* @param chan2_raw RC channel 2 value, in microseconds
* @param chan3_raw RC channel 3 value, in microseconds
* @param chan4_raw RC channel 4 value, in microseconds
* @param chan5_raw RC channel 5 value, in microseconds
* @param chan6_raw RC channel 6 value, in microseconds
* @param chan7_raw RC channel 7 value, in microseconds
* @param chan8_raw RC channel 8 value, in microseconds
* @param rssi Receive signal strength indicator, 0: 0%, 255: 100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_rc_channels_raw_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint16_t chan1_raw, uint16_t chan2_raw, uint16_t chan3_raw, uint16_t chan4_raw, uint16_t chan5_raw, uint16_t chan6_raw, uint16_t chan7_raw, uint16_t chan8_raw, uint8_t rssi)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[17];
_mav_put_uint16_t(buf, 0, chan1_raw);
_mav_put_uint16_t(buf, 2, chan2_raw);
_mav_put_uint16_t(buf, 4, chan3_raw);
_mav_put_uint16_t(buf, 6, chan4_raw);
_mav_put_uint16_t(buf, 8, chan5_raw);
_mav_put_uint16_t(buf, 10, chan6_raw);
_mav_put_uint16_t(buf, 12, chan7_raw);
_mav_put_uint16_t(buf, 14, chan8_raw);
_mav_put_uint8_t(buf, 16, rssi);
memcpy(_MAV_PAYLOAD(msg), buf, 17);
#else
mavlink_rc_channels_raw_t packet;
packet.chan1_raw = chan1_raw;
packet.chan2_raw = chan2_raw;
packet.chan3_raw = chan3_raw;
packet.chan4_raw = chan4_raw;
packet.chan5_raw = chan5_raw;
packet.chan6_raw = chan6_raw;
packet.chan7_raw = chan7_raw;
packet.chan8_raw = chan8_raw;
packet.rssi = rssi;
memcpy(_MAV_PAYLOAD(msg), &packet, 17);
#endif
msg->msgid = MAVLINK_MSG_ID_RC_CHANNELS_RAW;
return mavlink_finalize_message(msg, system_id, component_id, 17);
}
/**
* @brief Pack a rc_channels_raw message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param chan1_raw RC channel 1 value, in microseconds
* @param chan2_raw RC channel 2 value, in microseconds
* @param chan3_raw RC channel 3 value, in microseconds
* @param chan4_raw RC channel 4 value, in microseconds
* @param chan5_raw RC channel 5 value, in microseconds
* @param chan6_raw RC channel 6 value, in microseconds
* @param chan7_raw RC channel 7 value, in microseconds
* @param chan8_raw RC channel 8 value, in microseconds
* @param rssi Receive signal strength indicator, 0: 0%, 255: 100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_rc_channels_raw_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint16_t chan1_raw,uint16_t chan2_raw,uint16_t chan3_raw,uint16_t chan4_raw,uint16_t chan5_raw,uint16_t chan6_raw,uint16_t chan7_raw,uint16_t chan8_raw,uint8_t rssi)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[17];
_mav_put_uint16_t(buf, 0, chan1_raw);
_mav_put_uint16_t(buf, 2, chan2_raw);
_mav_put_uint16_t(buf, 4, chan3_raw);
_mav_put_uint16_t(buf, 6, chan4_raw);
_mav_put_uint16_t(buf, 8, chan5_raw);
_mav_put_uint16_t(buf, 10, chan6_raw);
_mav_put_uint16_t(buf, 12, chan7_raw);
_mav_put_uint16_t(buf, 14, chan8_raw);
_mav_put_uint8_t(buf, 16, rssi);
memcpy(_MAV_PAYLOAD(msg), buf, 17);
#else
mavlink_rc_channels_raw_t packet;
packet.chan1_raw = chan1_raw;
packet.chan2_raw = chan2_raw;
packet.chan3_raw = chan3_raw;
packet.chan4_raw = chan4_raw;
packet.chan5_raw = chan5_raw;
packet.chan6_raw = chan6_raw;
packet.chan7_raw = chan7_raw;
packet.chan8_raw = chan8_raw;
packet.rssi = rssi;
memcpy(_MAV_PAYLOAD(msg), &packet, 17);
#endif
msg->msgid = MAVLINK_MSG_ID_RC_CHANNELS_RAW;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 17);
}
/**
* @brief Encode a rc_channels_raw struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param rc_channels_raw C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_rc_channels_raw_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_rc_channels_raw_t* rc_channels_raw)
{
return mavlink_msg_rc_channels_raw_pack(system_id, component_id, msg, rc_channels_raw->chan1_raw, rc_channels_raw->chan2_raw, rc_channels_raw->chan3_raw, rc_channels_raw->chan4_raw, rc_channels_raw->chan5_raw, rc_channels_raw->chan6_raw, rc_channels_raw->chan7_raw, rc_channels_raw->chan8_raw, rc_channels_raw->rssi);
}
/**
* @brief Send a rc_channels_raw message
* @param chan MAVLink channel to send the message
*
* @param chan1_raw RC channel 1 value, in microseconds
* @param chan2_raw RC channel 2 value, in microseconds
* @param chan3_raw RC channel 3 value, in microseconds
* @param chan4_raw RC channel 4 value, in microseconds
* @param chan5_raw RC channel 5 value, in microseconds
* @param chan6_raw RC channel 6 value, in microseconds
* @param chan7_raw RC channel 7 value, in microseconds
* @param chan8_raw RC channel 8 value, in microseconds
* @param rssi Receive signal strength indicator, 0: 0%, 255: 100%
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_rc_channels_raw_send(mavlink_channel_t chan, uint16_t chan1_raw, uint16_t chan2_raw, uint16_t chan3_raw, uint16_t chan4_raw, uint16_t chan5_raw, uint16_t chan6_raw, uint16_t chan7_raw, uint16_t chan8_raw, uint8_t rssi)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[17];
_mav_put_uint16_t(buf, 0, chan1_raw);
_mav_put_uint16_t(buf, 2, chan2_raw);
_mav_put_uint16_t(buf, 4, chan3_raw);
_mav_put_uint16_t(buf, 6, chan4_raw);
_mav_put_uint16_t(buf, 8, chan5_raw);
_mav_put_uint16_t(buf, 10, chan6_raw);
_mav_put_uint16_t(buf, 12, chan7_raw);
_mav_put_uint16_t(buf, 14, chan8_raw);
_mav_put_uint8_t(buf, 16, rssi);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RC_CHANNELS_RAW, buf, 17);
#else
mavlink_rc_channels_raw_t packet;
packet.chan1_raw = chan1_raw;
packet.chan2_raw = chan2_raw;
packet.chan3_raw = chan3_raw;
packet.chan4_raw = chan4_raw;
packet.chan5_raw = chan5_raw;
packet.chan6_raw = chan6_raw;
packet.chan7_raw = chan7_raw;
packet.chan8_raw = chan8_raw;
packet.rssi = rssi;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RC_CHANNELS_RAW, (const char *)&packet, 17);
#endif
}
#endif
// MESSAGE RC_CHANNELS_RAW UNPACKING
/**
* @brief Get field chan1_raw from rc_channels_raw message
*
* @return RC channel 1 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan1_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 0);
}
/**
* @brief Get field chan2_raw from rc_channels_raw message
*
* @return RC channel 2 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan2_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Get field chan3_raw from rc_channels_raw message
*
* @return RC channel 3 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan3_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 4);
}
/**
* @brief Get field chan4_raw from rc_channels_raw message
*
* @return RC channel 4 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan4_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 6);
}
/**
* @brief Get field chan5_raw from rc_channels_raw message
*
* @return RC channel 5 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan5_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 8);
}
/**
* @brief Get field chan6_raw from rc_channels_raw message
*
* @return RC channel 6 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan6_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 10);
}
/**
* @brief Get field chan7_raw from rc_channels_raw message
*
* @return RC channel 7 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan7_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 12);
}
/**
* @brief Get field chan8_raw from rc_channels_raw message
*
* @return RC channel 8 value, in microseconds
*/
static inline uint16_t mavlink_msg_rc_channels_raw_get_chan8_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 14);
}
/**
* @brief Get field rssi from rc_channels_raw message
*
* @return Receive signal strength indicator, 0: 0%, 255: 100%
*/
static inline uint8_t mavlink_msg_rc_channels_raw_get_rssi(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 16);
}
/**
* @brief Decode a rc_channels_raw message into a struct
*
* @param msg The message to decode
* @param rc_channels_raw C-struct to decode the message contents into
*/
static inline void mavlink_msg_rc_channels_raw_decode(const mavlink_message_t* msg, mavlink_rc_channels_raw_t* rc_channels_raw)
{
#if MAVLINK_NEED_BYTE_SWAP
rc_channels_raw->chan1_raw = mavlink_msg_rc_channels_raw_get_chan1_raw(msg);
rc_channels_raw->chan2_raw = mavlink_msg_rc_channels_raw_get_chan2_raw(msg);
rc_channels_raw->chan3_raw = mavlink_msg_rc_channels_raw_get_chan3_raw(msg);
rc_channels_raw->chan4_raw = mavlink_msg_rc_channels_raw_get_chan4_raw(msg);
rc_channels_raw->chan5_raw = mavlink_msg_rc_channels_raw_get_chan5_raw(msg);
rc_channels_raw->chan6_raw = mavlink_msg_rc_channels_raw_get_chan6_raw(msg);
rc_channels_raw->chan7_raw = mavlink_msg_rc_channels_raw_get_chan7_raw(msg);
rc_channels_raw->chan8_raw = mavlink_msg_rc_channels_raw_get_chan8_raw(msg);
rc_channels_raw->rssi = mavlink_msg_rc_channels_raw_get_rssi(msg);
#else
memcpy(rc_channels_raw, _MAV_PAYLOAD(msg), 17);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE RC_CHANNELS_SCALED PACKING
#define MAVLINK_MSG_ID_RC_CHANNELS_SCALED 36
typedef struct __mavlink_rc_channels_scaled_t
{
int16_t chan1_scaled; ///< RC channel 1 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan2_scaled; ///< RC channel 2 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan3_scaled; ///< RC channel 3 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan4_scaled; ///< RC channel 4 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan5_scaled; ///< RC channel 5 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan6_scaled; ///< RC channel 6 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan7_scaled; ///< RC channel 7 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
int16_t chan8_scaled; ///< RC channel 8 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
uint8_t rssi; ///< Receive signal strength indicator, 0: 0%, 255: 100%
} mavlink_rc_channels_scaled_t;
#define MAVLINK_MSG_ID_RC_CHANNELS_SCALED_LEN 17
#define MAVLINK_MSG_ID_36_LEN 17
#define MAVLINK_MESSAGE_INFO_RC_CHANNELS_SCALED { \
"RC_CHANNELS_SCALED", \
9, \
{ { "chan1_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 0, offsetof(mavlink_rc_channels_scaled_t, chan1_scaled) }, \
{ "chan2_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 2, offsetof(mavlink_rc_channels_scaled_t, chan2_scaled) }, \
{ "chan3_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 4, offsetof(mavlink_rc_channels_scaled_t, chan3_scaled) }, \
{ "chan4_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 6, offsetof(mavlink_rc_channels_scaled_t, chan4_scaled) }, \
{ "chan5_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 8, offsetof(mavlink_rc_channels_scaled_t, chan5_scaled) }, \
{ "chan6_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 10, offsetof(mavlink_rc_channels_scaled_t, chan6_scaled) }, \
{ "chan7_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 12, offsetof(mavlink_rc_channels_scaled_t, chan7_scaled) }, \
{ "chan8_scaled", NULL, MAVLINK_TYPE_INT16_T, 0, 14, offsetof(mavlink_rc_channels_scaled_t, chan8_scaled) }, \
{ "rssi", NULL, MAVLINK_TYPE_UINT8_T, 0, 16, offsetof(mavlink_rc_channels_scaled_t, rssi) }, \
} \
}
/**
* @brief Pack a rc_channels_scaled message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param chan1_scaled RC channel 1 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan2_scaled RC channel 2 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan3_scaled RC channel 3 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan4_scaled RC channel 4 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan5_scaled RC channel 5 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan6_scaled RC channel 6 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan7_scaled RC channel 7 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan8_scaled RC channel 8 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param rssi Receive signal strength indicator, 0: 0%, 255: 100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_rc_channels_scaled_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
int16_t chan1_scaled, int16_t chan2_scaled, int16_t chan3_scaled, int16_t chan4_scaled, int16_t chan5_scaled, int16_t chan6_scaled, int16_t chan7_scaled, int16_t chan8_scaled, uint8_t rssi)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[17];
_mav_put_int16_t(buf, 0, chan1_scaled);
_mav_put_int16_t(buf, 2, chan2_scaled);
_mav_put_int16_t(buf, 4, chan3_scaled);
_mav_put_int16_t(buf, 6, chan4_scaled);
_mav_put_int16_t(buf, 8, chan5_scaled);
_mav_put_int16_t(buf, 10, chan6_scaled);
_mav_put_int16_t(buf, 12, chan7_scaled);
_mav_put_int16_t(buf, 14, chan8_scaled);
_mav_put_uint8_t(buf, 16, rssi);
memcpy(_MAV_PAYLOAD(msg), buf, 17);
#else
mavlink_rc_channels_scaled_t packet;
packet.chan1_scaled = chan1_scaled;
packet.chan2_scaled = chan2_scaled;
packet.chan3_scaled = chan3_scaled;
packet.chan4_scaled = chan4_scaled;
packet.chan5_scaled = chan5_scaled;
packet.chan6_scaled = chan6_scaled;
packet.chan7_scaled = chan7_scaled;
packet.chan8_scaled = chan8_scaled;
packet.rssi = rssi;
memcpy(_MAV_PAYLOAD(msg), &packet, 17);
#endif
msg->msgid = MAVLINK_MSG_ID_RC_CHANNELS_SCALED;
return mavlink_finalize_message(msg, system_id, component_id, 17);
}
/**
* @brief Pack a rc_channels_scaled message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param chan1_scaled RC channel 1 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan2_scaled RC channel 2 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan3_scaled RC channel 3 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan4_scaled RC channel 4 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan5_scaled RC channel 5 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan6_scaled RC channel 6 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan7_scaled RC channel 7 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan8_scaled RC channel 8 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param rssi Receive signal strength indicator, 0: 0%, 255: 100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_rc_channels_scaled_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
int16_t chan1_scaled,int16_t chan2_scaled,int16_t chan3_scaled,int16_t chan4_scaled,int16_t chan5_scaled,int16_t chan6_scaled,int16_t chan7_scaled,int16_t chan8_scaled,uint8_t rssi)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[17];
_mav_put_int16_t(buf, 0, chan1_scaled);
_mav_put_int16_t(buf, 2, chan2_scaled);
_mav_put_int16_t(buf, 4, chan3_scaled);
_mav_put_int16_t(buf, 6, chan4_scaled);
_mav_put_int16_t(buf, 8, chan5_scaled);
_mav_put_int16_t(buf, 10, chan6_scaled);
_mav_put_int16_t(buf, 12, chan7_scaled);
_mav_put_int16_t(buf, 14, chan8_scaled);
_mav_put_uint8_t(buf, 16, rssi);
memcpy(_MAV_PAYLOAD(msg), buf, 17);
#else
mavlink_rc_channels_scaled_t packet;
packet.chan1_scaled = chan1_scaled;
packet.chan2_scaled = chan2_scaled;
packet.chan3_scaled = chan3_scaled;
packet.chan4_scaled = chan4_scaled;
packet.chan5_scaled = chan5_scaled;
packet.chan6_scaled = chan6_scaled;
packet.chan7_scaled = chan7_scaled;
packet.chan8_scaled = chan8_scaled;
packet.rssi = rssi;
memcpy(_MAV_PAYLOAD(msg), &packet, 17);
#endif
msg->msgid = MAVLINK_MSG_ID_RC_CHANNELS_SCALED;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 17);
}
/**
* @brief Encode a rc_channels_scaled struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param rc_channels_scaled C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_rc_channels_scaled_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_rc_channels_scaled_t* rc_channels_scaled)
{
return mavlink_msg_rc_channels_scaled_pack(system_id, component_id, msg, rc_channels_scaled->chan1_scaled, rc_channels_scaled->chan2_scaled, rc_channels_scaled->chan3_scaled, rc_channels_scaled->chan4_scaled, rc_channels_scaled->chan5_scaled, rc_channels_scaled->chan6_scaled, rc_channels_scaled->chan7_scaled, rc_channels_scaled->chan8_scaled, rc_channels_scaled->rssi);
}
/**
* @brief Send a rc_channels_scaled message
* @param chan MAVLink channel to send the message
*
* @param chan1_scaled RC channel 1 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan2_scaled RC channel 2 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan3_scaled RC channel 3 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan4_scaled RC channel 4 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan5_scaled RC channel 5 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan6_scaled RC channel 6 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan7_scaled RC channel 7 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param chan8_scaled RC channel 8 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
* @param rssi Receive signal strength indicator, 0: 0%, 255: 100%
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_rc_channels_scaled_send(mavlink_channel_t chan, int16_t chan1_scaled, int16_t chan2_scaled, int16_t chan3_scaled, int16_t chan4_scaled, int16_t chan5_scaled, int16_t chan6_scaled, int16_t chan7_scaled, int16_t chan8_scaled, uint8_t rssi)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[17];
_mav_put_int16_t(buf, 0, chan1_scaled);
_mav_put_int16_t(buf, 2, chan2_scaled);
_mav_put_int16_t(buf, 4, chan3_scaled);
_mav_put_int16_t(buf, 6, chan4_scaled);
_mav_put_int16_t(buf, 8, chan5_scaled);
_mav_put_int16_t(buf, 10, chan6_scaled);
_mav_put_int16_t(buf, 12, chan7_scaled);
_mav_put_int16_t(buf, 14, chan8_scaled);
_mav_put_uint8_t(buf, 16, rssi);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RC_CHANNELS_SCALED, buf, 17);
#else
mavlink_rc_channels_scaled_t packet;
packet.chan1_scaled = chan1_scaled;
packet.chan2_scaled = chan2_scaled;
packet.chan3_scaled = chan3_scaled;
packet.chan4_scaled = chan4_scaled;
packet.chan5_scaled = chan5_scaled;
packet.chan6_scaled = chan6_scaled;
packet.chan7_scaled = chan7_scaled;
packet.chan8_scaled = chan8_scaled;
packet.rssi = rssi;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_RC_CHANNELS_SCALED, (const char *)&packet, 17);
#endif
}
#endif
// MESSAGE RC_CHANNELS_SCALED UNPACKING
/**
* @brief Get field chan1_scaled from rc_channels_scaled message
*
* @return RC channel 1 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan1_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 0);
}
/**
* @brief Get field chan2_scaled from rc_channels_scaled message
*
* @return RC channel 2 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan2_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 2);
}
/**
* @brief Get field chan3_scaled from rc_channels_scaled message
*
* @return RC channel 3 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan3_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 4);
}
/**
* @brief Get field chan4_scaled from rc_channels_scaled message
*
* @return RC channel 4 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan4_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 6);
}
/**
* @brief Get field chan5_scaled from rc_channels_scaled message
*
* @return RC channel 5 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan5_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 8);
}
/**
* @brief Get field chan6_scaled from rc_channels_scaled message
*
* @return RC channel 6 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan6_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 10);
}
/**
* @brief Get field chan7_scaled from rc_channels_scaled message
*
* @return RC channel 7 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan7_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 12);
}
/**
* @brief Get field chan8_scaled from rc_channels_scaled message
*
* @return RC channel 8 value scaled, (-100%) -10000, (0%) 0, (100%) 10000
*/
static inline int16_t mavlink_msg_rc_channels_scaled_get_chan8_scaled(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 14);
}
/**
* @brief Get field rssi from rc_channels_scaled message
*
* @return Receive signal strength indicator, 0: 0%, 255: 100%
*/
static inline uint8_t mavlink_msg_rc_channels_scaled_get_rssi(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 16);
}
/**
* @brief Decode a rc_channels_scaled message into a struct
*
* @param msg The message to decode
* @param rc_channels_scaled C-struct to decode the message contents into
*/
static inline void mavlink_msg_rc_channels_scaled_decode(const mavlink_message_t* msg, mavlink_rc_channels_scaled_t* rc_channels_scaled)
{
#if MAVLINK_NEED_BYTE_SWAP
rc_channels_scaled->chan1_scaled = mavlink_msg_rc_channels_scaled_get_chan1_scaled(msg);
rc_channels_scaled->chan2_scaled = mavlink_msg_rc_channels_scaled_get_chan2_scaled(msg);
rc_channels_scaled->chan3_scaled = mavlink_msg_rc_channels_scaled_get_chan3_scaled(msg);
rc_channels_scaled->chan4_scaled = mavlink_msg_rc_channels_scaled_get_chan4_scaled(msg);
rc_channels_scaled->chan5_scaled = mavlink_msg_rc_channels_scaled_get_chan5_scaled(msg);
rc_channels_scaled->chan6_scaled = mavlink_msg_rc_channels_scaled_get_chan6_scaled(msg);
rc_channels_scaled->chan7_scaled = mavlink_msg_rc_channels_scaled_get_chan7_scaled(msg);
rc_channels_scaled->chan8_scaled = mavlink_msg_rc_channels_scaled_get_chan8_scaled(msg);
rc_channels_scaled->rssi = mavlink_msg_rc_channels_scaled_get_rssi(msg);
#else
memcpy(rc_channels_scaled, _MAV_PAYLOAD(msg), 17);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE REQUEST_DATA_STREAM PACKING
#define MAVLINK_MSG_ID_REQUEST_DATA_STREAM 66
typedef struct __mavlink_request_data_stream_t
{
uint8_t target_system; ///< The target requested to send the message stream.
uint8_t target_component; ///< The target requested to send the message stream.
uint8_t req_stream_id; ///< The ID of the requested message type
uint16_t req_message_rate; ///< Update rate in Hertz
uint8_t start_stop; ///< 1 to start sending, 0 to stop sending.
} mavlink_request_data_stream_t;
#define MAVLINK_MSG_ID_REQUEST_DATA_STREAM_LEN 6
#define MAVLINK_MSG_ID_66_LEN 6
#define MAVLINK_MESSAGE_INFO_REQUEST_DATA_STREAM { \
"REQUEST_DATA_STREAM", \
5, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_request_data_stream_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_request_data_stream_t, target_component) }, \
{ "req_stream_id", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_request_data_stream_t, req_stream_id) }, \
{ "req_message_rate", NULL, MAVLINK_TYPE_UINT16_T, 0, 3, offsetof(mavlink_request_data_stream_t, req_message_rate) }, \
{ "start_stop", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_request_data_stream_t, start_stop) }, \
} \
}
/**
* @brief Pack a request_data_stream message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system The target requested to send the message stream.
* @param target_component The target requested to send the message stream.
* @param req_stream_id The ID of the requested message type
* @param req_message_rate Update rate in Hertz
* @param start_stop 1 to start sending, 0 to stop sending.
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_request_data_stream_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t req_stream_id, uint16_t req_message_rate, uint8_t start_stop)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[6];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, req_stream_id);
_mav_put_uint16_t(buf, 3, req_message_rate);
_mav_put_uint8_t(buf, 5, start_stop);
memcpy(_MAV_PAYLOAD(msg), buf, 6);
#else
mavlink_request_data_stream_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.req_stream_id = req_stream_id;
packet.req_message_rate = req_message_rate;
packet.start_stop = start_stop;
memcpy(_MAV_PAYLOAD(msg), &packet, 6);
#endif
msg->msgid = MAVLINK_MSG_ID_REQUEST_DATA_STREAM;
return mavlink_finalize_message(msg, system_id, component_id, 6);
}
/**
* @brief Pack a request_data_stream message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system The target requested to send the message stream.
* @param target_component The target requested to send the message stream.
* @param req_stream_id The ID of the requested message type
* @param req_message_rate Update rate in Hertz
* @param start_stop 1 to start sending, 0 to stop sending.
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_request_data_stream_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t req_stream_id,uint16_t req_message_rate,uint8_t start_stop)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[6];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, req_stream_id);
_mav_put_uint16_t(buf, 3, req_message_rate);
_mav_put_uint8_t(buf, 5, start_stop);
memcpy(_MAV_PAYLOAD(msg), buf, 6);
#else
mavlink_request_data_stream_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.req_stream_id = req_stream_id;
packet.req_message_rate = req_message_rate;
packet.start_stop = start_stop;
memcpy(_MAV_PAYLOAD(msg), &packet, 6);
#endif
msg->msgid = MAVLINK_MSG_ID_REQUEST_DATA_STREAM;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 6);
}
/**
* @brief Encode a request_data_stream struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param request_data_stream C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_request_data_stream_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_request_data_stream_t* request_data_stream)
{
return mavlink_msg_request_data_stream_pack(system_id, component_id, msg, request_data_stream->target_system, request_data_stream->target_component, request_data_stream->req_stream_id, request_data_stream->req_message_rate, request_data_stream->start_stop);
}
/**
* @brief Send a request_data_stream message
* @param chan MAVLink channel to send the message
*
* @param target_system The target requested to send the message stream.
* @param target_component The target requested to send the message stream.
* @param req_stream_id The ID of the requested message type
* @param req_message_rate Update rate in Hertz
* @param start_stop 1 to start sending, 0 to stop sending.
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_request_data_stream_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t req_stream_id, uint16_t req_message_rate, uint8_t start_stop)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[6];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, req_stream_id);
_mav_put_uint16_t(buf, 3, req_message_rate);
_mav_put_uint8_t(buf, 5, start_stop);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_REQUEST_DATA_STREAM, buf, 6);
#else
mavlink_request_data_stream_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.req_stream_id = req_stream_id;
packet.req_message_rate = req_message_rate;
packet.start_stop = start_stop;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_REQUEST_DATA_STREAM, (const char *)&packet, 6);
#endif
}
#endif
// MESSAGE REQUEST_DATA_STREAM UNPACKING
/**
* @brief Get field target_system from request_data_stream message
*
* @return The target requested to send the message stream.
*/
static inline uint8_t mavlink_msg_request_data_stream_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from request_data_stream message
*
* @return The target requested to send the message stream.
*/
static inline uint8_t mavlink_msg_request_data_stream_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field req_stream_id from request_data_stream message
*
* @return The ID of the requested message type
*/
static inline uint8_t mavlink_msg_request_data_stream_get_req_stream_id(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field req_message_rate from request_data_stream message
*
* @return Update rate in Hertz
*/
static inline uint16_t mavlink_msg_request_data_stream_get_req_message_rate(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 3);
}
/**
* @brief Get field start_stop from request_data_stream message
*
* @return 1 to start sending, 0 to stop sending.
*/
static inline uint8_t mavlink_msg_request_data_stream_get_start_stop(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Decode a request_data_stream message into a struct
*
* @param msg The message to decode
* @param request_data_stream C-struct to decode the message contents into
*/
static inline void mavlink_msg_request_data_stream_decode(const mavlink_message_t* msg, mavlink_request_data_stream_t* request_data_stream)
{
#if MAVLINK_NEED_BYTE_SWAP
request_data_stream->target_system = mavlink_msg_request_data_stream_get_target_system(msg);
request_data_stream->target_component = mavlink_msg_request_data_stream_get_target_component(msg);
request_data_stream->req_stream_id = mavlink_msg_request_data_stream_get_req_stream_id(msg);
request_data_stream->req_message_rate = mavlink_msg_request_data_stream_get_req_message_rate(msg);
request_data_stream->start_stop = mavlink_msg_request_data_stream_get_start_stop(msg);
#else
memcpy(request_data_stream, _MAV_PAYLOAD(msg), 6);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT PACKING
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT 58
typedef struct __mavlink_roll_pitch_yaw_speed_thrust_setpoint_t
{
uint64_t time_us; ///< Timestamp in micro seconds since unix epoch
float roll_speed; ///< Desired roll angular speed in rad/s
float pitch_speed; ///< Desired pitch angular speed in rad/s
float yaw_speed; ///< Desired yaw angular speed in rad/s
float thrust; ///< Collective thrust, normalized to 0 .. 1
} mavlink_roll_pitch_yaw_speed_thrust_setpoint_t;
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT_LEN 24
#define MAVLINK_MSG_ID_58_LEN 24
#define MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT { \
"ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT", \
5, \
{ { "time_us", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_roll_pitch_yaw_speed_thrust_setpoint_t, time_us) }, \
{ "roll_speed", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_roll_pitch_yaw_speed_thrust_setpoint_t, roll_speed) }, \
{ "pitch_speed", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_roll_pitch_yaw_speed_thrust_setpoint_t, pitch_speed) }, \
{ "yaw_speed", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_roll_pitch_yaw_speed_thrust_setpoint_t, yaw_speed) }, \
{ "thrust", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_roll_pitch_yaw_speed_thrust_setpoint_t, thrust) }, \
} \
}
/**
* @brief Pack a roll_pitch_yaw_speed_thrust_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time_us Timestamp in micro seconds since unix epoch
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t time_us, float roll_speed, float pitch_speed, float yaw_speed, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[24];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll_speed);
_mav_put_float(buf, 12, pitch_speed);
_mav_put_float(buf, 16, yaw_speed);
_mav_put_float(buf, 20, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 24);
#else
mavlink_roll_pitch_yaw_speed_thrust_setpoint_t packet;
packet.time_us = time_us;
packet.roll_speed = roll_speed;
packet.pitch_speed = pitch_speed;
packet.yaw_speed = yaw_speed;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 24);
#endif
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT;
return mavlink_finalize_message(msg, system_id, component_id, 24);
}
/**
* @brief Pack a roll_pitch_yaw_speed_thrust_setpoint message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time_us Timestamp in micro seconds since unix epoch
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t time_us,float roll_speed,float pitch_speed,float yaw_speed,float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[24];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll_speed);
_mav_put_float(buf, 12, pitch_speed);
_mav_put_float(buf, 16, yaw_speed);
_mav_put_float(buf, 20, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 24);
#else
mavlink_roll_pitch_yaw_speed_thrust_setpoint_t packet;
packet.time_us = time_us;
packet.roll_speed = roll_speed;
packet.pitch_speed = pitch_speed;
packet.yaw_speed = yaw_speed;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 24);
#endif
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 24);
}
/**
* @brief Encode a roll_pitch_yaw_speed_thrust_setpoint struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param roll_pitch_yaw_speed_thrust_setpoint C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_roll_pitch_yaw_speed_thrust_setpoint_t* roll_pitch_yaw_speed_thrust_setpoint)
{
return mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_pack(system_id, component_id, msg, roll_pitch_yaw_speed_thrust_setpoint->time_us, roll_pitch_yaw_speed_thrust_setpoint->roll_speed, roll_pitch_yaw_speed_thrust_setpoint->pitch_speed, roll_pitch_yaw_speed_thrust_setpoint->yaw_speed, roll_pitch_yaw_speed_thrust_setpoint->thrust);
}
/**
* @brief Send a roll_pitch_yaw_speed_thrust_setpoint message
* @param chan MAVLink channel to send the message
*
* @param time_us Timestamp in micro seconds since unix epoch
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @param thrust Collective thrust, normalized to 0 .. 1
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_send(mavlink_channel_t chan, uint64_t time_us, float roll_speed, float pitch_speed, float yaw_speed, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[24];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll_speed);
_mav_put_float(buf, 12, pitch_speed);
_mav_put_float(buf, 16, yaw_speed);
_mav_put_float(buf, 20, thrust);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT, buf, 24);
#else
mavlink_roll_pitch_yaw_speed_thrust_setpoint_t packet;
packet.time_us = time_us;
packet.roll_speed = roll_speed;
packet.pitch_speed = pitch_speed;
packet.yaw_speed = yaw_speed;
packet.thrust = thrust;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT, (const char *)&packet, 24);
#endif
}
#endif
// MESSAGE ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT UNPACKING
/**
* @brief Get field time_us from roll_pitch_yaw_speed_thrust_setpoint message
*
* @return Timestamp in micro seconds since unix epoch
*/
static inline uint64_t mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_time_us(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field roll_speed from roll_pitch_yaw_speed_thrust_setpoint message
*
* @return Desired roll angular speed in rad/s
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_roll_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field pitch_speed from roll_pitch_yaw_speed_thrust_setpoint message
*
* @return Desired pitch angular speed in rad/s
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_pitch_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field yaw_speed from roll_pitch_yaw_speed_thrust_setpoint message
*
* @return Desired yaw angular speed in rad/s
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_yaw_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field thrust from roll_pitch_yaw_speed_thrust_setpoint message
*
* @return Collective thrust, normalized to 0 .. 1
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_thrust(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Decode a roll_pitch_yaw_speed_thrust_setpoint message into a struct
*
* @param msg The message to decode
* @param roll_pitch_yaw_speed_thrust_setpoint C-struct to decode the message contents into
*/
static inline void mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_decode(const mavlink_message_t* msg, mavlink_roll_pitch_yaw_speed_thrust_setpoint_t* roll_pitch_yaw_speed_thrust_setpoint)
{
#if MAVLINK_NEED_BYTE_SWAP
roll_pitch_yaw_speed_thrust_setpoint->time_us = mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_time_us(msg);
roll_pitch_yaw_speed_thrust_setpoint->roll_speed = mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_roll_speed(msg);
roll_pitch_yaw_speed_thrust_setpoint->pitch_speed = mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_pitch_speed(msg);
roll_pitch_yaw_speed_thrust_setpoint->yaw_speed = mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_yaw_speed(msg);
roll_pitch_yaw_speed_thrust_setpoint->thrust = mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_get_thrust(msg);
#else
memcpy(roll_pitch_yaw_speed_thrust_setpoint, _MAV_PAYLOAD(msg), 24);
#endif
}
@@ -1,232 +0,0 @@
// MESSAGE ROLL_PITCH_YAW_THRUST_SETPOINT PACKING
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_THRUST_SETPOINT 57
typedef struct __mavlink_roll_pitch_yaw_thrust_setpoint_t
{
uint64_t time_us; ///< Timestamp in micro seconds since unix epoch
float roll; ///< Desired roll angle in radians
float pitch; ///< Desired pitch angle in radians
float yaw; ///< Desired yaw angle in radians
float thrust; ///< Collective thrust, normalized to 0 .. 1
} mavlink_roll_pitch_yaw_thrust_setpoint_t;
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_THRUST_SETPOINT_LEN 24
#define MAVLINK_MSG_ID_57_LEN 24
#define MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_THRUST_SETPOINT { \
"ROLL_PITCH_YAW_THRUST_SETPOINT", \
5, \
{ { "time_us", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_roll_pitch_yaw_thrust_setpoint_t, time_us) }, \
{ "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_roll_pitch_yaw_thrust_setpoint_t, roll) }, \
{ "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_roll_pitch_yaw_thrust_setpoint_t, pitch) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_roll_pitch_yaw_thrust_setpoint_t, yaw) }, \
{ "thrust", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_roll_pitch_yaw_thrust_setpoint_t, thrust) }, \
} \
}
/**
* @brief Pack a roll_pitch_yaw_thrust_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time_us Timestamp in micro seconds since unix epoch
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_thrust_setpoint_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t time_us, float roll, float pitch, float yaw, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[24];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 24);
#else
mavlink_roll_pitch_yaw_thrust_setpoint_t packet;
packet.time_us = time_us;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 24);
#endif
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_THRUST_SETPOINT;
return mavlink_finalize_message(msg, system_id, component_id, 24);
}
/**
* @brief Pack a roll_pitch_yaw_thrust_setpoint message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time_us Timestamp in micro seconds since unix epoch
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_thrust_setpoint_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t time_us,float roll,float pitch,float yaw,float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[24];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 24);
#else
mavlink_roll_pitch_yaw_thrust_setpoint_t packet;
packet.time_us = time_us;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 24);
#endif
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_THRUST_SETPOINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 24);
}
/**
* @brief Encode a roll_pitch_yaw_thrust_setpoint struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param roll_pitch_yaw_thrust_setpoint C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_thrust_setpoint_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_roll_pitch_yaw_thrust_setpoint_t* roll_pitch_yaw_thrust_setpoint)
{
return mavlink_msg_roll_pitch_yaw_thrust_setpoint_pack(system_id, component_id, msg, roll_pitch_yaw_thrust_setpoint->time_us, roll_pitch_yaw_thrust_setpoint->roll, roll_pitch_yaw_thrust_setpoint->pitch, roll_pitch_yaw_thrust_setpoint->yaw, roll_pitch_yaw_thrust_setpoint->thrust);
}
/**
* @brief Send a roll_pitch_yaw_thrust_setpoint message
* @param chan MAVLink channel to send the message
*
* @param time_us Timestamp in micro seconds since unix epoch
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @param thrust Collective thrust, normalized to 0 .. 1
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_roll_pitch_yaw_thrust_setpoint_send(mavlink_channel_t chan, uint64_t time_us, float roll, float pitch, float yaw, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[24];
_mav_put_uint64_t(buf, 0, time_us);
_mav_put_float(buf, 8, roll);
_mav_put_float(buf, 12, pitch);
_mav_put_float(buf, 16, yaw);
_mav_put_float(buf, 20, thrust);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ROLL_PITCH_YAW_THRUST_SETPOINT, buf, 24);
#else
mavlink_roll_pitch_yaw_thrust_setpoint_t packet;
packet.time_us = time_us;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ROLL_PITCH_YAW_THRUST_SETPOINT, (const char *)&packet, 24);
#endif
}
#endif
// MESSAGE ROLL_PITCH_YAW_THRUST_SETPOINT UNPACKING
/**
* @brief Get field time_us from roll_pitch_yaw_thrust_setpoint message
*
* @return Timestamp in micro seconds since unix epoch
*/
static inline uint64_t mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_time_us(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field roll from roll_pitch_yaw_thrust_setpoint message
*
* @return Desired roll angle in radians
*/
static inline float mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field pitch from roll_pitch_yaw_thrust_setpoint message
*
* @return Desired pitch angle in radians
*/
static inline float mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field yaw from roll_pitch_yaw_thrust_setpoint message
*
* @return Desired yaw angle in radians
*/
static inline float mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field thrust from roll_pitch_yaw_thrust_setpoint message
*
* @return Collective thrust, normalized to 0 .. 1
*/
static inline float mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_thrust(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Decode a roll_pitch_yaw_thrust_setpoint message into a struct
*
* @param msg The message to decode
* @param roll_pitch_yaw_thrust_setpoint C-struct to decode the message contents into
*/
static inline void mavlink_msg_roll_pitch_yaw_thrust_setpoint_decode(const mavlink_message_t* msg, mavlink_roll_pitch_yaw_thrust_setpoint_t* roll_pitch_yaw_thrust_setpoint)
{
#if MAVLINK_NEED_BYTE_SWAP
roll_pitch_yaw_thrust_setpoint->time_us = mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_time_us(msg);
roll_pitch_yaw_thrust_setpoint->roll = mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_roll(msg);
roll_pitch_yaw_thrust_setpoint->pitch = mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_pitch(msg);
roll_pitch_yaw_thrust_setpoint->yaw = mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_yaw(msg);
roll_pitch_yaw_thrust_setpoint->thrust = mavlink_msg_roll_pitch_yaw_thrust_setpoint_get_thrust(msg);
#else
memcpy(roll_pitch_yaw_thrust_setpoint, _MAV_PAYLOAD(msg), 24);
#endif
}
@@ -1,276 +0,0 @@
// MESSAGE SAFETY_ALLOWED_AREA PACKING
#define MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA 54
typedef struct __mavlink_safety_allowed_area_t
{
uint8_t frame; ///< Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
float p1x; ///< x position 1 / Latitude 1
float p1y; ///< y position 1 / Longitude 1
float p1z; ///< z position 1 / Altitude 1
float p2x; ///< x position 2 / Latitude 2
float p2y; ///< y position 2 / Longitude 2
float p2z; ///< z position 2 / Altitude 2
} mavlink_safety_allowed_area_t;
#define MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA_LEN 25
#define MAVLINK_MSG_ID_54_LEN 25
#define MAVLINK_MESSAGE_INFO_SAFETY_ALLOWED_AREA { \
"SAFETY_ALLOWED_AREA", \
7, \
{ { "frame", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_safety_allowed_area_t, frame) }, \
{ "p1x", NULL, MAVLINK_TYPE_FLOAT, 0, 1, offsetof(mavlink_safety_allowed_area_t, p1x) }, \
{ "p1y", NULL, MAVLINK_TYPE_FLOAT, 0, 5, offsetof(mavlink_safety_allowed_area_t, p1y) }, \
{ "p1z", NULL, MAVLINK_TYPE_FLOAT, 0, 9, offsetof(mavlink_safety_allowed_area_t, p1z) }, \
{ "p2x", NULL, MAVLINK_TYPE_FLOAT, 0, 13, offsetof(mavlink_safety_allowed_area_t, p2x) }, \
{ "p2y", NULL, MAVLINK_TYPE_FLOAT, 0, 17, offsetof(mavlink_safety_allowed_area_t, p2y) }, \
{ "p2z", NULL, MAVLINK_TYPE_FLOAT, 0, 21, offsetof(mavlink_safety_allowed_area_t, p2z) }, \
} \
}
/**
* @brief Pack a safety_allowed_area message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param frame Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
* @param p1x x position 1 / Latitude 1
* @param p1y y position 1 / Longitude 1
* @param p1z z position 1 / Altitude 1
* @param p2x x position 2 / Latitude 2
* @param p2y y position 2 / Longitude 2
* @param p2z z position 2 / Altitude 2
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_safety_allowed_area_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t frame, float p1x, float p1y, float p1z, float p2x, float p2y, float p2z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[25];
_mav_put_uint8_t(buf, 0, frame);
_mav_put_float(buf, 1, p1x);
_mav_put_float(buf, 5, p1y);
_mav_put_float(buf, 9, p1z);
_mav_put_float(buf, 13, p2x);
_mav_put_float(buf, 17, p2y);
_mav_put_float(buf, 21, p2z);
memcpy(_MAV_PAYLOAD(msg), buf, 25);
#else
mavlink_safety_allowed_area_t packet;
packet.frame = frame;
packet.p1x = p1x;
packet.p1y = p1y;
packet.p1z = p1z;
packet.p2x = p2x;
packet.p2y = p2y;
packet.p2z = p2z;
memcpy(_MAV_PAYLOAD(msg), &packet, 25);
#endif
msg->msgid = MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA;
return mavlink_finalize_message(msg, system_id, component_id, 25);
}
/**
* @brief Pack a safety_allowed_area message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param frame Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
* @param p1x x position 1 / Latitude 1
* @param p1y y position 1 / Longitude 1
* @param p1z z position 1 / Altitude 1
* @param p2x x position 2 / Latitude 2
* @param p2y y position 2 / Longitude 2
* @param p2z z position 2 / Altitude 2
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_safety_allowed_area_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t frame,float p1x,float p1y,float p1z,float p2x,float p2y,float p2z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[25];
_mav_put_uint8_t(buf, 0, frame);
_mav_put_float(buf, 1, p1x);
_mav_put_float(buf, 5, p1y);
_mav_put_float(buf, 9, p1z);
_mav_put_float(buf, 13, p2x);
_mav_put_float(buf, 17, p2y);
_mav_put_float(buf, 21, p2z);
memcpy(_MAV_PAYLOAD(msg), buf, 25);
#else
mavlink_safety_allowed_area_t packet;
packet.frame = frame;
packet.p1x = p1x;
packet.p1y = p1y;
packet.p1z = p1z;
packet.p2x = p2x;
packet.p2y = p2y;
packet.p2z = p2z;
memcpy(_MAV_PAYLOAD(msg), &packet, 25);
#endif
msg->msgid = MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 25);
}
/**
* @brief Encode a safety_allowed_area struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param safety_allowed_area C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_safety_allowed_area_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_safety_allowed_area_t* safety_allowed_area)
{
return mavlink_msg_safety_allowed_area_pack(system_id, component_id, msg, safety_allowed_area->frame, safety_allowed_area->p1x, safety_allowed_area->p1y, safety_allowed_area->p1z, safety_allowed_area->p2x, safety_allowed_area->p2y, safety_allowed_area->p2z);
}
/**
* @brief Send a safety_allowed_area message
* @param chan MAVLink channel to send the message
*
* @param frame Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
* @param p1x x position 1 / Latitude 1
* @param p1y y position 1 / Longitude 1
* @param p1z z position 1 / Altitude 1
* @param p2x x position 2 / Latitude 2
* @param p2y y position 2 / Longitude 2
* @param p2z z position 2 / Altitude 2
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_safety_allowed_area_send(mavlink_channel_t chan, uint8_t frame, float p1x, float p1y, float p1z, float p2x, float p2y, float p2z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[25];
_mav_put_uint8_t(buf, 0, frame);
_mav_put_float(buf, 1, p1x);
_mav_put_float(buf, 5, p1y);
_mav_put_float(buf, 9, p1z);
_mav_put_float(buf, 13, p2x);
_mav_put_float(buf, 17, p2y);
_mav_put_float(buf, 21, p2z);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA, buf, 25);
#else
mavlink_safety_allowed_area_t packet;
packet.frame = frame;
packet.p1x = p1x;
packet.p1y = p1y;
packet.p1z = p1z;
packet.p2x = p2x;
packet.p2y = p2y;
packet.p2z = p2z;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA, (const char *)&packet, 25);
#endif
}
#endif
// MESSAGE SAFETY_ALLOWED_AREA UNPACKING
/**
* @brief Get field frame from safety_allowed_area message
*
* @return Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
*/
static inline uint8_t mavlink_msg_safety_allowed_area_get_frame(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field p1x from safety_allowed_area message
*
* @return x position 1 / Latitude 1
*/
static inline float mavlink_msg_safety_allowed_area_get_p1x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 1);
}
/**
* @brief Get field p1y from safety_allowed_area message
*
* @return y position 1 / Longitude 1
*/
static inline float mavlink_msg_safety_allowed_area_get_p1y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 5);
}
/**
* @brief Get field p1z from safety_allowed_area message
*
* @return z position 1 / Altitude 1
*/
static inline float mavlink_msg_safety_allowed_area_get_p1z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 9);
}
/**
* @brief Get field p2x from safety_allowed_area message
*
* @return x position 2 / Latitude 2
*/
static inline float mavlink_msg_safety_allowed_area_get_p2x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 13);
}
/**
* @brief Get field p2y from safety_allowed_area message
*
* @return y position 2 / Longitude 2
*/
static inline float mavlink_msg_safety_allowed_area_get_p2y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 17);
}
/**
* @brief Get field p2z from safety_allowed_area message
*
* @return z position 2 / Altitude 2
*/
static inline float mavlink_msg_safety_allowed_area_get_p2z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 21);
}
/**
* @brief Decode a safety_allowed_area message into a struct
*
* @param msg The message to decode
* @param safety_allowed_area C-struct to decode the message contents into
*/
static inline void mavlink_msg_safety_allowed_area_decode(const mavlink_message_t* msg, mavlink_safety_allowed_area_t* safety_allowed_area)
{
#if MAVLINK_NEED_BYTE_SWAP
safety_allowed_area->frame = mavlink_msg_safety_allowed_area_get_frame(msg);
safety_allowed_area->p1x = mavlink_msg_safety_allowed_area_get_p1x(msg);
safety_allowed_area->p1y = mavlink_msg_safety_allowed_area_get_p1y(msg);
safety_allowed_area->p1z = mavlink_msg_safety_allowed_area_get_p1z(msg);
safety_allowed_area->p2x = mavlink_msg_safety_allowed_area_get_p2x(msg);
safety_allowed_area->p2y = mavlink_msg_safety_allowed_area_get_p2y(msg);
safety_allowed_area->p2z = mavlink_msg_safety_allowed_area_get_p2z(msg);
#else
memcpy(safety_allowed_area, _MAV_PAYLOAD(msg), 25);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE SAFETY_SET_ALLOWED_AREA PACKING
#define MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA 53
typedef struct __mavlink_safety_set_allowed_area_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t frame; ///< Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
float p1x; ///< x position 1 / Latitude 1
float p1y; ///< y position 1 / Longitude 1
float p1z; ///< z position 1 / Altitude 1
float p2x; ///< x position 2 / Latitude 2
float p2y; ///< y position 2 / Longitude 2
float p2z; ///< z position 2 / Altitude 2
} mavlink_safety_set_allowed_area_t;
#define MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA_LEN 27
#define MAVLINK_MSG_ID_53_LEN 27
#define MAVLINK_MESSAGE_INFO_SAFETY_SET_ALLOWED_AREA { \
"SAFETY_SET_ALLOWED_AREA", \
9, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_safety_set_allowed_area_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_safety_set_allowed_area_t, target_component) }, \
{ "frame", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_safety_set_allowed_area_t, frame) }, \
{ "p1x", NULL, MAVLINK_TYPE_FLOAT, 0, 3, offsetof(mavlink_safety_set_allowed_area_t, p1x) }, \
{ "p1y", NULL, MAVLINK_TYPE_FLOAT, 0, 7, offsetof(mavlink_safety_set_allowed_area_t, p1y) }, \
{ "p1z", NULL, MAVLINK_TYPE_FLOAT, 0, 11, offsetof(mavlink_safety_set_allowed_area_t, p1z) }, \
{ "p2x", NULL, MAVLINK_TYPE_FLOAT, 0, 15, offsetof(mavlink_safety_set_allowed_area_t, p2x) }, \
{ "p2y", NULL, MAVLINK_TYPE_FLOAT, 0, 19, offsetof(mavlink_safety_set_allowed_area_t, p2y) }, \
{ "p2z", NULL, MAVLINK_TYPE_FLOAT, 0, 23, offsetof(mavlink_safety_set_allowed_area_t, p2z) }, \
} \
}
/**
* @brief Pack a safety_set_allowed_area message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param frame Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
* @param p1x x position 1 / Latitude 1
* @param p1y y position 1 / Longitude 1
* @param p1z z position 1 / Altitude 1
* @param p2x x position 2 / Latitude 2
* @param p2y y position 2 / Longitude 2
* @param p2z z position 2 / Altitude 2
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_safety_set_allowed_area_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t frame, float p1x, float p1y, float p1z, float p2x, float p2y, float p2z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[27];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, frame);
_mav_put_float(buf, 3, p1x);
_mav_put_float(buf, 7, p1y);
_mav_put_float(buf, 11, p1z);
_mav_put_float(buf, 15, p2x);
_mav_put_float(buf, 19, p2y);
_mav_put_float(buf, 23, p2z);
memcpy(_MAV_PAYLOAD(msg), buf, 27);
#else
mavlink_safety_set_allowed_area_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.frame = frame;
packet.p1x = p1x;
packet.p1y = p1y;
packet.p1z = p1z;
packet.p2x = p2x;
packet.p2y = p2y;
packet.p2z = p2z;
memcpy(_MAV_PAYLOAD(msg), &packet, 27);
#endif
msg->msgid = MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA;
return mavlink_finalize_message(msg, system_id, component_id, 27);
}
/**
* @brief Pack a safety_set_allowed_area message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param frame Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
* @param p1x x position 1 / Latitude 1
* @param p1y y position 1 / Longitude 1
* @param p1z z position 1 / Altitude 1
* @param p2x x position 2 / Latitude 2
* @param p2y y position 2 / Longitude 2
* @param p2z z position 2 / Altitude 2
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_safety_set_allowed_area_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t frame,float p1x,float p1y,float p1z,float p2x,float p2y,float p2z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[27];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, frame);
_mav_put_float(buf, 3, p1x);
_mav_put_float(buf, 7, p1y);
_mav_put_float(buf, 11, p1z);
_mav_put_float(buf, 15, p2x);
_mav_put_float(buf, 19, p2y);
_mav_put_float(buf, 23, p2z);
memcpy(_MAV_PAYLOAD(msg), buf, 27);
#else
mavlink_safety_set_allowed_area_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.frame = frame;
packet.p1x = p1x;
packet.p1y = p1y;
packet.p1z = p1z;
packet.p2x = p2x;
packet.p2y = p2y;
packet.p2z = p2z;
memcpy(_MAV_PAYLOAD(msg), &packet, 27);
#endif
msg->msgid = MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 27);
}
/**
* @brief Encode a safety_set_allowed_area struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param safety_set_allowed_area C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_safety_set_allowed_area_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_safety_set_allowed_area_t* safety_set_allowed_area)
{
return mavlink_msg_safety_set_allowed_area_pack(system_id, component_id, msg, safety_set_allowed_area->target_system, safety_set_allowed_area->target_component, safety_set_allowed_area->frame, safety_set_allowed_area->p1x, safety_set_allowed_area->p1y, safety_set_allowed_area->p1z, safety_set_allowed_area->p2x, safety_set_allowed_area->p2y, safety_set_allowed_area->p2z);
}
/**
* @brief Send a safety_set_allowed_area message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param frame Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
* @param p1x x position 1 / Latitude 1
* @param p1y y position 1 / Longitude 1
* @param p1z z position 1 / Altitude 1
* @param p2x x position 2 / Latitude 2
* @param p2y y position 2 / Longitude 2
* @param p2z z position 2 / Altitude 2
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_safety_set_allowed_area_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t frame, float p1x, float p1y, float p1z, float p2x, float p2y, float p2z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[27];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, frame);
_mav_put_float(buf, 3, p1x);
_mav_put_float(buf, 7, p1y);
_mav_put_float(buf, 11, p1z);
_mav_put_float(buf, 15, p2x);
_mav_put_float(buf, 19, p2y);
_mav_put_float(buf, 23, p2z);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA, buf, 27);
#else
mavlink_safety_set_allowed_area_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.frame = frame;
packet.p1x = p1x;
packet.p1y = p1y;
packet.p1z = p1z;
packet.p2x = p2x;
packet.p2y = p2y;
packet.p2z = p2z;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA, (const char *)&packet, 27);
#endif
}
#endif
// MESSAGE SAFETY_SET_ALLOWED_AREA UNPACKING
/**
* @brief Get field target_system from safety_set_allowed_area message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_safety_set_allowed_area_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from safety_set_allowed_area message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_safety_set_allowed_area_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field frame from safety_set_allowed_area message
*
* @return Coordinate frame, as defined by MAV_FRAME enum in mavlink_types.h. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down.
*/
static inline uint8_t mavlink_msg_safety_set_allowed_area_get_frame(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field p1x from safety_set_allowed_area message
*
* @return x position 1 / Latitude 1
*/
static inline float mavlink_msg_safety_set_allowed_area_get_p1x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 3);
}
/**
* @brief Get field p1y from safety_set_allowed_area message
*
* @return y position 1 / Longitude 1
*/
static inline float mavlink_msg_safety_set_allowed_area_get_p1y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 7);
}
/**
* @brief Get field p1z from safety_set_allowed_area message
*
* @return z position 1 / Altitude 1
*/
static inline float mavlink_msg_safety_set_allowed_area_get_p1z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 11);
}
/**
* @brief Get field p2x from safety_set_allowed_area message
*
* @return x position 2 / Latitude 2
*/
static inline float mavlink_msg_safety_set_allowed_area_get_p2x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 15);
}
/**
* @brief Get field p2y from safety_set_allowed_area message
*
* @return y position 2 / Longitude 2
*/
static inline float mavlink_msg_safety_set_allowed_area_get_p2y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 19);
}
/**
* @brief Get field p2z from safety_set_allowed_area message
*
* @return z position 2 / Altitude 2
*/
static inline float mavlink_msg_safety_set_allowed_area_get_p2z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 23);
}
/**
* @brief Decode a safety_set_allowed_area message into a struct
*
* @param msg The message to decode
* @param safety_set_allowed_area C-struct to decode the message contents into
*/
static inline void mavlink_msg_safety_set_allowed_area_decode(const mavlink_message_t* msg, mavlink_safety_set_allowed_area_t* safety_set_allowed_area)
{
#if MAVLINK_NEED_BYTE_SWAP
safety_set_allowed_area->target_system = mavlink_msg_safety_set_allowed_area_get_target_system(msg);
safety_set_allowed_area->target_component = mavlink_msg_safety_set_allowed_area_get_target_component(msg);
safety_set_allowed_area->frame = mavlink_msg_safety_set_allowed_area_get_frame(msg);
safety_set_allowed_area->p1x = mavlink_msg_safety_set_allowed_area_get_p1x(msg);
safety_set_allowed_area->p1y = mavlink_msg_safety_set_allowed_area_get_p1y(msg);
safety_set_allowed_area->p1z = mavlink_msg_safety_set_allowed_area_get_p1z(msg);
safety_set_allowed_area->p2x = mavlink_msg_safety_set_allowed_area_get_p2x(msg);
safety_set_allowed_area->p2y = mavlink_msg_safety_set_allowed_area_get_p2y(msg);
safety_set_allowed_area->p2z = mavlink_msg_safety_set_allowed_area_get_p2z(msg);
#else
memcpy(safety_set_allowed_area, _MAV_PAYLOAD(msg), 27);
#endif
}
@@ -1,342 +0,0 @@
// MESSAGE SCALED_IMU PACKING
#define MAVLINK_MSG_ID_SCALED_IMU 26
typedef struct __mavlink_scaled_imu_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
int16_t xacc; ///< X acceleration (mg)
int16_t yacc; ///< Y acceleration (mg)
int16_t zacc; ///< Z acceleration (mg)
int16_t xgyro; ///< Angular speed around X axis (millirad /sec)
int16_t ygyro; ///< Angular speed around Y axis (millirad /sec)
int16_t zgyro; ///< Angular speed around Z axis (millirad /sec)
int16_t xmag; ///< X Magnetic field (milli tesla)
int16_t ymag; ///< Y Magnetic field (milli tesla)
int16_t zmag; ///< Z Magnetic field (milli tesla)
} mavlink_scaled_imu_t;
#define MAVLINK_MSG_ID_SCALED_IMU_LEN 26
#define MAVLINK_MSG_ID_26_LEN 26
#define MAVLINK_MESSAGE_INFO_SCALED_IMU { \
"SCALED_IMU", \
10, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_scaled_imu_t, usec) }, \
{ "xacc", NULL, MAVLINK_TYPE_INT16_T, 0, 8, offsetof(mavlink_scaled_imu_t, xacc) }, \
{ "yacc", NULL, MAVLINK_TYPE_INT16_T, 0, 10, offsetof(mavlink_scaled_imu_t, yacc) }, \
{ "zacc", NULL, MAVLINK_TYPE_INT16_T, 0, 12, offsetof(mavlink_scaled_imu_t, zacc) }, \
{ "xgyro", NULL, MAVLINK_TYPE_INT16_T, 0, 14, offsetof(mavlink_scaled_imu_t, xgyro) }, \
{ "ygyro", NULL, MAVLINK_TYPE_INT16_T, 0, 16, offsetof(mavlink_scaled_imu_t, ygyro) }, \
{ "zgyro", NULL, MAVLINK_TYPE_INT16_T, 0, 18, offsetof(mavlink_scaled_imu_t, zgyro) }, \
{ "xmag", NULL, MAVLINK_TYPE_INT16_T, 0, 20, offsetof(mavlink_scaled_imu_t, xmag) }, \
{ "ymag", NULL, MAVLINK_TYPE_INT16_T, 0, 22, offsetof(mavlink_scaled_imu_t, ymag) }, \
{ "zmag", NULL, MAVLINK_TYPE_INT16_T, 0, 24, offsetof(mavlink_scaled_imu_t, zmag) }, \
} \
}
/**
* @brief Pack a scaled_imu message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param xacc X acceleration (mg)
* @param yacc Y acceleration (mg)
* @param zacc Z acceleration (mg)
* @param xgyro Angular speed around X axis (millirad /sec)
* @param ygyro Angular speed around Y axis (millirad /sec)
* @param zgyro Angular speed around Z axis (millirad /sec)
* @param xmag X Magnetic field (milli tesla)
* @param ymag Y Magnetic field (milli tesla)
* @param zmag Z Magnetic field (milli tesla)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_scaled_imu_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, int16_t xacc, int16_t yacc, int16_t zacc, int16_t xgyro, int16_t ygyro, int16_t zgyro, int16_t xmag, int16_t ymag, int16_t zmag)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, xacc);
_mav_put_int16_t(buf, 10, yacc);
_mav_put_int16_t(buf, 12, zacc);
_mav_put_int16_t(buf, 14, xgyro);
_mav_put_int16_t(buf, 16, ygyro);
_mav_put_int16_t(buf, 18, zgyro);
_mav_put_int16_t(buf, 20, xmag);
_mav_put_int16_t(buf, 22, ymag);
_mav_put_int16_t(buf, 24, zmag);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_scaled_imu_t packet;
packet.usec = usec;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
packet.xgyro = xgyro;
packet.ygyro = ygyro;
packet.zgyro = zgyro;
packet.xmag = xmag;
packet.ymag = ymag;
packet.zmag = zmag;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_SCALED_IMU;
return mavlink_finalize_message(msg, system_id, component_id, 26);
}
/**
* @brief Pack a scaled_imu message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param xacc X acceleration (mg)
* @param yacc Y acceleration (mg)
* @param zacc Z acceleration (mg)
* @param xgyro Angular speed around X axis (millirad /sec)
* @param ygyro Angular speed around Y axis (millirad /sec)
* @param zgyro Angular speed around Z axis (millirad /sec)
* @param xmag X Magnetic field (milli tesla)
* @param ymag Y Magnetic field (milli tesla)
* @param zmag Z Magnetic field (milli tesla)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_scaled_imu_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,int16_t xacc,int16_t yacc,int16_t zacc,int16_t xgyro,int16_t ygyro,int16_t zgyro,int16_t xmag,int16_t ymag,int16_t zmag)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, xacc);
_mav_put_int16_t(buf, 10, yacc);
_mav_put_int16_t(buf, 12, zacc);
_mav_put_int16_t(buf, 14, xgyro);
_mav_put_int16_t(buf, 16, ygyro);
_mav_put_int16_t(buf, 18, zgyro);
_mav_put_int16_t(buf, 20, xmag);
_mav_put_int16_t(buf, 22, ymag);
_mav_put_int16_t(buf, 24, zmag);
memcpy(_MAV_PAYLOAD(msg), buf, 26);
#else
mavlink_scaled_imu_t packet;
packet.usec = usec;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
packet.xgyro = xgyro;
packet.ygyro = ygyro;
packet.zgyro = zgyro;
packet.xmag = xmag;
packet.ymag = ymag;
packet.zmag = zmag;
memcpy(_MAV_PAYLOAD(msg), &packet, 26);
#endif
msg->msgid = MAVLINK_MSG_ID_SCALED_IMU;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 26);
}
/**
* @brief Encode a scaled_imu struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param scaled_imu C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_scaled_imu_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_scaled_imu_t* scaled_imu)
{
return mavlink_msg_scaled_imu_pack(system_id, component_id, msg, scaled_imu->usec, scaled_imu->xacc, scaled_imu->yacc, scaled_imu->zacc, scaled_imu->xgyro, scaled_imu->ygyro, scaled_imu->zgyro, scaled_imu->xmag, scaled_imu->ymag, scaled_imu->zmag);
}
/**
* @brief Send a scaled_imu message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param xacc X acceleration (mg)
* @param yacc Y acceleration (mg)
* @param zacc Z acceleration (mg)
* @param xgyro Angular speed around X axis (millirad /sec)
* @param ygyro Angular speed around Y axis (millirad /sec)
* @param zgyro Angular speed around Z axis (millirad /sec)
* @param xmag X Magnetic field (milli tesla)
* @param ymag Y Magnetic field (milli tesla)
* @param zmag Z Magnetic field (milli tesla)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_scaled_imu_send(mavlink_channel_t chan, uint64_t usec, int16_t xacc, int16_t yacc, int16_t zacc, int16_t xgyro, int16_t ygyro, int16_t zgyro, int16_t xmag, int16_t ymag, int16_t zmag)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[26];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_int16_t(buf, 8, xacc);
_mav_put_int16_t(buf, 10, yacc);
_mav_put_int16_t(buf, 12, zacc);
_mav_put_int16_t(buf, 14, xgyro);
_mav_put_int16_t(buf, 16, ygyro);
_mav_put_int16_t(buf, 18, zgyro);
_mav_put_int16_t(buf, 20, xmag);
_mav_put_int16_t(buf, 22, ymag);
_mav_put_int16_t(buf, 24, zmag);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SCALED_IMU, buf, 26);
#else
mavlink_scaled_imu_t packet;
packet.usec = usec;
packet.xacc = xacc;
packet.yacc = yacc;
packet.zacc = zacc;
packet.xgyro = xgyro;
packet.ygyro = ygyro;
packet.zgyro = zgyro;
packet.xmag = xmag;
packet.ymag = ymag;
packet.zmag = zmag;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SCALED_IMU, (const char *)&packet, 26);
#endif
}
#endif
// MESSAGE SCALED_IMU UNPACKING
/**
* @brief Get field usec from scaled_imu message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_scaled_imu_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field xacc from scaled_imu message
*
* @return X acceleration (mg)
*/
static inline int16_t mavlink_msg_scaled_imu_get_xacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 8);
}
/**
* @brief Get field yacc from scaled_imu message
*
* @return Y acceleration (mg)
*/
static inline int16_t mavlink_msg_scaled_imu_get_yacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 10);
}
/**
* @brief Get field zacc from scaled_imu message
*
* @return Z acceleration (mg)
*/
static inline int16_t mavlink_msg_scaled_imu_get_zacc(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 12);
}
/**
* @brief Get field xgyro from scaled_imu message
*
* @return Angular speed around X axis (millirad /sec)
*/
static inline int16_t mavlink_msg_scaled_imu_get_xgyro(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 14);
}
/**
* @brief Get field ygyro from scaled_imu message
*
* @return Angular speed around Y axis (millirad /sec)
*/
static inline int16_t mavlink_msg_scaled_imu_get_ygyro(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 16);
}
/**
* @brief Get field zgyro from scaled_imu message
*
* @return Angular speed around Z axis (millirad /sec)
*/
static inline int16_t mavlink_msg_scaled_imu_get_zgyro(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 18);
}
/**
* @brief Get field xmag from scaled_imu message
*
* @return X Magnetic field (milli tesla)
*/
static inline int16_t mavlink_msg_scaled_imu_get_xmag(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 20);
}
/**
* @brief Get field ymag from scaled_imu message
*
* @return Y Magnetic field (milli tesla)
*/
static inline int16_t mavlink_msg_scaled_imu_get_ymag(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 22);
}
/**
* @brief Get field zmag from scaled_imu message
*
* @return Z Magnetic field (milli tesla)
*/
static inline int16_t mavlink_msg_scaled_imu_get_zmag(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 24);
}
/**
* @brief Decode a scaled_imu message into a struct
*
* @param msg The message to decode
* @param scaled_imu C-struct to decode the message contents into
*/
static inline void mavlink_msg_scaled_imu_decode(const mavlink_message_t* msg, mavlink_scaled_imu_t* scaled_imu)
{
#if MAVLINK_NEED_BYTE_SWAP
scaled_imu->usec = mavlink_msg_scaled_imu_get_usec(msg);
scaled_imu->xacc = mavlink_msg_scaled_imu_get_xacc(msg);
scaled_imu->yacc = mavlink_msg_scaled_imu_get_yacc(msg);
scaled_imu->zacc = mavlink_msg_scaled_imu_get_zacc(msg);
scaled_imu->xgyro = mavlink_msg_scaled_imu_get_xgyro(msg);
scaled_imu->ygyro = mavlink_msg_scaled_imu_get_ygyro(msg);
scaled_imu->zgyro = mavlink_msg_scaled_imu_get_zgyro(msg);
scaled_imu->xmag = mavlink_msg_scaled_imu_get_xmag(msg);
scaled_imu->ymag = mavlink_msg_scaled_imu_get_ymag(msg);
scaled_imu->zmag = mavlink_msg_scaled_imu_get_zmag(msg);
#else
memcpy(scaled_imu, _MAV_PAYLOAD(msg), 26);
#endif
}
@@ -1,210 +0,0 @@
// MESSAGE SCALED_PRESSURE PACKING
#define MAVLINK_MSG_ID_SCALED_PRESSURE 38
typedef struct __mavlink_scaled_pressure_t
{
uint64_t usec; ///< Timestamp (microseconds since UNIX epoch or microseconds since system boot)
float press_abs; ///< Absolute pressure (hectopascal)
float press_diff; ///< Differential pressure 1 (hectopascal)
int16_t temperature; ///< Temperature measurement (0.01 degrees celsius)
} mavlink_scaled_pressure_t;
#define MAVLINK_MSG_ID_SCALED_PRESSURE_LEN 18
#define MAVLINK_MSG_ID_38_LEN 18
#define MAVLINK_MESSAGE_INFO_SCALED_PRESSURE { \
"SCALED_PRESSURE", \
4, \
{ { "usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_scaled_pressure_t, usec) }, \
{ "press_abs", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_scaled_pressure_t, press_abs) }, \
{ "press_diff", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_scaled_pressure_t, press_diff) }, \
{ "temperature", NULL, MAVLINK_TYPE_INT16_T, 0, 16, offsetof(mavlink_scaled_pressure_t, temperature) }, \
} \
}
/**
* @brief Pack a scaled_pressure message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param press_abs Absolute pressure (hectopascal)
* @param press_diff Differential pressure 1 (hectopascal)
* @param temperature Temperature measurement (0.01 degrees celsius)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_scaled_pressure_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t usec, float press_abs, float press_diff, int16_t temperature)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, press_abs);
_mav_put_float(buf, 12, press_diff);
_mav_put_int16_t(buf, 16, temperature);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_scaled_pressure_t packet;
packet.usec = usec;
packet.press_abs = press_abs;
packet.press_diff = press_diff;
packet.temperature = temperature;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_SCALED_PRESSURE;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a scaled_pressure message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param press_abs Absolute pressure (hectopascal)
* @param press_diff Differential pressure 1 (hectopascal)
* @param temperature Temperature measurement (0.01 degrees celsius)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_scaled_pressure_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t usec,float press_abs,float press_diff,int16_t temperature)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, press_abs);
_mav_put_float(buf, 12, press_diff);
_mav_put_int16_t(buf, 16, temperature);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_scaled_pressure_t packet;
packet.usec = usec;
packet.press_abs = press_abs;
packet.press_diff = press_diff;
packet.temperature = temperature;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_SCALED_PRESSURE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a scaled_pressure struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param scaled_pressure C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_scaled_pressure_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_scaled_pressure_t* scaled_pressure)
{
return mavlink_msg_scaled_pressure_pack(system_id, component_id, msg, scaled_pressure->usec, scaled_pressure->press_abs, scaled_pressure->press_diff, scaled_pressure->temperature);
}
/**
* @brief Send a scaled_pressure message
* @param chan MAVLink channel to send the message
*
* @param usec Timestamp (microseconds since UNIX epoch or microseconds since system boot)
* @param press_abs Absolute pressure (hectopascal)
* @param press_diff Differential pressure 1 (hectopascal)
* @param temperature Temperature measurement (0.01 degrees celsius)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_scaled_pressure_send(mavlink_channel_t chan, uint64_t usec, float press_abs, float press_diff, int16_t temperature)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint64_t(buf, 0, usec);
_mav_put_float(buf, 8, press_abs);
_mav_put_float(buf, 12, press_diff);
_mav_put_int16_t(buf, 16, temperature);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SCALED_PRESSURE, buf, 18);
#else
mavlink_scaled_pressure_t packet;
packet.usec = usec;
packet.press_abs = press_abs;
packet.press_diff = press_diff;
packet.temperature = temperature;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SCALED_PRESSURE, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE SCALED_PRESSURE UNPACKING
/**
* @brief Get field usec from scaled_pressure message
*
* @return Timestamp (microseconds since UNIX epoch or microseconds since system boot)
*/
static inline uint64_t mavlink_msg_scaled_pressure_get_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Get field press_abs from scaled_pressure message
*
* @return Absolute pressure (hectopascal)
*/
static inline float mavlink_msg_scaled_pressure_get_press_abs(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field press_diff from scaled_pressure message
*
* @return Differential pressure 1 (hectopascal)
*/
static inline float mavlink_msg_scaled_pressure_get_press_diff(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field temperature from scaled_pressure message
*
* @return Temperature measurement (0.01 degrees celsius)
*/
static inline int16_t mavlink_msg_scaled_pressure_get_temperature(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 16);
}
/**
* @brief Decode a scaled_pressure message into a struct
*
* @param msg The message to decode
* @param scaled_pressure C-struct to decode the message contents into
*/
static inline void mavlink_msg_scaled_pressure_decode(const mavlink_message_t* msg, mavlink_scaled_pressure_t* scaled_pressure)
{
#if MAVLINK_NEED_BYTE_SWAP
scaled_pressure->usec = mavlink_msg_scaled_pressure_get_usec(msg);
scaled_pressure->press_abs = mavlink_msg_scaled_pressure_get_press_abs(msg);
scaled_pressure->press_diff = mavlink_msg_scaled_pressure_get_press_diff(msg);
scaled_pressure->temperature = mavlink_msg_scaled_pressure_get_temperature(msg);
#else
memcpy(scaled_pressure, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,298 +0,0 @@
// MESSAGE SERVO_OUTPUT_RAW PACKING
#define MAVLINK_MSG_ID_SERVO_OUTPUT_RAW 37
typedef struct __mavlink_servo_output_raw_t
{
uint16_t servo1_raw; ///< Servo output 1 value, in microseconds
uint16_t servo2_raw; ///< Servo output 2 value, in microseconds
uint16_t servo3_raw; ///< Servo output 3 value, in microseconds
uint16_t servo4_raw; ///< Servo output 4 value, in microseconds
uint16_t servo5_raw; ///< Servo output 5 value, in microseconds
uint16_t servo6_raw; ///< Servo output 6 value, in microseconds
uint16_t servo7_raw; ///< Servo output 7 value, in microseconds
uint16_t servo8_raw; ///< Servo output 8 value, in microseconds
} mavlink_servo_output_raw_t;
#define MAVLINK_MSG_ID_SERVO_OUTPUT_RAW_LEN 16
#define MAVLINK_MSG_ID_37_LEN 16
#define MAVLINK_MESSAGE_INFO_SERVO_OUTPUT_RAW { \
"SERVO_OUTPUT_RAW", \
8, \
{ { "servo1_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_servo_output_raw_t, servo1_raw) }, \
{ "servo2_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_servo_output_raw_t, servo2_raw) }, \
{ "servo3_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 4, offsetof(mavlink_servo_output_raw_t, servo3_raw) }, \
{ "servo4_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 6, offsetof(mavlink_servo_output_raw_t, servo4_raw) }, \
{ "servo5_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 8, offsetof(mavlink_servo_output_raw_t, servo5_raw) }, \
{ "servo6_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 10, offsetof(mavlink_servo_output_raw_t, servo6_raw) }, \
{ "servo7_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 12, offsetof(mavlink_servo_output_raw_t, servo7_raw) }, \
{ "servo8_raw", NULL, MAVLINK_TYPE_UINT16_T, 0, 14, offsetof(mavlink_servo_output_raw_t, servo8_raw) }, \
} \
}
/**
* @brief Pack a servo_output_raw message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param servo1_raw Servo output 1 value, in microseconds
* @param servo2_raw Servo output 2 value, in microseconds
* @param servo3_raw Servo output 3 value, in microseconds
* @param servo4_raw Servo output 4 value, in microseconds
* @param servo5_raw Servo output 5 value, in microseconds
* @param servo6_raw Servo output 6 value, in microseconds
* @param servo7_raw Servo output 7 value, in microseconds
* @param servo8_raw Servo output 8 value, in microseconds
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_servo_output_raw_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint16_t servo1_raw, uint16_t servo2_raw, uint16_t servo3_raw, uint16_t servo4_raw, uint16_t servo5_raw, uint16_t servo6_raw, uint16_t servo7_raw, uint16_t servo8_raw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_uint16_t(buf, 0, servo1_raw);
_mav_put_uint16_t(buf, 2, servo2_raw);
_mav_put_uint16_t(buf, 4, servo3_raw);
_mav_put_uint16_t(buf, 6, servo4_raw);
_mav_put_uint16_t(buf, 8, servo5_raw);
_mav_put_uint16_t(buf, 10, servo6_raw);
_mav_put_uint16_t(buf, 12, servo7_raw);
_mav_put_uint16_t(buf, 14, servo8_raw);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_servo_output_raw_t packet;
packet.servo1_raw = servo1_raw;
packet.servo2_raw = servo2_raw;
packet.servo3_raw = servo3_raw;
packet.servo4_raw = servo4_raw;
packet.servo5_raw = servo5_raw;
packet.servo6_raw = servo6_raw;
packet.servo7_raw = servo7_raw;
packet.servo8_raw = servo8_raw;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_SERVO_OUTPUT_RAW;
return mavlink_finalize_message(msg, system_id, component_id, 16);
}
/**
* @brief Pack a servo_output_raw message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param servo1_raw Servo output 1 value, in microseconds
* @param servo2_raw Servo output 2 value, in microseconds
* @param servo3_raw Servo output 3 value, in microseconds
* @param servo4_raw Servo output 4 value, in microseconds
* @param servo5_raw Servo output 5 value, in microseconds
* @param servo6_raw Servo output 6 value, in microseconds
* @param servo7_raw Servo output 7 value, in microseconds
* @param servo8_raw Servo output 8 value, in microseconds
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_servo_output_raw_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint16_t servo1_raw,uint16_t servo2_raw,uint16_t servo3_raw,uint16_t servo4_raw,uint16_t servo5_raw,uint16_t servo6_raw,uint16_t servo7_raw,uint16_t servo8_raw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_uint16_t(buf, 0, servo1_raw);
_mav_put_uint16_t(buf, 2, servo2_raw);
_mav_put_uint16_t(buf, 4, servo3_raw);
_mav_put_uint16_t(buf, 6, servo4_raw);
_mav_put_uint16_t(buf, 8, servo5_raw);
_mav_put_uint16_t(buf, 10, servo6_raw);
_mav_put_uint16_t(buf, 12, servo7_raw);
_mav_put_uint16_t(buf, 14, servo8_raw);
memcpy(_MAV_PAYLOAD(msg), buf, 16);
#else
mavlink_servo_output_raw_t packet;
packet.servo1_raw = servo1_raw;
packet.servo2_raw = servo2_raw;
packet.servo3_raw = servo3_raw;
packet.servo4_raw = servo4_raw;
packet.servo5_raw = servo5_raw;
packet.servo6_raw = servo6_raw;
packet.servo7_raw = servo7_raw;
packet.servo8_raw = servo8_raw;
memcpy(_MAV_PAYLOAD(msg), &packet, 16);
#endif
msg->msgid = MAVLINK_MSG_ID_SERVO_OUTPUT_RAW;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 16);
}
/**
* @brief Encode a servo_output_raw struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param servo_output_raw C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_servo_output_raw_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_servo_output_raw_t* servo_output_raw)
{
return mavlink_msg_servo_output_raw_pack(system_id, component_id, msg, servo_output_raw->servo1_raw, servo_output_raw->servo2_raw, servo_output_raw->servo3_raw, servo_output_raw->servo4_raw, servo_output_raw->servo5_raw, servo_output_raw->servo6_raw, servo_output_raw->servo7_raw, servo_output_raw->servo8_raw);
}
/**
* @brief Send a servo_output_raw message
* @param chan MAVLink channel to send the message
*
* @param servo1_raw Servo output 1 value, in microseconds
* @param servo2_raw Servo output 2 value, in microseconds
* @param servo3_raw Servo output 3 value, in microseconds
* @param servo4_raw Servo output 4 value, in microseconds
* @param servo5_raw Servo output 5 value, in microseconds
* @param servo6_raw Servo output 6 value, in microseconds
* @param servo7_raw Servo output 7 value, in microseconds
* @param servo8_raw Servo output 8 value, in microseconds
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_servo_output_raw_send(mavlink_channel_t chan, uint16_t servo1_raw, uint16_t servo2_raw, uint16_t servo3_raw, uint16_t servo4_raw, uint16_t servo5_raw, uint16_t servo6_raw, uint16_t servo7_raw, uint16_t servo8_raw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[16];
_mav_put_uint16_t(buf, 0, servo1_raw);
_mav_put_uint16_t(buf, 2, servo2_raw);
_mav_put_uint16_t(buf, 4, servo3_raw);
_mav_put_uint16_t(buf, 6, servo4_raw);
_mav_put_uint16_t(buf, 8, servo5_raw);
_mav_put_uint16_t(buf, 10, servo6_raw);
_mav_put_uint16_t(buf, 12, servo7_raw);
_mav_put_uint16_t(buf, 14, servo8_raw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SERVO_OUTPUT_RAW, buf, 16);
#else
mavlink_servo_output_raw_t packet;
packet.servo1_raw = servo1_raw;
packet.servo2_raw = servo2_raw;
packet.servo3_raw = servo3_raw;
packet.servo4_raw = servo4_raw;
packet.servo5_raw = servo5_raw;
packet.servo6_raw = servo6_raw;
packet.servo7_raw = servo7_raw;
packet.servo8_raw = servo8_raw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SERVO_OUTPUT_RAW, (const char *)&packet, 16);
#endif
}
#endif
// MESSAGE SERVO_OUTPUT_RAW UNPACKING
/**
* @brief Get field servo1_raw from servo_output_raw message
*
* @return Servo output 1 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo1_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 0);
}
/**
* @brief Get field servo2_raw from servo_output_raw message
*
* @return Servo output 2 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo2_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Get field servo3_raw from servo_output_raw message
*
* @return Servo output 3 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo3_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 4);
}
/**
* @brief Get field servo4_raw from servo_output_raw message
*
* @return Servo output 4 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo4_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 6);
}
/**
* @brief Get field servo5_raw from servo_output_raw message
*
* @return Servo output 5 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo5_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 8);
}
/**
* @brief Get field servo6_raw from servo_output_raw message
*
* @return Servo output 6 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo6_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 10);
}
/**
* @brief Get field servo7_raw from servo_output_raw message
*
* @return Servo output 7 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo7_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 12);
}
/**
* @brief Get field servo8_raw from servo_output_raw message
*
* @return Servo output 8 value, in microseconds
*/
static inline uint16_t mavlink_msg_servo_output_raw_get_servo8_raw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 14);
}
/**
* @brief Decode a servo_output_raw message into a struct
*
* @param msg The message to decode
* @param servo_output_raw C-struct to decode the message contents into
*/
static inline void mavlink_msg_servo_output_raw_decode(const mavlink_message_t* msg, mavlink_servo_output_raw_t* servo_output_raw)
{
#if MAVLINK_NEED_BYTE_SWAP
servo_output_raw->servo1_raw = mavlink_msg_servo_output_raw_get_servo1_raw(msg);
servo_output_raw->servo2_raw = mavlink_msg_servo_output_raw_get_servo2_raw(msg);
servo_output_raw->servo3_raw = mavlink_msg_servo_output_raw_get_servo3_raw(msg);
servo_output_raw->servo4_raw = mavlink_msg_servo_output_raw_get_servo4_raw(msg);
servo_output_raw->servo5_raw = mavlink_msg_servo_output_raw_get_servo5_raw(msg);
servo_output_raw->servo6_raw = mavlink_msg_servo_output_raw_get_servo6_raw(msg);
servo_output_raw->servo7_raw = mavlink_msg_servo_output_raw_get_servo7_raw(msg);
servo_output_raw->servo8_raw = mavlink_msg_servo_output_raw_get_servo8_raw(msg);
#else
memcpy(servo_output_raw, _MAV_PAYLOAD(msg), 16);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE SET_ALTITUDE PACKING
#define MAVLINK_MSG_ID_SET_ALTITUDE 65
typedef struct __mavlink_set_altitude_t
{
uint8_t target; ///< The system setting the altitude
uint32_t mode; ///< The new altitude in meters
} mavlink_set_altitude_t;
#define MAVLINK_MSG_ID_SET_ALTITUDE_LEN 5
#define MAVLINK_MSG_ID_65_LEN 5
#define MAVLINK_MESSAGE_INFO_SET_ALTITUDE { \
"SET_ALTITUDE", \
2, \
{ { "target", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_set_altitude_t, target) }, \
{ "mode", NULL, MAVLINK_TYPE_UINT32_T, 0, 1, offsetof(mavlink_set_altitude_t, mode) }, \
} \
}
/**
* @brief Pack a set_altitude message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target The system setting the altitude
* @param mode The new altitude in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_altitude_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target, uint32_t mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[5];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint32_t(buf, 1, mode);
memcpy(_MAV_PAYLOAD(msg), buf, 5);
#else
mavlink_set_altitude_t packet;
packet.target = target;
packet.mode = mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 5);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_ALTITUDE;
return mavlink_finalize_message(msg, system_id, component_id, 5);
}
/**
* @brief Pack a set_altitude message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target The system setting the altitude
* @param mode The new altitude in meters
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_altitude_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target,uint32_t mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[5];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint32_t(buf, 1, mode);
memcpy(_MAV_PAYLOAD(msg), buf, 5);
#else
mavlink_set_altitude_t packet;
packet.target = target;
packet.mode = mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 5);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_ALTITUDE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 5);
}
/**
* @brief Encode a set_altitude struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_altitude C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_altitude_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_altitude_t* set_altitude)
{
return mavlink_msg_set_altitude_pack(system_id, component_id, msg, set_altitude->target, set_altitude->mode);
}
/**
* @brief Send a set_altitude message
* @param chan MAVLink channel to send the message
*
* @param target The system setting the altitude
* @param mode The new altitude in meters
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_altitude_send(mavlink_channel_t chan, uint8_t target, uint32_t mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[5];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint32_t(buf, 1, mode);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ALTITUDE, buf, 5);
#else
mavlink_set_altitude_t packet;
packet.target = target;
packet.mode = mode;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ALTITUDE, (const char *)&packet, 5);
#endif
}
#endif
// MESSAGE SET_ALTITUDE UNPACKING
/**
* @brief Get field target from set_altitude message
*
* @return The system setting the altitude
*/
static inline uint8_t mavlink_msg_set_altitude_get_target(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field mode from set_altitude message
*
* @return The new altitude in meters
*/
static inline uint32_t mavlink_msg_set_altitude_get_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 1);
}
/**
* @brief Decode a set_altitude message into a struct
*
* @param msg The message to decode
* @param set_altitude C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_altitude_decode(const mavlink_message_t* msg, mavlink_set_altitude_t* set_altitude)
{
#if MAVLINK_NEED_BYTE_SWAP
set_altitude->target = mavlink_msg_set_altitude_get_target(msg);
set_altitude->mode = mavlink_msg_set_altitude_get_mode(msg);
#else
memcpy(set_altitude, _MAV_PAYLOAD(msg), 5);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE SET_MODE PACKING
#define MAVLINK_MSG_ID_SET_MODE 11
typedef struct __mavlink_set_mode_t
{
uint8_t target; ///< The system setting the mode
uint8_t mode; ///< The new mode
} mavlink_set_mode_t;
#define MAVLINK_MSG_ID_SET_MODE_LEN 2
#define MAVLINK_MSG_ID_11_LEN 2
#define MAVLINK_MESSAGE_INFO_SET_MODE { \
"SET_MODE", \
2, \
{ { "target", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_set_mode_t, target) }, \
{ "mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_set_mode_t, mode) }, \
} \
}
/**
* @brief Pack a set_mode message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target The system setting the mode
* @param mode The new mode
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_mode_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target, uint8_t mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, mode);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_set_mode_t packet;
packet.target = target;
packet.mode = mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_MODE;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a set_mode message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target The system setting the mode
* @param mode The new mode
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_mode_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target,uint8_t mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, mode);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_set_mode_t packet;
packet.target = target;
packet.mode = mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_MODE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a set_mode struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_mode C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_mode_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_mode_t* set_mode)
{
return mavlink_msg_set_mode_pack(system_id, component_id, msg, set_mode->target, set_mode->mode);
}
/**
* @brief Send a set_mode message
* @param chan MAVLink channel to send the message
*
* @param target The system setting the mode
* @param mode The new mode
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_mode_send(mavlink_channel_t chan, uint8_t target, uint8_t mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, mode);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_MODE, buf, 2);
#else
mavlink_set_mode_t packet;
packet.target = target;
packet.mode = mode;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_MODE, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE SET_MODE UNPACKING
/**
* @brief Get field target from set_mode message
*
* @return The system setting the mode
*/
static inline uint8_t mavlink_msg_set_mode_get_target(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field mode from set_mode message
*
* @return The new mode
*/
static inline uint8_t mavlink_msg_set_mode_get_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Decode a set_mode message into a struct
*
* @param msg The message to decode
* @param set_mode C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_mode_decode(const mavlink_message_t* msg, mavlink_set_mode_t* set_mode)
{
#if MAVLINK_NEED_BYTE_SWAP
set_mode->target = mavlink_msg_set_mode_get_target(msg);
set_mode->mode = mavlink_msg_set_mode_get_mode(msg);
#else
memcpy(set_mode, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE SET_NAV_MODE PACKING
#define MAVLINK_MSG_ID_SET_NAV_MODE 12
typedef struct __mavlink_set_nav_mode_t
{
uint8_t target; ///< The system setting the mode
uint8_t nav_mode; ///< The new navigation mode
} mavlink_set_nav_mode_t;
#define MAVLINK_MSG_ID_SET_NAV_MODE_LEN 2
#define MAVLINK_MSG_ID_12_LEN 2
#define MAVLINK_MESSAGE_INFO_SET_NAV_MODE { \
"SET_NAV_MODE", \
2, \
{ { "target", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_set_nav_mode_t, target) }, \
{ "nav_mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_set_nav_mode_t, nav_mode) }, \
} \
}
/**
* @brief Pack a set_nav_mode message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target The system setting the mode
* @param nav_mode The new navigation mode
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_nav_mode_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target, uint8_t nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, nav_mode);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_set_nav_mode_t packet;
packet.target = target;
packet.nav_mode = nav_mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_NAV_MODE;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a set_nav_mode message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target The system setting the mode
* @param nav_mode The new navigation mode
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_nav_mode_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target,uint8_t nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, nav_mode);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_set_nav_mode_t packet;
packet.target = target;
packet.nav_mode = nav_mode;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_NAV_MODE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a set_nav_mode struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_nav_mode C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_nav_mode_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_nav_mode_t* set_nav_mode)
{
return mavlink_msg_set_nav_mode_pack(system_id, component_id, msg, set_nav_mode->target, set_nav_mode->nav_mode);
}
/**
* @brief Send a set_nav_mode message
* @param chan MAVLink channel to send the message
*
* @param target The system setting the mode
* @param nav_mode The new navigation mode
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_nav_mode_send(mavlink_channel_t chan, uint8_t target, uint8_t nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target);
_mav_put_uint8_t(buf, 1, nav_mode);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_NAV_MODE, buf, 2);
#else
mavlink_set_nav_mode_t packet;
packet.target = target;
packet.nav_mode = nav_mode;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_NAV_MODE, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE SET_NAV_MODE UNPACKING
/**
* @brief Get field target from set_nav_mode message
*
* @return The system setting the mode
*/
static inline uint8_t mavlink_msg_set_nav_mode_get_target(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field nav_mode from set_nav_mode message
*
* @return The new navigation mode
*/
static inline uint8_t mavlink_msg_set_nav_mode_get_nav_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Decode a set_nav_mode message into a struct
*
* @param msg The message to decode
* @param set_nav_mode C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_nav_mode_decode(const mavlink_message_t* msg, mavlink_set_nav_mode_t* set_nav_mode)
{
#if MAVLINK_NEED_BYTE_SWAP
set_nav_mode->target = mavlink_msg_set_nav_mode_get_target(msg);
set_nav_mode->nav_mode = mavlink_msg_set_nav_mode_get_nav_mode(msg);
#else
memcpy(set_nav_mode, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE SET_ROLL_PITCH_YAW_SPEED_THRUST PACKING
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_THRUST 56
typedef struct __mavlink_set_roll_pitch_yaw_speed_thrust_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
float roll_speed; ///< Desired roll angular speed in rad/s
float pitch_speed; ///< Desired pitch angular speed in rad/s
float yaw_speed; ///< Desired yaw angular speed in rad/s
float thrust; ///< Collective thrust, normalized to 0 .. 1
} mavlink_set_roll_pitch_yaw_speed_thrust_t;
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_THRUST_LEN 18
#define MAVLINK_MSG_ID_56_LEN 18
#define MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_SPEED_THRUST { \
"SET_ROLL_PITCH_YAW_SPEED_THRUST", \
6, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_set_roll_pitch_yaw_speed_thrust_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_set_roll_pitch_yaw_speed_thrust_t, target_component) }, \
{ "roll_speed", NULL, MAVLINK_TYPE_FLOAT, 0, 2, offsetof(mavlink_set_roll_pitch_yaw_speed_thrust_t, roll_speed) }, \
{ "pitch_speed", NULL, MAVLINK_TYPE_FLOAT, 0, 6, offsetof(mavlink_set_roll_pitch_yaw_speed_thrust_t, pitch_speed) }, \
{ "yaw_speed", NULL, MAVLINK_TYPE_FLOAT, 0, 10, offsetof(mavlink_set_roll_pitch_yaw_speed_thrust_t, yaw_speed) }, \
{ "thrust", NULL, MAVLINK_TYPE_FLOAT, 0, 14, offsetof(mavlink_set_roll_pitch_yaw_speed_thrust_t, thrust) }, \
} \
}
/**
* @brief Pack a set_roll_pitch_yaw_speed_thrust message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_speed_thrust_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, float roll_speed, float pitch_speed, float yaw_speed, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, roll_speed);
_mav_put_float(buf, 6, pitch_speed);
_mav_put_float(buf, 10, yaw_speed);
_mav_put_float(buf, 14, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_set_roll_pitch_yaw_speed_thrust_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.roll_speed = roll_speed;
packet.pitch_speed = pitch_speed;
packet.yaw_speed = yaw_speed;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_THRUST;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a set_roll_pitch_yaw_speed_thrust message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_speed_thrust_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,float roll_speed,float pitch_speed,float yaw_speed,float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, roll_speed);
_mav_put_float(buf, 6, pitch_speed);
_mav_put_float(buf, 10, yaw_speed);
_mav_put_float(buf, 14, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_set_roll_pitch_yaw_speed_thrust_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.roll_speed = roll_speed;
packet.pitch_speed = pitch_speed;
packet.yaw_speed = yaw_speed;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_THRUST;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a set_roll_pitch_yaw_speed_thrust struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_roll_pitch_yaw_speed_thrust C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_speed_thrust_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_roll_pitch_yaw_speed_thrust_t* set_roll_pitch_yaw_speed_thrust)
{
return mavlink_msg_set_roll_pitch_yaw_speed_thrust_pack(system_id, component_id, msg, set_roll_pitch_yaw_speed_thrust->target_system, set_roll_pitch_yaw_speed_thrust->target_component, set_roll_pitch_yaw_speed_thrust->roll_speed, set_roll_pitch_yaw_speed_thrust->pitch_speed, set_roll_pitch_yaw_speed_thrust->yaw_speed, set_roll_pitch_yaw_speed_thrust->thrust);
}
/**
* @brief Send a set_roll_pitch_yaw_speed_thrust message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @param thrust Collective thrust, normalized to 0 .. 1
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_roll_pitch_yaw_speed_thrust_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, float roll_speed, float pitch_speed, float yaw_speed, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, roll_speed);
_mav_put_float(buf, 6, pitch_speed);
_mav_put_float(buf, 10, yaw_speed);
_mav_put_float(buf, 14, thrust);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_THRUST, buf, 18);
#else
mavlink_set_roll_pitch_yaw_speed_thrust_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.roll_speed = roll_speed;
packet.pitch_speed = pitch_speed;
packet.yaw_speed = yaw_speed;
packet.thrust = thrust;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_THRUST, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE SET_ROLL_PITCH_YAW_SPEED_THRUST UNPACKING
/**
* @brief Get field target_system from set_roll_pitch_yaw_speed_thrust message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from set_roll_pitch_yaw_speed_thrust message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field roll_speed from set_roll_pitch_yaw_speed_thrust message
*
* @return Desired roll angular speed in rad/s
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_roll_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 2);
}
/**
* @brief Get field pitch_speed from set_roll_pitch_yaw_speed_thrust message
*
* @return Desired pitch angular speed in rad/s
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_pitch_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 6);
}
/**
* @brief Get field yaw_speed from set_roll_pitch_yaw_speed_thrust message
*
* @return Desired yaw angular speed in rad/s
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_yaw_speed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 10);
}
/**
* @brief Get field thrust from set_roll_pitch_yaw_speed_thrust message
*
* @return Collective thrust, normalized to 0 .. 1
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_thrust(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 14);
}
/**
* @brief Decode a set_roll_pitch_yaw_speed_thrust message into a struct
*
* @param msg The message to decode
* @param set_roll_pitch_yaw_speed_thrust C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_roll_pitch_yaw_speed_thrust_decode(const mavlink_message_t* msg, mavlink_set_roll_pitch_yaw_speed_thrust_t* set_roll_pitch_yaw_speed_thrust)
{
#if MAVLINK_NEED_BYTE_SWAP
set_roll_pitch_yaw_speed_thrust->target_system = mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_target_system(msg);
set_roll_pitch_yaw_speed_thrust->target_component = mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_target_component(msg);
set_roll_pitch_yaw_speed_thrust->roll_speed = mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_roll_speed(msg);
set_roll_pitch_yaw_speed_thrust->pitch_speed = mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_pitch_speed(msg);
set_roll_pitch_yaw_speed_thrust->yaw_speed = mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_yaw_speed(msg);
set_roll_pitch_yaw_speed_thrust->thrust = mavlink_msg_set_roll_pitch_yaw_speed_thrust_get_thrust(msg);
#else
memcpy(set_roll_pitch_yaw_speed_thrust, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE SET_ROLL_PITCH_YAW_THRUST PACKING
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_THRUST 55
typedef struct __mavlink_set_roll_pitch_yaw_thrust_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
float roll; ///< Desired roll angle in radians
float pitch; ///< Desired pitch angle in radians
float yaw; ///< Desired yaw angle in radians
float thrust; ///< Collective thrust, normalized to 0 .. 1
} mavlink_set_roll_pitch_yaw_thrust_t;
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_THRUST_LEN 18
#define MAVLINK_MSG_ID_55_LEN 18
#define MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_THRUST { \
"SET_ROLL_PITCH_YAW_THRUST", \
6, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_set_roll_pitch_yaw_thrust_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_set_roll_pitch_yaw_thrust_t, target_component) }, \
{ "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 2, offsetof(mavlink_set_roll_pitch_yaw_thrust_t, roll) }, \
{ "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 6, offsetof(mavlink_set_roll_pitch_yaw_thrust_t, pitch) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 10, offsetof(mavlink_set_roll_pitch_yaw_thrust_t, yaw) }, \
{ "thrust", NULL, MAVLINK_TYPE_FLOAT, 0, 14, offsetof(mavlink_set_roll_pitch_yaw_thrust_t, thrust) }, \
} \
}
/**
* @brief Pack a set_roll_pitch_yaw_thrust message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_thrust_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, float roll, float pitch, float yaw, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, roll);
_mav_put_float(buf, 6, pitch);
_mav_put_float(buf, 10, yaw);
_mav_put_float(buf, 14, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_set_roll_pitch_yaw_thrust_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_THRUST;
return mavlink_finalize_message(msg, system_id, component_id, 18);
}
/**
* @brief Pack a set_roll_pitch_yaw_thrust message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @param thrust Collective thrust, normalized to 0 .. 1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_thrust_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,float roll,float pitch,float yaw,float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, roll);
_mav_put_float(buf, 6, pitch);
_mav_put_float(buf, 10, yaw);
_mav_put_float(buf, 14, thrust);
memcpy(_MAV_PAYLOAD(msg), buf, 18);
#else
mavlink_set_roll_pitch_yaw_thrust_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
memcpy(_MAV_PAYLOAD(msg), &packet, 18);
#endif
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_THRUST;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 18);
}
/**
* @brief Encode a set_roll_pitch_yaw_thrust struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_roll_pitch_yaw_thrust C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_thrust_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_roll_pitch_yaw_thrust_t* set_roll_pitch_yaw_thrust)
{
return mavlink_msg_set_roll_pitch_yaw_thrust_pack(system_id, component_id, msg, set_roll_pitch_yaw_thrust->target_system, set_roll_pitch_yaw_thrust->target_component, set_roll_pitch_yaw_thrust->roll, set_roll_pitch_yaw_thrust->pitch, set_roll_pitch_yaw_thrust->yaw, set_roll_pitch_yaw_thrust->thrust);
}
/**
* @brief Send a set_roll_pitch_yaw_thrust message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @param thrust Collective thrust, normalized to 0 .. 1
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_roll_pitch_yaw_thrust_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, float roll, float pitch, float yaw, float thrust)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[18];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_float(buf, 2, roll);
_mav_put_float(buf, 6, pitch);
_mav_put_float(buf, 10, yaw);
_mav_put_float(buf, 14, thrust);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_THRUST, buf, 18);
#else
mavlink_set_roll_pitch_yaw_thrust_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_THRUST, (const char *)&packet, 18);
#endif
}
#endif
// MESSAGE SET_ROLL_PITCH_YAW_THRUST UNPACKING
/**
* @brief Get field target_system from set_roll_pitch_yaw_thrust message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_thrust_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from set_roll_pitch_yaw_thrust message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_thrust_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field roll from set_roll_pitch_yaw_thrust message
*
* @return Desired roll angle in radians
*/
static inline float mavlink_msg_set_roll_pitch_yaw_thrust_get_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 2);
}
/**
* @brief Get field pitch from set_roll_pitch_yaw_thrust message
*
* @return Desired pitch angle in radians
*/
static inline float mavlink_msg_set_roll_pitch_yaw_thrust_get_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 6);
}
/**
* @brief Get field yaw from set_roll_pitch_yaw_thrust message
*
* @return Desired yaw angle in radians
*/
static inline float mavlink_msg_set_roll_pitch_yaw_thrust_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 10);
}
/**
* @brief Get field thrust from set_roll_pitch_yaw_thrust message
*
* @return Collective thrust, normalized to 0 .. 1
*/
static inline float mavlink_msg_set_roll_pitch_yaw_thrust_get_thrust(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 14);
}
/**
* @brief Decode a set_roll_pitch_yaw_thrust message into a struct
*
* @param msg The message to decode
* @param set_roll_pitch_yaw_thrust C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_roll_pitch_yaw_thrust_decode(const mavlink_message_t* msg, mavlink_set_roll_pitch_yaw_thrust_t* set_roll_pitch_yaw_thrust)
{
#if MAVLINK_NEED_BYTE_SWAP
set_roll_pitch_yaw_thrust->target_system = mavlink_msg_set_roll_pitch_yaw_thrust_get_target_system(msg);
set_roll_pitch_yaw_thrust->target_component = mavlink_msg_set_roll_pitch_yaw_thrust_get_target_component(msg);
set_roll_pitch_yaw_thrust->roll = mavlink_msg_set_roll_pitch_yaw_thrust_get_roll(msg);
set_roll_pitch_yaw_thrust->pitch = mavlink_msg_set_roll_pitch_yaw_thrust_get_pitch(msg);
set_roll_pitch_yaw_thrust->yaw = mavlink_msg_set_roll_pitch_yaw_thrust_get_yaw(msg);
set_roll_pitch_yaw_thrust->thrust = mavlink_msg_set_roll_pitch_yaw_thrust_get_thrust(msg);
#else
memcpy(set_roll_pitch_yaw_thrust, _MAV_PAYLOAD(msg), 18);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE STATE_CORRECTION PACKING
#define MAVLINK_MSG_ID_STATE_CORRECTION 64
typedef struct __mavlink_state_correction_t
{
float xErr; ///< x position error
float yErr; ///< y position error
float zErr; ///< z position error
float rollErr; ///< roll error (radians)
float pitchErr; ///< pitch error (radians)
float yawErr; ///< yaw error (radians)
float vxErr; ///< x velocity
float vyErr; ///< y velocity
float vzErr; ///< z velocity
} mavlink_state_correction_t;
#define MAVLINK_MSG_ID_STATE_CORRECTION_LEN 36
#define MAVLINK_MSG_ID_64_LEN 36
#define MAVLINK_MESSAGE_INFO_STATE_CORRECTION { \
"STATE_CORRECTION", \
9, \
{ { "xErr", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_state_correction_t, xErr) }, \
{ "yErr", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_state_correction_t, yErr) }, \
{ "zErr", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_state_correction_t, zErr) }, \
{ "rollErr", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_state_correction_t, rollErr) }, \
{ "pitchErr", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_state_correction_t, pitchErr) }, \
{ "yawErr", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_state_correction_t, yawErr) }, \
{ "vxErr", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_state_correction_t, vxErr) }, \
{ "vyErr", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_state_correction_t, vyErr) }, \
{ "vzErr", NULL, MAVLINK_TYPE_FLOAT, 0, 32, offsetof(mavlink_state_correction_t, vzErr) }, \
} \
}
/**
* @brief Pack a state_correction message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param xErr x position error
* @param yErr y position error
* @param zErr z position error
* @param rollErr roll error (radians)
* @param pitchErr pitch error (radians)
* @param yawErr yaw error (radians)
* @param vxErr x velocity
* @param vyErr y velocity
* @param vzErr z velocity
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_state_correction_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
float xErr, float yErr, float zErr, float rollErr, float pitchErr, float yawErr, float vxErr, float vyErr, float vzErr)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_float(buf, 0, xErr);
_mav_put_float(buf, 4, yErr);
_mav_put_float(buf, 8, zErr);
_mav_put_float(buf, 12, rollErr);
_mav_put_float(buf, 16, pitchErr);
_mav_put_float(buf, 20, yawErr);
_mav_put_float(buf, 24, vxErr);
_mav_put_float(buf, 28, vyErr);
_mav_put_float(buf, 32, vzErr);
memcpy(_MAV_PAYLOAD(msg), buf, 36);
#else
mavlink_state_correction_t packet;
packet.xErr = xErr;
packet.yErr = yErr;
packet.zErr = zErr;
packet.rollErr = rollErr;
packet.pitchErr = pitchErr;
packet.yawErr = yawErr;
packet.vxErr = vxErr;
packet.vyErr = vyErr;
packet.vzErr = vzErr;
memcpy(_MAV_PAYLOAD(msg), &packet, 36);
#endif
msg->msgid = MAVLINK_MSG_ID_STATE_CORRECTION;
return mavlink_finalize_message(msg, system_id, component_id, 36);
}
/**
* @brief Pack a state_correction message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param xErr x position error
* @param yErr y position error
* @param zErr z position error
* @param rollErr roll error (radians)
* @param pitchErr pitch error (radians)
* @param yawErr yaw error (radians)
* @param vxErr x velocity
* @param vyErr y velocity
* @param vzErr z velocity
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_state_correction_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
float xErr,float yErr,float zErr,float rollErr,float pitchErr,float yawErr,float vxErr,float vyErr,float vzErr)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_float(buf, 0, xErr);
_mav_put_float(buf, 4, yErr);
_mav_put_float(buf, 8, zErr);
_mav_put_float(buf, 12, rollErr);
_mav_put_float(buf, 16, pitchErr);
_mav_put_float(buf, 20, yawErr);
_mav_put_float(buf, 24, vxErr);
_mav_put_float(buf, 28, vyErr);
_mav_put_float(buf, 32, vzErr);
memcpy(_MAV_PAYLOAD(msg), buf, 36);
#else
mavlink_state_correction_t packet;
packet.xErr = xErr;
packet.yErr = yErr;
packet.zErr = zErr;
packet.rollErr = rollErr;
packet.pitchErr = pitchErr;
packet.yawErr = yawErr;
packet.vxErr = vxErr;
packet.vyErr = vyErr;
packet.vzErr = vzErr;
memcpy(_MAV_PAYLOAD(msg), &packet, 36);
#endif
msg->msgid = MAVLINK_MSG_ID_STATE_CORRECTION;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 36);
}
/**
* @brief Encode a state_correction struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param state_correction C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_state_correction_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_state_correction_t* state_correction)
{
return mavlink_msg_state_correction_pack(system_id, component_id, msg, state_correction->xErr, state_correction->yErr, state_correction->zErr, state_correction->rollErr, state_correction->pitchErr, state_correction->yawErr, state_correction->vxErr, state_correction->vyErr, state_correction->vzErr);
}
/**
* @brief Send a state_correction message
* @param chan MAVLink channel to send the message
*
* @param xErr x position error
* @param yErr y position error
* @param zErr z position error
* @param rollErr roll error (radians)
* @param pitchErr pitch error (radians)
* @param yawErr yaw error (radians)
* @param vxErr x velocity
* @param vyErr y velocity
* @param vzErr z velocity
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_state_correction_send(mavlink_channel_t chan, float xErr, float yErr, float zErr, float rollErr, float pitchErr, float yawErr, float vxErr, float vyErr, float vzErr)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_float(buf, 0, xErr);
_mav_put_float(buf, 4, yErr);
_mav_put_float(buf, 8, zErr);
_mav_put_float(buf, 12, rollErr);
_mav_put_float(buf, 16, pitchErr);
_mav_put_float(buf, 20, yawErr);
_mav_put_float(buf, 24, vxErr);
_mav_put_float(buf, 28, vyErr);
_mav_put_float(buf, 32, vzErr);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_STATE_CORRECTION, buf, 36);
#else
mavlink_state_correction_t packet;
packet.xErr = xErr;
packet.yErr = yErr;
packet.zErr = zErr;
packet.rollErr = rollErr;
packet.pitchErr = pitchErr;
packet.yawErr = yawErr;
packet.vxErr = vxErr;
packet.vyErr = vyErr;
packet.vzErr = vzErr;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_STATE_CORRECTION, (const char *)&packet, 36);
#endif
}
#endif
// MESSAGE STATE_CORRECTION UNPACKING
/**
* @brief Get field xErr from state_correction message
*
* @return x position error
*/
static inline float mavlink_msg_state_correction_get_xErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field yErr from state_correction message
*
* @return y position error
*/
static inline float mavlink_msg_state_correction_get_yErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field zErr from state_correction message
*
* @return z position error
*/
static inline float mavlink_msg_state_correction_get_zErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field rollErr from state_correction message
*
* @return roll error (radians)
*/
static inline float mavlink_msg_state_correction_get_rollErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field pitchErr from state_correction message
*
* @return pitch error (radians)
*/
static inline float mavlink_msg_state_correction_get_pitchErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field yawErr from state_correction message
*
* @return yaw error (radians)
*/
static inline float mavlink_msg_state_correction_get_yawErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field vxErr from state_correction message
*
* @return x velocity
*/
static inline float mavlink_msg_state_correction_get_vxErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 24);
}
/**
* @brief Get field vyErr from state_correction message
*
* @return y velocity
*/
static inline float mavlink_msg_state_correction_get_vyErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Get field vzErr from state_correction message
*
* @return z velocity
*/
static inline float mavlink_msg_state_correction_get_vzErr(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 32);
}
/**
* @brief Decode a state_correction message into a struct
*
* @param msg The message to decode
* @param state_correction C-struct to decode the message contents into
*/
static inline void mavlink_msg_state_correction_decode(const mavlink_message_t* msg, mavlink_state_correction_t* state_correction)
{
#if MAVLINK_NEED_BYTE_SWAP
state_correction->xErr = mavlink_msg_state_correction_get_xErr(msg);
state_correction->yErr = mavlink_msg_state_correction_get_yErr(msg);
state_correction->zErr = mavlink_msg_state_correction_get_zErr(msg);
state_correction->rollErr = mavlink_msg_state_correction_get_rollErr(msg);
state_correction->pitchErr = mavlink_msg_state_correction_get_pitchErr(msg);
state_correction->yawErr = mavlink_msg_state_correction_get_yawErr(msg);
state_correction->vxErr = mavlink_msg_state_correction_get_vxErr(msg);
state_correction->vyErr = mavlink_msg_state_correction_get_vyErr(msg);
state_correction->vzErr = mavlink_msg_state_correction_get_vzErr(msg);
#else
memcpy(state_correction, _MAV_PAYLOAD(msg), 36);
#endif
}
@@ -1,160 +0,0 @@
// MESSAGE STATUSTEXT PACKING
#define MAVLINK_MSG_ID_STATUSTEXT 254
typedef struct __mavlink_statustext_t
{
uint8_t severity; ///< Severity of status, 0 = info message, 255 = critical fault
int8_t text[50]; ///< Status text message, without null termination character
} mavlink_statustext_t;
#define MAVLINK_MSG_ID_STATUSTEXT_LEN 51
#define MAVLINK_MSG_ID_254_LEN 51
#define MAVLINK_MSG_STATUSTEXT_FIELD_TEXT_LEN 50
#define MAVLINK_MESSAGE_INFO_STATUSTEXT { \
"STATUSTEXT", \
2, \
{ { "severity", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_statustext_t, severity) }, \
{ "text", NULL, MAVLINK_TYPE_INT8_T, 50, 1, offsetof(mavlink_statustext_t, text) }, \
} \
}
/**
* @brief Pack a statustext message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param severity Severity of status, 0 = info message, 255 = critical fault
* @param text Status text message, without null termination character
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_statustext_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t severity, const int8_t *text)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[51];
_mav_put_uint8_t(buf, 0, severity);
_mav_put_int8_t_array(buf, 1, text, 50);
memcpy(_MAV_PAYLOAD(msg), buf, 51);
#else
mavlink_statustext_t packet;
packet.severity = severity;
mav_array_memcpy(packet.text, text, sizeof(int8_t)*50);
memcpy(_MAV_PAYLOAD(msg), &packet, 51);
#endif
msg->msgid = MAVLINK_MSG_ID_STATUSTEXT;
return mavlink_finalize_message(msg, system_id, component_id, 51);
}
/**
* @brief Pack a statustext message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param severity Severity of status, 0 = info message, 255 = critical fault
* @param text Status text message, without null termination character
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_statustext_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t severity,const int8_t *text)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[51];
_mav_put_uint8_t(buf, 0, severity);
_mav_put_int8_t_array(buf, 1, text, 50);
memcpy(_MAV_PAYLOAD(msg), buf, 51);
#else
mavlink_statustext_t packet;
packet.severity = severity;
mav_array_memcpy(packet.text, text, sizeof(int8_t)*50);
memcpy(_MAV_PAYLOAD(msg), &packet, 51);
#endif
msg->msgid = MAVLINK_MSG_ID_STATUSTEXT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 51);
}
/**
* @brief Encode a statustext struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param statustext C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_statustext_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_statustext_t* statustext)
{
return mavlink_msg_statustext_pack(system_id, component_id, msg, statustext->severity, statustext->text);
}
/**
* @brief Send a statustext message
* @param chan MAVLink channel to send the message
*
* @param severity Severity of status, 0 = info message, 255 = critical fault
* @param text Status text message, without null termination character
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_statustext_send(mavlink_channel_t chan, uint8_t severity, const int8_t *text)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[51];
_mav_put_uint8_t(buf, 0, severity);
_mav_put_int8_t_array(buf, 1, text, 50);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_STATUSTEXT, buf, 51);
#else
mavlink_statustext_t packet;
packet.severity = severity;
mav_array_memcpy(packet.text, text, sizeof(int8_t)*50);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_STATUSTEXT, (const char *)&packet, 51);
#endif
}
#endif
// MESSAGE STATUSTEXT UNPACKING
/**
* @brief Get field severity from statustext message
*
* @return Severity of status, 0 = info message, 255 = critical fault
*/
static inline uint8_t mavlink_msg_statustext_get_severity(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field text from statustext message
*
* @return Status text message, without null termination character
*/
static inline uint16_t mavlink_msg_statustext_get_text(const mavlink_message_t* msg, int8_t *text)
{
return _MAV_RETURN_int8_t_array(msg, text, 50, 1);
}
/**
* @brief Decode a statustext message into a struct
*
* @param msg The message to decode
* @param statustext C-struct to decode the message contents into
*/
static inline void mavlink_msg_statustext_decode(const mavlink_message_t* msg, mavlink_statustext_t* statustext)
{
#if MAVLINK_NEED_BYTE_SWAP
statustext->severity = mavlink_msg_statustext_get_severity(msg);
mavlink_msg_statustext_get_text(msg, statustext->text);
#else
memcpy(statustext, _MAV_PAYLOAD(msg), 51);
#endif
}
@@ -1,276 +0,0 @@
// MESSAGE SYS_STATUS PACKING
#define MAVLINK_MSG_ID_SYS_STATUS 34
typedef struct __mavlink_sys_status_t
{
uint8_t mode; ///< System mode, see MAV_MODE ENUM in mavlink/include/mavlink_types.h
uint8_t nav_mode; ///< Navigation mode, see MAV_NAV_MODE ENUM
uint8_t status; ///< System status flag, see MAV_STATUS ENUM
uint16_t load; ///< Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
uint16_t vbat; ///< Battery voltage, in millivolts (1 = 1 millivolt)
uint16_t battery_remaining; ///< Remaining battery energy: (0%: 0, 100%: 1000)
uint16_t packet_drop; ///< Dropped packets (packets that were corrupted on reception on the MAV)
} mavlink_sys_status_t;
#define MAVLINK_MSG_ID_SYS_STATUS_LEN 11
#define MAVLINK_MSG_ID_34_LEN 11
#define MAVLINK_MESSAGE_INFO_SYS_STATUS { \
"SYS_STATUS", \
7, \
{ { "mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_sys_status_t, mode) }, \
{ "nav_mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_sys_status_t, nav_mode) }, \
{ "status", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_sys_status_t, status) }, \
{ "load", NULL, MAVLINK_TYPE_UINT16_T, 0, 3, offsetof(mavlink_sys_status_t, load) }, \
{ "vbat", NULL, MAVLINK_TYPE_UINT16_T, 0, 5, offsetof(mavlink_sys_status_t, vbat) }, \
{ "battery_remaining", NULL, MAVLINK_TYPE_UINT16_T, 0, 7, offsetof(mavlink_sys_status_t, battery_remaining) }, \
{ "packet_drop", NULL, MAVLINK_TYPE_UINT16_T, 0, 9, offsetof(mavlink_sys_status_t, packet_drop) }, \
} \
}
/**
* @brief Pack a sys_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param mode System mode, see MAV_MODE ENUM in mavlink/include/mavlink_types.h
* @param nav_mode Navigation mode, see MAV_NAV_MODE ENUM
* @param status System status flag, see MAV_STATUS ENUM
* @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
* @param vbat Battery voltage, in millivolts (1 = 1 millivolt)
* @param battery_remaining Remaining battery energy: (0%: 0, 100%: 1000)
* @param packet_drop Dropped packets (packets that were corrupted on reception on the MAV)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_sys_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t mode, uint8_t nav_mode, uint8_t status, uint16_t load, uint16_t vbat, uint16_t battery_remaining, uint16_t packet_drop)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[11];
_mav_put_uint8_t(buf, 0, mode);
_mav_put_uint8_t(buf, 1, nav_mode);
_mav_put_uint8_t(buf, 2, status);
_mav_put_uint16_t(buf, 3, load);
_mav_put_uint16_t(buf, 5, vbat);
_mav_put_uint16_t(buf, 7, battery_remaining);
_mav_put_uint16_t(buf, 9, packet_drop);
memcpy(_MAV_PAYLOAD(msg), buf, 11);
#else
mavlink_sys_status_t packet;
packet.mode = mode;
packet.nav_mode = nav_mode;
packet.status = status;
packet.load = load;
packet.vbat = vbat;
packet.battery_remaining = battery_remaining;
packet.packet_drop = packet_drop;
memcpy(_MAV_PAYLOAD(msg), &packet, 11);
#endif
msg->msgid = MAVLINK_MSG_ID_SYS_STATUS;
return mavlink_finalize_message(msg, system_id, component_id, 11);
}
/**
* @brief Pack a sys_status message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param mode System mode, see MAV_MODE ENUM in mavlink/include/mavlink_types.h
* @param nav_mode Navigation mode, see MAV_NAV_MODE ENUM
* @param status System status flag, see MAV_STATUS ENUM
* @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
* @param vbat Battery voltage, in millivolts (1 = 1 millivolt)
* @param battery_remaining Remaining battery energy: (0%: 0, 100%: 1000)
* @param packet_drop Dropped packets (packets that were corrupted on reception on the MAV)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_sys_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t mode,uint8_t nav_mode,uint8_t status,uint16_t load,uint16_t vbat,uint16_t battery_remaining,uint16_t packet_drop)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[11];
_mav_put_uint8_t(buf, 0, mode);
_mav_put_uint8_t(buf, 1, nav_mode);
_mav_put_uint8_t(buf, 2, status);
_mav_put_uint16_t(buf, 3, load);
_mav_put_uint16_t(buf, 5, vbat);
_mav_put_uint16_t(buf, 7, battery_remaining);
_mav_put_uint16_t(buf, 9, packet_drop);
memcpy(_MAV_PAYLOAD(msg), buf, 11);
#else
mavlink_sys_status_t packet;
packet.mode = mode;
packet.nav_mode = nav_mode;
packet.status = status;
packet.load = load;
packet.vbat = vbat;
packet.battery_remaining = battery_remaining;
packet.packet_drop = packet_drop;
memcpy(_MAV_PAYLOAD(msg), &packet, 11);
#endif
msg->msgid = MAVLINK_MSG_ID_SYS_STATUS;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 11);
}
/**
* @brief Encode a sys_status struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param sys_status C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_sys_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_sys_status_t* sys_status)
{
return mavlink_msg_sys_status_pack(system_id, component_id, msg, sys_status->mode, sys_status->nav_mode, sys_status->status, sys_status->load, sys_status->vbat, sys_status->battery_remaining, sys_status->packet_drop);
}
/**
* @brief Send a sys_status message
* @param chan MAVLink channel to send the message
*
* @param mode System mode, see MAV_MODE ENUM in mavlink/include/mavlink_types.h
* @param nav_mode Navigation mode, see MAV_NAV_MODE ENUM
* @param status System status flag, see MAV_STATUS ENUM
* @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
* @param vbat Battery voltage, in millivolts (1 = 1 millivolt)
* @param battery_remaining Remaining battery energy: (0%: 0, 100%: 1000)
* @param packet_drop Dropped packets (packets that were corrupted on reception on the MAV)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_sys_status_send(mavlink_channel_t chan, uint8_t mode, uint8_t nav_mode, uint8_t status, uint16_t load, uint16_t vbat, uint16_t battery_remaining, uint16_t packet_drop)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[11];
_mav_put_uint8_t(buf, 0, mode);
_mav_put_uint8_t(buf, 1, nav_mode);
_mav_put_uint8_t(buf, 2, status);
_mav_put_uint16_t(buf, 3, load);
_mav_put_uint16_t(buf, 5, vbat);
_mav_put_uint16_t(buf, 7, battery_remaining);
_mav_put_uint16_t(buf, 9, packet_drop);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYS_STATUS, buf, 11);
#else
mavlink_sys_status_t packet;
packet.mode = mode;
packet.nav_mode = nav_mode;
packet.status = status;
packet.load = load;
packet.vbat = vbat;
packet.battery_remaining = battery_remaining;
packet.packet_drop = packet_drop;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYS_STATUS, (const char *)&packet, 11);
#endif
}
#endif
// MESSAGE SYS_STATUS UNPACKING
/**
* @brief Get field mode from sys_status message
*
* @return System mode, see MAV_MODE ENUM in mavlink/include/mavlink_types.h
*/
static inline uint8_t mavlink_msg_sys_status_get_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field nav_mode from sys_status message
*
* @return Navigation mode, see MAV_NAV_MODE ENUM
*/
static inline uint8_t mavlink_msg_sys_status_get_nav_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field status from sys_status message
*
* @return System status flag, see MAV_STATUS ENUM
*/
static inline uint8_t mavlink_msg_sys_status_get_status(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field load from sys_status message
*
* @return Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
*/
static inline uint16_t mavlink_msg_sys_status_get_load(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 3);
}
/**
* @brief Get field vbat from sys_status message
*
* @return Battery voltage, in millivolts (1 = 1 millivolt)
*/
static inline uint16_t mavlink_msg_sys_status_get_vbat(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 5);
}
/**
* @brief Get field battery_remaining from sys_status message
*
* @return Remaining battery energy: (0%: 0, 100%: 1000)
*/
static inline uint16_t mavlink_msg_sys_status_get_battery_remaining(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 7);
}
/**
* @brief Get field packet_drop from sys_status message
*
* @return Dropped packets (packets that were corrupted on reception on the MAV)
*/
static inline uint16_t mavlink_msg_sys_status_get_packet_drop(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 9);
}
/**
* @brief Decode a sys_status message into a struct
*
* @param msg The message to decode
* @param sys_status C-struct to decode the message contents into
*/
static inline void mavlink_msg_sys_status_decode(const mavlink_message_t* msg, mavlink_sys_status_t* sys_status)
{
#if MAVLINK_NEED_BYTE_SWAP
sys_status->mode = mavlink_msg_sys_status_get_mode(msg);
sys_status->nav_mode = mavlink_msg_sys_status_get_nav_mode(msg);
sys_status->status = mavlink_msg_sys_status_get_status(msg);
sys_status->load = mavlink_msg_sys_status_get_load(msg);
sys_status->vbat = mavlink_msg_sys_status_get_vbat(msg);
sys_status->battery_remaining = mavlink_msg_sys_status_get_battery_remaining(msg);
sys_status->packet_drop = mavlink_msg_sys_status_get_packet_drop(msg);
#else
memcpy(sys_status, _MAV_PAYLOAD(msg), 11);
#endif
}
@@ -1,144 +0,0 @@
// MESSAGE SYSTEM_TIME PACKING
#define MAVLINK_MSG_ID_SYSTEM_TIME 2
typedef struct __mavlink_system_time_t
{
uint64_t time_usec; ///< Timestamp of the master clock in microseconds since UNIX epoch.
} mavlink_system_time_t;
#define MAVLINK_MSG_ID_SYSTEM_TIME_LEN 8
#define MAVLINK_MSG_ID_2_LEN 8
#define MAVLINK_MESSAGE_INFO_SYSTEM_TIME { \
"SYSTEM_TIME", \
1, \
{ { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_system_time_t, time_usec) }, \
} \
}
/**
* @brief Pack a system_time message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time_usec Timestamp of the master clock in microseconds since UNIX epoch.
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_system_time_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint64_t time_usec)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint64_t(buf, 0, time_usec);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_system_time_t packet;
packet.time_usec = time_usec;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_SYSTEM_TIME;
return mavlink_finalize_message(msg, system_id, component_id, 8);
}
/**
* @brief Pack a system_time message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time_usec Timestamp of the master clock in microseconds since UNIX epoch.
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_system_time_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint64_t time_usec)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint64_t(buf, 0, time_usec);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_system_time_t packet;
packet.time_usec = time_usec;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_SYSTEM_TIME;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 8);
}
/**
* @brief Encode a system_time struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param system_time C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_system_time_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_system_time_t* system_time)
{
return mavlink_msg_system_time_pack(system_id, component_id, msg, system_time->time_usec);
}
/**
* @brief Send a system_time message
* @param chan MAVLink channel to send the message
*
* @param time_usec Timestamp of the master clock in microseconds since UNIX epoch.
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_system_time_send(mavlink_channel_t chan, uint64_t time_usec)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint64_t(buf, 0, time_usec);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYSTEM_TIME, buf, 8);
#else
mavlink_system_time_t packet;
packet.time_usec = time_usec;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYSTEM_TIME, (const char *)&packet, 8);
#endif
}
#endif
// MESSAGE SYSTEM_TIME UNPACKING
/**
* @brief Get field time_usec from system_time message
*
* @return Timestamp of the master clock in microseconds since UNIX epoch.
*/
static inline uint64_t mavlink_msg_system_time_get_time_usec(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint64_t(msg, 0);
}
/**
* @brief Decode a system_time message into a struct
*
* @param msg The message to decode
* @param system_time C-struct to decode the message contents into
*/
static inline void mavlink_msg_system_time_decode(const mavlink_message_t* msg, mavlink_system_time_t* system_time)
{
#if MAVLINK_NEED_BYTE_SWAP
system_time->time_usec = mavlink_msg_system_time_get_time_usec(msg);
#else
memcpy(system_time, _MAV_PAYLOAD(msg), 8);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE SYSTEM_TIME_UTC PACKING
#define MAVLINK_MSG_ID_SYSTEM_TIME_UTC 4
typedef struct __mavlink_system_time_utc_t
{
uint32_t utc_date; ///< GPS UTC date ddmmyy
uint32_t utc_time; ///< GPS UTC time hhmmss
} mavlink_system_time_utc_t;
#define MAVLINK_MSG_ID_SYSTEM_TIME_UTC_LEN 8
#define MAVLINK_MSG_ID_4_LEN 8
#define MAVLINK_MESSAGE_INFO_SYSTEM_TIME_UTC { \
"SYSTEM_TIME_UTC", \
2, \
{ { "utc_date", NULL, MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_system_time_utc_t, utc_date) }, \
{ "utc_time", NULL, MAVLINK_TYPE_UINT32_T, 0, 4, offsetof(mavlink_system_time_utc_t, utc_time) }, \
} \
}
/**
* @brief Pack a system_time_utc message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param utc_date GPS UTC date ddmmyy
* @param utc_time GPS UTC time hhmmss
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_system_time_utc_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint32_t utc_date, uint32_t utc_time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint32_t(buf, 0, utc_date);
_mav_put_uint32_t(buf, 4, utc_time);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_system_time_utc_t packet;
packet.utc_date = utc_date;
packet.utc_time = utc_time;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_SYSTEM_TIME_UTC;
return mavlink_finalize_message(msg, system_id, component_id, 8);
}
/**
* @brief Pack a system_time_utc message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param utc_date GPS UTC date ddmmyy
* @param utc_time GPS UTC time hhmmss
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_system_time_utc_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint32_t utc_date,uint32_t utc_time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint32_t(buf, 0, utc_date);
_mav_put_uint32_t(buf, 4, utc_time);
memcpy(_MAV_PAYLOAD(msg), buf, 8);
#else
mavlink_system_time_utc_t packet;
packet.utc_date = utc_date;
packet.utc_time = utc_time;
memcpy(_MAV_PAYLOAD(msg), &packet, 8);
#endif
msg->msgid = MAVLINK_MSG_ID_SYSTEM_TIME_UTC;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 8);
}
/**
* @brief Encode a system_time_utc struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param system_time_utc C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_system_time_utc_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_system_time_utc_t* system_time_utc)
{
return mavlink_msg_system_time_utc_pack(system_id, component_id, msg, system_time_utc->utc_date, system_time_utc->utc_time);
}
/**
* @brief Send a system_time_utc message
* @param chan MAVLink channel to send the message
*
* @param utc_date GPS UTC date ddmmyy
* @param utc_time GPS UTC time hhmmss
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_system_time_utc_send(mavlink_channel_t chan, uint32_t utc_date, uint32_t utc_time)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[8];
_mav_put_uint32_t(buf, 0, utc_date);
_mav_put_uint32_t(buf, 4, utc_time);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYSTEM_TIME_UTC, buf, 8);
#else
mavlink_system_time_utc_t packet;
packet.utc_date = utc_date;
packet.utc_time = utc_time;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYSTEM_TIME_UTC, (const char *)&packet, 8);
#endif
}
#endif
// MESSAGE SYSTEM_TIME_UTC UNPACKING
/**
* @brief Get field utc_date from system_time_utc message
*
* @return GPS UTC date ddmmyy
*/
static inline uint32_t mavlink_msg_system_time_utc_get_utc_date(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 0);
}
/**
* @brief Get field utc_time from system_time_utc message
*
* @return GPS UTC time hhmmss
*/
static inline uint32_t mavlink_msg_system_time_utc_get_utc_time(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint32_t(msg, 4);
}
/**
* @brief Decode a system_time_utc message into a struct
*
* @param msg The message to decode
* @param system_time_utc C-struct to decode the message contents into
*/
static inline void mavlink_msg_system_time_utc_decode(const mavlink_message_t* msg, mavlink_system_time_utc_t* system_time_utc)
{
#if MAVLINK_NEED_BYTE_SWAP
system_time_utc->utc_date = mavlink_msg_system_time_utc_get_utc_date(msg);
system_time_utc->utc_time = mavlink_msg_system_time_utc_get_utc_time(msg);
#else
memcpy(system_time_utc, _MAV_PAYLOAD(msg), 8);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE VFR_HUD PACKING
#define MAVLINK_MSG_ID_VFR_HUD 74
typedef struct __mavlink_vfr_hud_t
{
float airspeed; ///< Current airspeed in m/s
float groundspeed; ///< Current ground speed in m/s
int16_t heading; ///< Current heading in degrees, in compass units (0..360, 0=north)
uint16_t throttle; ///< Current throttle setting in integer percent, 0 to 100
float alt; ///< Current altitude (MSL), in meters
float climb; ///< Current climb rate in meters/second
} mavlink_vfr_hud_t;
#define MAVLINK_MSG_ID_VFR_HUD_LEN 20
#define MAVLINK_MSG_ID_74_LEN 20
#define MAVLINK_MESSAGE_INFO_VFR_HUD { \
"VFR_HUD", \
6, \
{ { "airspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_vfr_hud_t, airspeed) }, \
{ "groundspeed", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_vfr_hud_t, groundspeed) }, \
{ "heading", NULL, MAVLINK_TYPE_INT16_T, 0, 8, offsetof(mavlink_vfr_hud_t, heading) }, \
{ "throttle", NULL, MAVLINK_TYPE_UINT16_T, 0, 10, offsetof(mavlink_vfr_hud_t, throttle) }, \
{ "alt", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_vfr_hud_t, alt) }, \
{ "climb", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_vfr_hud_t, climb) }, \
} \
}
/**
* @brief Pack a vfr_hud message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param airspeed Current airspeed in m/s
* @param groundspeed Current ground speed in m/s
* @param heading Current heading in degrees, in compass units (0..360, 0=north)
* @param throttle Current throttle setting in integer percent, 0 to 100
* @param alt Current altitude (MSL), in meters
* @param climb Current climb rate in meters/second
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_vfr_hud_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
float airspeed, float groundspeed, int16_t heading, uint16_t throttle, float alt, float climb)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[20];
_mav_put_float(buf, 0, airspeed);
_mav_put_float(buf, 4, groundspeed);
_mav_put_int16_t(buf, 8, heading);
_mav_put_uint16_t(buf, 10, throttle);
_mav_put_float(buf, 12, alt);
_mav_put_float(buf, 16, climb);
memcpy(_MAV_PAYLOAD(msg), buf, 20);
#else
mavlink_vfr_hud_t packet;
packet.airspeed = airspeed;
packet.groundspeed = groundspeed;
packet.heading = heading;
packet.throttle = throttle;
packet.alt = alt;
packet.climb = climb;
memcpy(_MAV_PAYLOAD(msg), &packet, 20);
#endif
msg->msgid = MAVLINK_MSG_ID_VFR_HUD;
return mavlink_finalize_message(msg, system_id, component_id, 20);
}
/**
* @brief Pack a vfr_hud message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param airspeed Current airspeed in m/s
* @param groundspeed Current ground speed in m/s
* @param heading Current heading in degrees, in compass units (0..360, 0=north)
* @param throttle Current throttle setting in integer percent, 0 to 100
* @param alt Current altitude (MSL), in meters
* @param climb Current climb rate in meters/second
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_vfr_hud_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
float airspeed,float groundspeed,int16_t heading,uint16_t throttle,float alt,float climb)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[20];
_mav_put_float(buf, 0, airspeed);
_mav_put_float(buf, 4, groundspeed);
_mav_put_int16_t(buf, 8, heading);
_mav_put_uint16_t(buf, 10, throttle);
_mav_put_float(buf, 12, alt);
_mav_put_float(buf, 16, climb);
memcpy(_MAV_PAYLOAD(msg), buf, 20);
#else
mavlink_vfr_hud_t packet;
packet.airspeed = airspeed;
packet.groundspeed = groundspeed;
packet.heading = heading;
packet.throttle = throttle;
packet.alt = alt;
packet.climb = climb;
memcpy(_MAV_PAYLOAD(msg), &packet, 20);
#endif
msg->msgid = MAVLINK_MSG_ID_VFR_HUD;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 20);
}
/**
* @brief Encode a vfr_hud struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param vfr_hud C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_vfr_hud_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_vfr_hud_t* vfr_hud)
{
return mavlink_msg_vfr_hud_pack(system_id, component_id, msg, vfr_hud->airspeed, vfr_hud->groundspeed, vfr_hud->heading, vfr_hud->throttle, vfr_hud->alt, vfr_hud->climb);
}
/**
* @brief Send a vfr_hud message
* @param chan MAVLink channel to send the message
*
* @param airspeed Current airspeed in m/s
* @param groundspeed Current ground speed in m/s
* @param heading Current heading in degrees, in compass units (0..360, 0=north)
* @param throttle Current throttle setting in integer percent, 0 to 100
* @param alt Current altitude (MSL), in meters
* @param climb Current climb rate in meters/second
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_vfr_hud_send(mavlink_channel_t chan, float airspeed, float groundspeed, int16_t heading, uint16_t throttle, float alt, float climb)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[20];
_mav_put_float(buf, 0, airspeed);
_mav_put_float(buf, 4, groundspeed);
_mav_put_int16_t(buf, 8, heading);
_mav_put_uint16_t(buf, 10, throttle);
_mav_put_float(buf, 12, alt);
_mav_put_float(buf, 16, climb);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VFR_HUD, buf, 20);
#else
mavlink_vfr_hud_t packet;
packet.airspeed = airspeed;
packet.groundspeed = groundspeed;
packet.heading = heading;
packet.throttle = throttle;
packet.alt = alt;
packet.climb = climb;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VFR_HUD, (const char *)&packet, 20);
#endif
}
#endif
// MESSAGE VFR_HUD UNPACKING
/**
* @brief Get field airspeed from vfr_hud message
*
* @return Current airspeed in m/s
*/
static inline float mavlink_msg_vfr_hud_get_airspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field groundspeed from vfr_hud message
*
* @return Current ground speed in m/s
*/
static inline float mavlink_msg_vfr_hud_get_groundspeed(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field heading from vfr_hud message
*
* @return Current heading in degrees, in compass units (0..360, 0=north)
*/
static inline int16_t mavlink_msg_vfr_hud_get_heading(const mavlink_message_t* msg)
{
return _MAV_RETURN_int16_t(msg, 8);
}
/**
* @brief Get field throttle from vfr_hud message
*
* @return Current throttle setting in integer percent, 0 to 100
*/
static inline uint16_t mavlink_msg_vfr_hud_get_throttle(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 10);
}
/**
* @brief Get field alt from vfr_hud message
*
* @return Current altitude (MSL), in meters
*/
static inline float mavlink_msg_vfr_hud_get_alt(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field climb from vfr_hud message
*
* @return Current climb rate in meters/second
*/
static inline float mavlink_msg_vfr_hud_get_climb(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Decode a vfr_hud message into a struct
*
* @param msg The message to decode
* @param vfr_hud C-struct to decode the message contents into
*/
static inline void mavlink_msg_vfr_hud_decode(const mavlink_message_t* msg, mavlink_vfr_hud_t* vfr_hud)
{
#if MAVLINK_NEED_BYTE_SWAP
vfr_hud->airspeed = mavlink_msg_vfr_hud_get_airspeed(msg);
vfr_hud->groundspeed = mavlink_msg_vfr_hud_get_groundspeed(msg);
vfr_hud->heading = mavlink_msg_vfr_hud_get_heading(msg);
vfr_hud->throttle = mavlink_msg_vfr_hud_get_throttle(msg);
vfr_hud->alt = mavlink_msg_vfr_hud_get_alt(msg);
vfr_hud->climb = mavlink_msg_vfr_hud_get_climb(msg);
#else
memcpy(vfr_hud, _MAV_PAYLOAD(msg), 20);
#endif
}
@@ -1,430 +0,0 @@
// MESSAGE WAYPOINT PACKING
#define MAVLINK_MSG_ID_WAYPOINT 39
typedef struct __mavlink_waypoint_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint16_t seq; ///< Sequence
uint8_t frame; ///< The coordinate system of the waypoint. see MAV_FRAME in mavlink_types.h
uint8_t command; ///< The scheduled action for the waypoint. see MAV_COMMAND in common.xml MAVLink specs
uint8_t current; ///< false:0, true:1
uint8_t autocontinue; ///< autocontinue to next wp
float param1; ///< PARAM1 / For NAV command waypoints: Radius in which the waypoint is accepted as reached, in meters
float param2; ///< PARAM2 / For NAV command waypoints: Time that the MAV should stay inside the PARAM1 radius before advancing, in milliseconds
float param3; ///< PARAM3 / For LOITER command waypoints: Orbit to circle around the waypoint, in meters. If positive the orbit direction should be clockwise, if negative the orbit direction should be counter-clockwise.
float param4; ///< PARAM4 / For NAV and LOITER command waypoints: Yaw orientation in degrees, [0..360] 0 = NORTH
float x; ///< PARAM5 / local: x position, global: latitude
float y; ///< PARAM6 / y position: global: longitude
float z; ///< PARAM7 / z position: global: altitude
} mavlink_waypoint_t;
#define MAVLINK_MSG_ID_WAYPOINT_LEN 36
#define MAVLINK_MSG_ID_39_LEN 36
#define MAVLINK_MESSAGE_INFO_WAYPOINT { \
"WAYPOINT", \
14, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_t, target_component) }, \
{ "seq", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_waypoint_t, seq) }, \
{ "frame", NULL, MAVLINK_TYPE_UINT8_T, 0, 4, offsetof(mavlink_waypoint_t, frame) }, \
{ "command", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_waypoint_t, command) }, \
{ "current", NULL, MAVLINK_TYPE_UINT8_T, 0, 6, offsetof(mavlink_waypoint_t, current) }, \
{ "autocontinue", NULL, MAVLINK_TYPE_UINT8_T, 0, 7, offsetof(mavlink_waypoint_t, autocontinue) }, \
{ "param1", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_waypoint_t, param1) }, \
{ "param2", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_waypoint_t, param2) }, \
{ "param3", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_waypoint_t, param3) }, \
{ "param4", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_waypoint_t, param4) }, \
{ "x", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_waypoint_t, x) }, \
{ "y", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_waypoint_t, y) }, \
{ "z", NULL, MAVLINK_TYPE_FLOAT, 0, 32, offsetof(mavlink_waypoint_t, z) }, \
} \
}
/**
* @brief Pack a waypoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @param frame The coordinate system of the waypoint. see MAV_FRAME in mavlink_types.h
* @param command The scheduled action for the waypoint. see MAV_COMMAND in common.xml MAVLink specs
* @param current false:0, true:1
* @param autocontinue autocontinue to next wp
* @param param1 PARAM1 / For NAV command waypoints: Radius in which the waypoint is accepted as reached, in meters
* @param param2 PARAM2 / For NAV command waypoints: Time that the MAV should stay inside the PARAM1 radius before advancing, in milliseconds
* @param param3 PARAM3 / For LOITER command waypoints: Orbit to circle around the waypoint, in meters. If positive the orbit direction should be clockwise, if negative the orbit direction should be counter-clockwise.
* @param param4 PARAM4 / For NAV and LOITER command waypoints: Yaw orientation in degrees, [0..360] 0 = NORTH
* @param x PARAM5 / local: x position, global: latitude
* @param y PARAM6 / y position: global: longitude
* @param z PARAM7 / z position: global: altitude
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint16_t seq, uint8_t frame, uint8_t command, uint8_t current, uint8_t autocontinue, float param1, float param2, float param3, float param4, float x, float y, float z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
_mav_put_uint8_t(buf, 4, frame);
_mav_put_uint8_t(buf, 5, command);
_mav_put_uint8_t(buf, 6, current);
_mav_put_uint8_t(buf, 7, autocontinue);
_mav_put_float(buf, 8, param1);
_mav_put_float(buf, 12, param2);
_mav_put_float(buf, 16, param3);
_mav_put_float(buf, 20, param4);
_mav_put_float(buf, 24, x);
_mav_put_float(buf, 28, y);
_mav_put_float(buf, 32, z);
memcpy(_MAV_PAYLOAD(msg), buf, 36);
#else
mavlink_waypoint_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
packet.frame = frame;
packet.command = command;
packet.current = current;
packet.autocontinue = autocontinue;
packet.param1 = param1;
packet.param2 = param2;
packet.param3 = param3;
packet.param4 = param4;
packet.x = x;
packet.y = y;
packet.z = z;
memcpy(_MAV_PAYLOAD(msg), &packet, 36);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT;
return mavlink_finalize_message(msg, system_id, component_id, 36);
}
/**
* @brief Pack a waypoint message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @param frame The coordinate system of the waypoint. see MAV_FRAME in mavlink_types.h
* @param command The scheduled action for the waypoint. see MAV_COMMAND in common.xml MAVLink specs
* @param current false:0, true:1
* @param autocontinue autocontinue to next wp
* @param param1 PARAM1 / For NAV command waypoints: Radius in which the waypoint is accepted as reached, in meters
* @param param2 PARAM2 / For NAV command waypoints: Time that the MAV should stay inside the PARAM1 radius before advancing, in milliseconds
* @param param3 PARAM3 / For LOITER command waypoints: Orbit to circle around the waypoint, in meters. If positive the orbit direction should be clockwise, if negative the orbit direction should be counter-clockwise.
* @param param4 PARAM4 / For NAV and LOITER command waypoints: Yaw orientation in degrees, [0..360] 0 = NORTH
* @param x PARAM5 / local: x position, global: latitude
* @param y PARAM6 / y position: global: longitude
* @param z PARAM7 / z position: global: altitude
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint16_t seq,uint8_t frame,uint8_t command,uint8_t current,uint8_t autocontinue,float param1,float param2,float param3,float param4,float x,float y,float z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
_mav_put_uint8_t(buf, 4, frame);
_mav_put_uint8_t(buf, 5, command);
_mav_put_uint8_t(buf, 6, current);
_mav_put_uint8_t(buf, 7, autocontinue);
_mav_put_float(buf, 8, param1);
_mav_put_float(buf, 12, param2);
_mav_put_float(buf, 16, param3);
_mav_put_float(buf, 20, param4);
_mav_put_float(buf, 24, x);
_mav_put_float(buf, 28, y);
_mav_put_float(buf, 32, z);
memcpy(_MAV_PAYLOAD(msg), buf, 36);
#else
mavlink_waypoint_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
packet.frame = frame;
packet.command = command;
packet.current = current;
packet.autocontinue = autocontinue;
packet.param1 = param1;
packet.param2 = param2;
packet.param3 = param3;
packet.param4 = param4;
packet.x = x;
packet.y = y;
packet.z = z;
memcpy(_MAV_PAYLOAD(msg), &packet, 36);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 36);
}
/**
* @brief Encode a waypoint struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_t* waypoint)
{
return mavlink_msg_waypoint_pack(system_id, component_id, msg, waypoint->target_system, waypoint->target_component, waypoint->seq, waypoint->frame, waypoint->command, waypoint->current, waypoint->autocontinue, waypoint->param1, waypoint->param2, waypoint->param3, waypoint->param4, waypoint->x, waypoint->y, waypoint->z);
}
/**
* @brief Send a waypoint message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @param frame The coordinate system of the waypoint. see MAV_FRAME in mavlink_types.h
* @param command The scheduled action for the waypoint. see MAV_COMMAND in common.xml MAVLink specs
* @param current false:0, true:1
* @param autocontinue autocontinue to next wp
* @param param1 PARAM1 / For NAV command waypoints: Radius in which the waypoint is accepted as reached, in meters
* @param param2 PARAM2 / For NAV command waypoints: Time that the MAV should stay inside the PARAM1 radius before advancing, in milliseconds
* @param param3 PARAM3 / For LOITER command waypoints: Orbit to circle around the waypoint, in meters. If positive the orbit direction should be clockwise, if negative the orbit direction should be counter-clockwise.
* @param param4 PARAM4 / For NAV and LOITER command waypoints: Yaw orientation in degrees, [0..360] 0 = NORTH
* @param x PARAM5 / local: x position, global: latitude
* @param y PARAM6 / y position: global: longitude
* @param z PARAM7 / z position: global: altitude
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t seq, uint8_t frame, uint8_t command, uint8_t current, uint8_t autocontinue, float param1, float param2, float param3, float param4, float x, float y, float z)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[36];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
_mav_put_uint8_t(buf, 4, frame);
_mav_put_uint8_t(buf, 5, command);
_mav_put_uint8_t(buf, 6, current);
_mav_put_uint8_t(buf, 7, autocontinue);
_mav_put_float(buf, 8, param1);
_mav_put_float(buf, 12, param2);
_mav_put_float(buf, 16, param3);
_mav_put_float(buf, 20, param4);
_mav_put_float(buf, 24, x);
_mav_put_float(buf, 28, y);
_mav_put_float(buf, 32, z);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT, buf, 36);
#else
mavlink_waypoint_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
packet.frame = frame;
packet.command = command;
packet.current = current;
packet.autocontinue = autocontinue;
packet.param1 = param1;
packet.param2 = param2;
packet.param3 = param3;
packet.param4 = param4;
packet.x = x;
packet.y = y;
packet.z = z;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT, (const char *)&packet, 36);
#endif
}
#endif
// MESSAGE WAYPOINT UNPACKING
/**
* @brief Get field target_system from waypoint message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field seq from waypoint message
*
* @return Sequence
*/
static inline uint16_t mavlink_msg_waypoint_get_seq(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Get field frame from waypoint message
*
* @return The coordinate system of the waypoint. see MAV_FRAME in mavlink_types.h
*/
static inline uint8_t mavlink_msg_waypoint_get_frame(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 4);
}
/**
* @brief Get field command from waypoint message
*
* @return The scheduled action for the waypoint. see MAV_COMMAND in common.xml MAVLink specs
*/
static inline uint8_t mavlink_msg_waypoint_get_command(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Get field current from waypoint message
*
* @return false:0, true:1
*/
static inline uint8_t mavlink_msg_waypoint_get_current(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 6);
}
/**
* @brief Get field autocontinue from waypoint message
*
* @return autocontinue to next wp
*/
static inline uint8_t mavlink_msg_waypoint_get_autocontinue(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 7);
}
/**
* @brief Get field param1 from waypoint message
*
* @return PARAM1 / For NAV command waypoints: Radius in which the waypoint is accepted as reached, in meters
*/
static inline float mavlink_msg_waypoint_get_param1(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field param2 from waypoint message
*
* @return PARAM2 / For NAV command waypoints: Time that the MAV should stay inside the PARAM1 radius before advancing, in milliseconds
*/
static inline float mavlink_msg_waypoint_get_param2(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field param3 from waypoint message
*
* @return PARAM3 / For LOITER command waypoints: Orbit to circle around the waypoint, in meters. If positive the orbit direction should be clockwise, if negative the orbit direction should be counter-clockwise.
*/
static inline float mavlink_msg_waypoint_get_param3(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 16);
}
/**
* @brief Get field param4 from waypoint message
*
* @return PARAM4 / For NAV and LOITER command waypoints: Yaw orientation in degrees, [0..360] 0 = NORTH
*/
static inline float mavlink_msg_waypoint_get_param4(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 20);
}
/**
* @brief Get field x from waypoint message
*
* @return PARAM5 / local: x position, global: latitude
*/
static inline float mavlink_msg_waypoint_get_x(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 24);
}
/**
* @brief Get field y from waypoint message
*
* @return PARAM6 / y position: global: longitude
*/
static inline float mavlink_msg_waypoint_get_y(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 28);
}
/**
* @brief Get field z from waypoint message
*
* @return PARAM7 / z position: global: altitude
*/
static inline float mavlink_msg_waypoint_get_z(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 32);
}
/**
* @brief Decode a waypoint message into a struct
*
* @param msg The message to decode
* @param waypoint C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_decode(const mavlink_message_t* msg, mavlink_waypoint_t* waypoint)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint->target_system = mavlink_msg_waypoint_get_target_system(msg);
waypoint->target_component = mavlink_msg_waypoint_get_target_component(msg);
waypoint->seq = mavlink_msg_waypoint_get_seq(msg);
waypoint->frame = mavlink_msg_waypoint_get_frame(msg);
waypoint->command = mavlink_msg_waypoint_get_command(msg);
waypoint->current = mavlink_msg_waypoint_get_current(msg);
waypoint->autocontinue = mavlink_msg_waypoint_get_autocontinue(msg);
waypoint->param1 = mavlink_msg_waypoint_get_param1(msg);
waypoint->param2 = mavlink_msg_waypoint_get_param2(msg);
waypoint->param3 = mavlink_msg_waypoint_get_param3(msg);
waypoint->param4 = mavlink_msg_waypoint_get_param4(msg);
waypoint->x = mavlink_msg_waypoint_get_x(msg);
waypoint->y = mavlink_msg_waypoint_get_y(msg);
waypoint->z = mavlink_msg_waypoint_get_z(msg);
#else
memcpy(waypoint, _MAV_PAYLOAD(msg), 36);
#endif
}
@@ -1,188 +0,0 @@
// MESSAGE WAYPOINT_ACK PACKING
#define MAVLINK_MSG_ID_WAYPOINT_ACK 47
typedef struct __mavlink_waypoint_ack_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t type; ///< 0: OK, 1: Error
} mavlink_waypoint_ack_t;
#define MAVLINK_MSG_ID_WAYPOINT_ACK_LEN 3
#define MAVLINK_MSG_ID_47_LEN 3
#define MAVLINK_MESSAGE_INFO_WAYPOINT_ACK { \
"WAYPOINT_ACK", \
3, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_ack_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_ack_t, target_component) }, \
{ "type", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_waypoint_ack_t, type) }, \
} \
}
/**
* @brief Pack a waypoint_ack message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param type 0: OK, 1: Error
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_ack_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t type)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, type);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_waypoint_ack_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.type = type;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_ACK;
return mavlink_finalize_message(msg, system_id, component_id, 3);
}
/**
* @brief Pack a waypoint_ack message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param type 0: OK, 1: Error
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_ack_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t type)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, type);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_waypoint_ack_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.type = type;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_ACK;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 3);
}
/**
* @brief Encode a waypoint_ack struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_ack C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_ack_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_ack_t* waypoint_ack)
{
return mavlink_msg_waypoint_ack_pack(system_id, component_id, msg, waypoint_ack->target_system, waypoint_ack->target_component, waypoint_ack->type);
}
/**
* @brief Send a waypoint_ack message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param type 0: OK, 1: Error
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_ack_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t type)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, type);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_ACK, buf, 3);
#else
mavlink_waypoint_ack_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.type = type;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_ACK, (const char *)&packet, 3);
#endif
}
#endif
// MESSAGE WAYPOINT_ACK UNPACKING
/**
* @brief Get field target_system from waypoint_ack message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_ack_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint_ack message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_ack_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field type from waypoint_ack message
*
* @return 0: OK, 1: Error
*/
static inline uint8_t mavlink_msg_waypoint_ack_get_type(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Decode a waypoint_ack message into a struct
*
* @param msg The message to decode
* @param waypoint_ack C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_ack_decode(const mavlink_message_t* msg, mavlink_waypoint_ack_t* waypoint_ack)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_ack->target_system = mavlink_msg_waypoint_ack_get_target_system(msg);
waypoint_ack->target_component = mavlink_msg_waypoint_ack_get_target_component(msg);
waypoint_ack->type = mavlink_msg_waypoint_ack_get_type(msg);
#else
memcpy(waypoint_ack, _MAV_PAYLOAD(msg), 3);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE WAYPOINT_CLEAR_ALL PACKING
#define MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL 45
typedef struct __mavlink_waypoint_clear_all_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
} mavlink_waypoint_clear_all_t;
#define MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL_LEN 2
#define MAVLINK_MSG_ID_45_LEN 2
#define MAVLINK_MESSAGE_INFO_WAYPOINT_CLEAR_ALL { \
"WAYPOINT_CLEAR_ALL", \
2, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_clear_all_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_clear_all_t, target_component) }, \
} \
}
/**
* @brief Pack a waypoint_clear_all message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_clear_all_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_clear_all_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a waypoint_clear_all message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_clear_all_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_clear_all_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a waypoint_clear_all struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_clear_all C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_clear_all_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_clear_all_t* waypoint_clear_all)
{
return mavlink_msg_waypoint_clear_all_pack(system_id, component_id, msg, waypoint_clear_all->target_system, waypoint_clear_all->target_component);
}
/**
* @brief Send a waypoint_clear_all message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_clear_all_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL, buf, 2);
#else
mavlink_waypoint_clear_all_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_CLEAR_ALL, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE WAYPOINT_CLEAR_ALL UNPACKING
/**
* @brief Get field target_system from waypoint_clear_all message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_clear_all_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint_clear_all message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_clear_all_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Decode a waypoint_clear_all message into a struct
*
* @param msg The message to decode
* @param waypoint_clear_all C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_clear_all_decode(const mavlink_message_t* msg, mavlink_waypoint_clear_all_t* waypoint_clear_all)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_clear_all->target_system = mavlink_msg_waypoint_clear_all_get_target_system(msg);
waypoint_clear_all->target_component = mavlink_msg_waypoint_clear_all_get_target_component(msg);
#else
memcpy(waypoint_clear_all, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,188 +0,0 @@
// MESSAGE WAYPOINT_COUNT PACKING
#define MAVLINK_MSG_ID_WAYPOINT_COUNT 44
typedef struct __mavlink_waypoint_count_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint16_t count; ///< Number of Waypoints in the Sequence
} mavlink_waypoint_count_t;
#define MAVLINK_MSG_ID_WAYPOINT_COUNT_LEN 4
#define MAVLINK_MSG_ID_44_LEN 4
#define MAVLINK_MESSAGE_INFO_WAYPOINT_COUNT { \
"WAYPOINT_COUNT", \
3, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_count_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_count_t, target_component) }, \
{ "count", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_waypoint_count_t, count) }, \
} \
}
/**
* @brief Pack a waypoint_count message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param count Number of Waypoints in the Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_count_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint16_t count)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, count);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_waypoint_count_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.count = count;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_COUNT;
return mavlink_finalize_message(msg, system_id, component_id, 4);
}
/**
* @brief Pack a waypoint_count message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param count Number of Waypoints in the Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_count_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint16_t count)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, count);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_waypoint_count_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.count = count;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_COUNT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 4);
}
/**
* @brief Encode a waypoint_count struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_count C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_count_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_count_t* waypoint_count)
{
return mavlink_msg_waypoint_count_pack(system_id, component_id, msg, waypoint_count->target_system, waypoint_count->target_component, waypoint_count->count);
}
/**
* @brief Send a waypoint_count message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param count Number of Waypoints in the Sequence
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_count_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t count)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, count);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_COUNT, buf, 4);
#else
mavlink_waypoint_count_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.count = count;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_COUNT, (const char *)&packet, 4);
#endif
}
#endif
// MESSAGE WAYPOINT_COUNT UNPACKING
/**
* @brief Get field target_system from waypoint_count message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_count_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint_count message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_count_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field count from waypoint_count message
*
* @return Number of Waypoints in the Sequence
*/
static inline uint16_t mavlink_msg_waypoint_count_get_count(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Decode a waypoint_count message into a struct
*
* @param msg The message to decode
* @param waypoint_count C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_count_decode(const mavlink_message_t* msg, mavlink_waypoint_count_t* waypoint_count)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_count->target_system = mavlink_msg_waypoint_count_get_target_system(msg);
waypoint_count->target_component = mavlink_msg_waypoint_count_get_target_component(msg);
waypoint_count->count = mavlink_msg_waypoint_count_get_count(msg);
#else
memcpy(waypoint_count, _MAV_PAYLOAD(msg), 4);
#endif
}
@@ -1,144 +0,0 @@
// MESSAGE WAYPOINT_CURRENT PACKING
#define MAVLINK_MSG_ID_WAYPOINT_CURRENT 42
typedef struct __mavlink_waypoint_current_t
{
uint16_t seq; ///< Sequence
} mavlink_waypoint_current_t;
#define MAVLINK_MSG_ID_WAYPOINT_CURRENT_LEN 2
#define MAVLINK_MSG_ID_42_LEN 2
#define MAVLINK_MESSAGE_INFO_WAYPOINT_CURRENT { \
"WAYPOINT_CURRENT", \
1, \
{ { "seq", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_waypoint_current_t, seq) }, \
} \
}
/**
* @brief Pack a waypoint_current message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_current_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint16_t(buf, 0, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_current_t packet;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_CURRENT;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a waypoint_current message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_current_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint16_t(buf, 0, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_current_t packet;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_CURRENT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a waypoint_current struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_current C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_current_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_current_t* waypoint_current)
{
return mavlink_msg_waypoint_current_pack(system_id, component_id, msg, waypoint_current->seq);
}
/**
* @brief Send a waypoint_current message
* @param chan MAVLink channel to send the message
*
* @param seq Sequence
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_current_send(mavlink_channel_t chan, uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint16_t(buf, 0, seq);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_CURRENT, buf, 2);
#else
mavlink_waypoint_current_t packet;
packet.seq = seq;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_CURRENT, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE WAYPOINT_CURRENT UNPACKING
/**
* @brief Get field seq from waypoint_current message
*
* @return Sequence
*/
static inline uint16_t mavlink_msg_waypoint_current_get_seq(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 0);
}
/**
* @brief Decode a waypoint_current message into a struct
*
* @param msg The message to decode
* @param waypoint_current C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_current_decode(const mavlink_message_t* msg, mavlink_waypoint_current_t* waypoint_current)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_current->seq = mavlink_msg_waypoint_current_get_seq(msg);
#else
memcpy(waypoint_current, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,144 +0,0 @@
// MESSAGE WAYPOINT_REACHED PACKING
#define MAVLINK_MSG_ID_WAYPOINT_REACHED 46
typedef struct __mavlink_waypoint_reached_t
{
uint16_t seq; ///< Sequence
} mavlink_waypoint_reached_t;
#define MAVLINK_MSG_ID_WAYPOINT_REACHED_LEN 2
#define MAVLINK_MSG_ID_46_LEN 2
#define MAVLINK_MESSAGE_INFO_WAYPOINT_REACHED { \
"WAYPOINT_REACHED", \
1, \
{ { "seq", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_waypoint_reached_t, seq) }, \
} \
}
/**
* @brief Pack a waypoint_reached message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_reached_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint16_t(buf, 0, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_reached_t packet;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_REACHED;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a waypoint_reached message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_reached_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint16_t(buf, 0, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_reached_t packet;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_REACHED;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a waypoint_reached struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_reached C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_reached_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_reached_t* waypoint_reached)
{
return mavlink_msg_waypoint_reached_pack(system_id, component_id, msg, waypoint_reached->seq);
}
/**
* @brief Send a waypoint_reached message
* @param chan MAVLink channel to send the message
*
* @param seq Sequence
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_reached_send(mavlink_channel_t chan, uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint16_t(buf, 0, seq);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_REACHED, buf, 2);
#else
mavlink_waypoint_reached_t packet;
packet.seq = seq;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_REACHED, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE WAYPOINT_REACHED UNPACKING
/**
* @brief Get field seq from waypoint_reached message
*
* @return Sequence
*/
static inline uint16_t mavlink_msg_waypoint_reached_get_seq(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 0);
}
/**
* @brief Decode a waypoint_reached message into a struct
*
* @param msg The message to decode
* @param waypoint_reached C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_reached_decode(const mavlink_message_t* msg, mavlink_waypoint_reached_t* waypoint_reached)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_reached->seq = mavlink_msg_waypoint_reached_get_seq(msg);
#else
memcpy(waypoint_reached, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,188 +0,0 @@
// MESSAGE WAYPOINT_REQUEST PACKING
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST 40
typedef struct __mavlink_waypoint_request_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint16_t seq; ///< Sequence
} mavlink_waypoint_request_t;
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST_LEN 4
#define MAVLINK_MSG_ID_40_LEN 4
#define MAVLINK_MESSAGE_INFO_WAYPOINT_REQUEST { \
"WAYPOINT_REQUEST", \
3, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_request_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_request_t, target_component) }, \
{ "seq", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_waypoint_request_t, seq) }, \
} \
}
/**
* @brief Pack a waypoint_request message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_request_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_waypoint_request_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_REQUEST;
return mavlink_finalize_message(msg, system_id, component_id, 4);
}
/**
* @brief Pack a waypoint_request message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_request_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_waypoint_request_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_REQUEST;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 4);
}
/**
* @brief Encode a waypoint_request struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_request C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_request_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_request_t* waypoint_request)
{
return mavlink_msg_waypoint_request_pack(system_id, component_id, msg, waypoint_request->target_system, waypoint_request->target_component, waypoint_request->seq);
}
/**
* @brief Send a waypoint_request message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_request_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_REQUEST, buf, 4);
#else
mavlink_waypoint_request_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_REQUEST, (const char *)&packet, 4);
#endif
}
#endif
// MESSAGE WAYPOINT_REQUEST UNPACKING
/**
* @brief Get field target_system from waypoint_request message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_request_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint_request message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_request_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field seq from waypoint_request message
*
* @return Sequence
*/
static inline uint16_t mavlink_msg_waypoint_request_get_seq(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Decode a waypoint_request message into a struct
*
* @param msg The message to decode
* @param waypoint_request C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_request_decode(const mavlink_message_t* msg, mavlink_waypoint_request_t* waypoint_request)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_request->target_system = mavlink_msg_waypoint_request_get_target_system(msg);
waypoint_request->target_component = mavlink_msg_waypoint_request_get_target_component(msg);
waypoint_request->seq = mavlink_msg_waypoint_request_get_seq(msg);
#else
memcpy(waypoint_request, _MAV_PAYLOAD(msg), 4);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE WAYPOINT_REQUEST_LIST PACKING
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST 43
typedef struct __mavlink_waypoint_request_list_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
} mavlink_waypoint_request_list_t;
#define MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST_LEN 2
#define MAVLINK_MSG_ID_43_LEN 2
#define MAVLINK_MESSAGE_INFO_WAYPOINT_REQUEST_LIST { \
"WAYPOINT_REQUEST_LIST", \
2, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_request_list_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_request_list_t, target_component) }, \
} \
}
/**
* @brief Pack a waypoint_request_list message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_request_list_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_request_list_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST;
return mavlink_finalize_message(msg, system_id, component_id, 2);
}
/**
* @brief Pack a waypoint_request_list message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_request_list_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
memcpy(_MAV_PAYLOAD(msg), buf, 2);
#else
mavlink_waypoint_request_list_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
memcpy(_MAV_PAYLOAD(msg), &packet, 2);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 2);
}
/**
* @brief Encode a waypoint_request_list struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_request_list C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_request_list_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_request_list_t* waypoint_request_list)
{
return mavlink_msg_waypoint_request_list_pack(system_id, component_id, msg, waypoint_request_list->target_system, waypoint_request_list->target_component);
}
/**
* @brief Send a waypoint_request_list message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_request_list_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[2];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST, buf, 2);
#else
mavlink_waypoint_request_list_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_REQUEST_LIST, (const char *)&packet, 2);
#endif
}
#endif
// MESSAGE WAYPOINT_REQUEST_LIST UNPACKING
/**
* @brief Get field target_system from waypoint_request_list message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_request_list_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint_request_list message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_request_list_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Decode a waypoint_request_list message into a struct
*
* @param msg The message to decode
* @param waypoint_request_list C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_request_list_decode(const mavlink_message_t* msg, mavlink_waypoint_request_list_t* waypoint_request_list)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_request_list->target_system = mavlink_msg_waypoint_request_list_get_target_system(msg);
waypoint_request_list->target_component = mavlink_msg_waypoint_request_list_get_target_component(msg);
#else
memcpy(waypoint_request_list, _MAV_PAYLOAD(msg), 2);
#endif
}
@@ -1,188 +0,0 @@
// MESSAGE WAYPOINT_SET_CURRENT PACKING
#define MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT 41
typedef struct __mavlink_waypoint_set_current_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint16_t seq; ///< Sequence
} mavlink_waypoint_set_current_t;
#define MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT_LEN 4
#define MAVLINK_MSG_ID_41_LEN 4
#define MAVLINK_MESSAGE_INFO_WAYPOINT_SET_CURRENT { \
"WAYPOINT_SET_CURRENT", \
3, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_waypoint_set_current_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_waypoint_set_current_t, target_component) }, \
{ "seq", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_waypoint_set_current_t, seq) }, \
} \
}
/**
* @brief Pack a waypoint_set_current message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_set_current_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_waypoint_set_current_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT;
return mavlink_finalize_message(msg, system_id, component_id, 4);
}
/**
* @brief Pack a waypoint_set_current message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_waypoint_set_current_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_waypoint_set_current_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 4);
}
/**
* @brief Encode a waypoint_set_current struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param waypoint_set_current C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_waypoint_set_current_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_waypoint_set_current_t* waypoint_set_current)
{
return mavlink_msg_waypoint_set_current_pack(system_id, component_id, msg, waypoint_set_current->target_system, waypoint_set_current->target_component, waypoint_set_current->seq);
}
/**
* @brief Send a waypoint_set_current message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param seq Sequence
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_waypoint_set_current_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t seq)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint16_t(buf, 2, seq);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT, buf, 4);
#else
mavlink_waypoint_set_current_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.seq = seq;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_WAYPOINT_SET_CURRENT, (const char *)&packet, 4);
#endif
}
#endif
// MESSAGE WAYPOINT_SET_CURRENT UNPACKING
/**
* @brief Get field target_system from waypoint_set_current message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_waypoint_set_current_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from waypoint_set_current message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_waypoint_set_current_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field seq from waypoint_set_current message
*
* @return Sequence
*/
static inline uint16_t mavlink_msg_waypoint_set_current_get_seq(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Decode a waypoint_set_current message into a struct
*
* @param msg The message to decode
* @param waypoint_set_current C-struct to decode the message contents into
*/
static inline void mavlink_msg_waypoint_set_current_decode(const mavlink_message_t* msg, mavlink_waypoint_set_current_t* waypoint_set_current)
{
#if MAVLINK_NEED_BYTE_SWAP
waypoint_set_current->target_system = mavlink_msg_waypoint_set_current_get_target_system(msg);
waypoint_set_current->target_component = mavlink_msg_waypoint_set_current_get_target_component(msg);
waypoint_set_current->seq = mavlink_msg_waypoint_set_current_get_seq(msg);
#else
memcpy(waypoint_set_current, _MAV_PAYLOAD(msg), 4);
#endif
}
File diff suppressed because it is too large Load Diff
-12
View File
@@ -1,12 +0,0 @@
/** @file
* @brief MAVLink comm protocol built from common.xml
* @see http://pixhawk.ethz.ch/software/mavlink
*/
#ifndef MAVLINK_VERSION_H
#define MAVLINK_VERSION_H
#define MAVLINK_BUILD_DATE "Sat Oct 29 18:27:32 2011"
#define MAVLINK_WIRE_PROTOCOL_VERSION "0.9"
#define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 101
#endif // MAVLINK_VERSION_H
-488
View File
@@ -1,488 +0,0 @@
#ifndef _MAVLINK_HELPERS_H_
#define _MAVLINK_HELPERS_H_
#include "string.h"
#include "checksum.h"
#include "mavlink_types.h"
#ifndef MAVLINK_HELPER
#define MAVLINK_HELPER
#endif
/*
internal function to give access to the channel status for each channel
*/
MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan)
{
static mavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];
return &m_mavlink_status[chan];
}
/**
* @brief Finalize a MAVLink message with channel assignment
*
* This function calculates the checksum and sets length and aircraft id correctly.
* It assumes that the message id and the payload are already correctly set. This function
* can also be used if the message header has already been written before (as in mavlink_msg_xxx_pack
* instead of mavlink_msg_xxx_pack_headerless), it just introduces little extra overhead.
*
* @param msg Message to finalize
* @param system_id Id of the sending (this) system, 1-127
* @param length Message length
*/
#if MAVLINK_CRC_EXTRA
MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id,
uint8_t chan, uint8_t length, uint8_t crc_extra)
#else
MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id,
uint8_t chan, uint8_t length)
#endif
{
// This code part is the same for all messages;
uint16_t checksum;
msg->magic = MAVLINK_STX;
msg->len = length;
msg->sysid = system_id;
msg->compid = component_id;
// One sequence number per component
msg->seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = mavlink_get_channel_status(chan)->current_tx_seq+1;
checksum = crc_calculate((uint8_t*)&msg->len, length + MAVLINK_CORE_HEADER_LEN);
#if MAVLINK_CRC_EXTRA
crc_accumulate(crc_extra, &checksum);
#endif
mavlink_ck_a(msg) = (uint8_t)(checksum & 0xFF);
mavlink_ck_b(msg) = (uint8_t)(checksum >> 8);
return length + MAVLINK_NUM_NON_PAYLOAD_BYTES;
}
/**
* @brief Finalize a MAVLink message with MAVLINK_COMM_0 as default channel
*/
#if MAVLINK_CRC_EXTRA
MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id,
uint8_t length, uint8_t crc_extra)
{
return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length, crc_extra);
}
#else
MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id,
uint8_t length)
{
return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length);
}
#endif
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len);
/**
* @brief Finalize a MAVLink message with channel assignment and send
*/
#if MAVLINK_CRC_EXTRA
MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet,
uint8_t length, uint8_t crc_extra)
#else
MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, uint8_t length)
#endif
{
uint16_t checksum;
uint8_t buf[MAVLINK_NUM_HEADER_BYTES];
uint8_t ck[2];
mavlink_status_t *status = mavlink_get_channel_status(chan);
buf[0] = MAVLINK_STX;
buf[1] = length;
buf[2] = status->current_tx_seq;
buf[3] = mavlink_system.sysid;
buf[4] = mavlink_system.compid;
buf[5] = msgid;
status->current_tx_seq++;
checksum = crc_calculate((uint8_t*)&buf[1], MAVLINK_CORE_HEADER_LEN);
crc_accumulate_buffer(&checksum, packet, length);
#if MAVLINK_CRC_EXTRA
crc_accumulate(crc_extra, &checksum);
#endif
ck[0] = (uint8_t)(checksum & 0xFF);
ck[1] = (uint8_t)(checksum >> 8);
MAVLINK_START_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)length);
_mavlink_send_uart(chan, (const char *)buf, MAVLINK_NUM_HEADER_BYTES);
_mavlink_send_uart(chan, packet, length);
_mavlink_send_uart(chan, (const char *)ck, 2);
MAVLINK_END_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)length);
}
#endif // MAVLINK_USE_CONVENIENCE_FUNCTIONS
/**
* @brief Pack a message to send it over a serial byte stream
*/
MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t *buffer, const mavlink_message_t *msg)
{
memcpy(buffer, (uint8_t *)&msg->magic, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len);
return MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len;
}
union __mavlink_bitfield {
uint8_t uint8;
int8_t int8;
uint16_t uint16;
int16_t int16;
uint32_t uint32;
int32_t int32;
};
MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg)
{
crc_init(&msg->checksum);
}
MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg, uint8_t c)
{
crc_accumulate(c, &msg->checksum);
}
/**
* This is a convenience function which handles the complete MAVLink parsing.
* the function will parse one byte at a time and return the complete packet once
* it could be successfully decoded. Checksum and other failures will be silently
* ignored.
*
* @param chan ID of the current channel. This allows to parse different channels with this function.
* a channel is not a physical message channel like a serial port, but a logic partition of
* the communication streams in this case. COMM_NB is the limit for the number of channels
* on MCU (e.g. ARM7), while COMM_NB_HIGH is the limit for the number of channels in Linux/Windows
* @param c The char to barse
*
* @param returnMsg NULL if no message could be decoded, the message data else
* @return 0 if no message could be decoded, 1 else
*
* A typical use scenario of this function call is:
*
* @code
* #include <inttypes.h> // For fixed-width uint8_t type
*
* mavlink_message_t msg;
* int chan = 0;
*
*
* while(serial.bytesAvailable > 0)
* {
* uint8_t byte = serial.getNextByte();
* if (mavlink_parse_char(chan, byte, &msg))
* {
* printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
* }
* }
*
*
* @endcode
*/
MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status)
{
static mavlink_message_t m_mavlink_message[MAVLINK_COMM_NUM_BUFFERS];
/*
default message crc function. You can override this per-system to
put this data in a different memory segment
*/
#if MAVLINK_CRC_EXTRA
#ifndef MAVLINK_MESSAGE_CRC
static const uint8_t mavlink_message_crcs[256] = MAVLINK_MESSAGE_CRCS;
#define MAVLINK_MESSAGE_CRC(msgid) mavlink_message_crcs[msgid]
#endif
#endif
mavlink_message_t* rxmsg = &m_mavlink_message[chan]; ///< The currently decoded message
mavlink_status_t* status = mavlink_get_channel_status(chan); ///< The current decode status
int bufferIndex = 0;
status->msg_received = 0;
switch (status->parse_state)
{
case MAVLINK_PARSE_STATE_UNINIT:
case MAVLINK_PARSE_STATE_IDLE:
if (c == MAVLINK_STX)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
rxmsg->len = 0;
mavlink_start_checksum(rxmsg);
}
break;
case MAVLINK_PARSE_STATE_GOT_STX:
if (status->msg_received
/* Support shorter buffers than the
default maximum packet size */
#if (MAVLINK_MAX_PAYLOAD_LEN < 255)
|| c > MAVLINK_MAX_PAYLOAD_LEN
#endif
)
{
status->buffer_overrun++;
status->parse_error++;
status->msg_received = 0;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
}
else
{
// NOT counting STX, LENGTH, SEQ, SYSID, COMPID, MSGID, CRC1 and CRC2
rxmsg->len = c;
status->packet_idx = 0;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_LENGTH;
}
break;
case MAVLINK_PARSE_STATE_GOT_LENGTH:
rxmsg->seq = c;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_SEQ;
break;
case MAVLINK_PARSE_STATE_GOT_SEQ:
rxmsg->sysid = c;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_SYSID;
break;
case MAVLINK_PARSE_STATE_GOT_SYSID:
rxmsg->compid = c;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_COMPID;
break;
case MAVLINK_PARSE_STATE_GOT_COMPID:
rxmsg->msgid = c;
mavlink_update_checksum(rxmsg, c);
if (rxmsg->len == 0)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
}
else
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_MSGID;
}
break;
case MAVLINK_PARSE_STATE_GOT_MSGID:
_MAV_PAYLOAD(rxmsg)[status->packet_idx++] = (char)c;
mavlink_update_checksum(rxmsg, c);
if (status->packet_idx == rxmsg->len)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
}
break;
case MAVLINK_PARSE_STATE_GOT_PAYLOAD:
#if MAVLINK_CRC_EXTRA
mavlink_update_checksum(rxmsg, MAVLINK_MESSAGE_CRC(rxmsg->msgid));
#endif
if (c != (rxmsg->checksum & 0xFF)) {
// Check first checksum byte
status->parse_error++;
status->msg_received = 0;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
if (c == MAVLINK_STX)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
rxmsg->len = 0;
mavlink_start_checksum(rxmsg);
}
}
else
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_CRC1;
}
break;
case MAVLINK_PARSE_STATE_GOT_CRC1:
if (c != (rxmsg->checksum >> 8)) {
// Check second checksum byte
status->parse_error++;
status->msg_received = 0;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
if (c == MAVLINK_STX)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
rxmsg->len = 0;
mavlink_start_checksum(rxmsg);
}
}
else
{
// Successfully got message
status->msg_received = 1;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
memcpy(r_message, rxmsg, sizeof(mavlink_message_t));
}
break;
}
bufferIndex++;
// If a message has been sucessfully decoded, check index
if (status->msg_received == 1)
{
//while(status->current_seq != rxmsg->seq)
//{
// status->packet_rx_drop_count++;
// status->current_seq++;
//}
status->current_rx_seq = rxmsg->seq;
// Initial condition: If no packet has been received so far, drop count is undefined
if (status->packet_rx_success_count == 0) status->packet_rx_drop_count = 0;
// Count this packet as received
status->packet_rx_success_count++;
}
r_mavlink_status->current_rx_seq = status->current_rx_seq+1;
r_mavlink_status->packet_rx_success_count = status->packet_rx_success_count;
r_mavlink_status->packet_rx_drop_count = status->parse_error;
status->parse_error = 0;
return status->msg_received;
}
/**
* @brief Put a bitfield of length 1-32 bit into the buffer
*
* @param b the value to add, will be encoded in the bitfield
* @param bits number of bits to use to encode b, e.g. 1 for boolean, 2, 3, etc.
* @param packet_index the position in the packet (the index of the first byte to use)
* @param bit_index the position in the byte (the index of the first bit to use)
* @param buffer packet buffer to write into
* @return new position of the last used byte in the buffer
*/
MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b, uint8_t bits, uint8_t packet_index, uint8_t bit_index, uint8_t* r_bit_index, uint8_t* buffer)
{
uint16_t bits_remain = bits;
// Transform number into network order
int32_t v;
uint8_t i_bit_index, i_byte_index, curr_bits_n;
#if MAVLINK_NEED_BYTE_SWAP
union {
int32_t i;
uint8_t b[4];
} bin, bout;
bin.i = b;
bout.b[0] = bin.b[3];
bout.b[1] = bin.b[2];
bout.b[2] = bin.b[1];
bout.b[3] = bin.b[0];
v = bout.i;
#else
v = b;
#endif
// buffer in
// 01100000 01000000 00000000 11110001
// buffer out
// 11110001 00000000 01000000 01100000
// Existing partly filled byte (four free slots)
// 0111xxxx
// Mask n free bits
// 00001111 = 2^0 + 2^1 + 2^2 + 2^3 = 2^n - 1
// = ((uint32_t)(1 << n)) - 1; // = 2^n - 1
// Shift n bits into the right position
// out = in >> n;
// Mask and shift bytes
i_bit_index = bit_index;
i_byte_index = packet_index;
if (bit_index > 0)
{
// If bits were available at start, they were available
// in the byte before the current index
i_byte_index--;
}
// While bits have not been packed yet
while (bits_remain > 0)
{
// Bits still have to be packed
// there can be more than 8 bits, so
// we might have to pack them into more than one byte
// First pack everything we can into the current 'open' byte
//curr_bits_n = bits_remain << 3; // Equals bits_remain mod 8
//FIXME
if (bits_remain <= (uint8_t)(8 - i_bit_index))
{
// Enough space
curr_bits_n = (uint8_t)bits_remain;
}
else
{
curr_bits_n = (8 - i_bit_index);
}
// Pack these n bits into the current byte
// Mask out whatever was at that position with ones (xxx11111)
buffer[i_byte_index] &= (0xFF >> (8 - curr_bits_n));
// Put content to this position, by masking out the non-used part
buffer[i_byte_index] |= ((0x00 << curr_bits_n) & v);
// Increment the bit index
i_bit_index += curr_bits_n;
// Now proceed to the next byte, if necessary
bits_remain -= curr_bits_n;
if (bits_remain > 0)
{
// Offer another 8 bits / one byte
i_byte_index++;
i_bit_index = 0;
}
}
*r_bit_index = i_bit_index;
// If a partly filled byte is present, mark this as consumed
if (i_bit_index != 7) i_byte_index++;
return i_byte_index - packet_index;
}
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
// To make MAVLink work on your MCU, define comm_send_ch() if you wish
// to send 1 byte at a time, or MAVLINK_SEND_UART_BYTES() to send a
// whole packet at a time
/*
#include "mavlink_types.h"
void comm_send_ch(mavlink_channel_t chan, uint8_t ch)
{
if (chan == MAVLINK_COMM_0)
{
uart0_transmit(ch);
}
if (chan == MAVLINK_COMM_1)
{
uart1_transmit(ch);
}
}
*/
MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len)
{
#ifdef MAVLINK_SEND_UART_BYTES
/* this is the more efficient approach, if the platform
defines it */
MAVLINK_SEND_UART_BYTES(chan, (uint8_t *)buf, len);
#else
/* fallback to one byte at a time */
uint16_t i;
for (i = 0; i < len; i++) {
comm_send_ch(chan, (uint8_t)buf[i]);
}
#endif
}
#endif // MAVLINK_USE_CONVENIENCE_FUNCTIONS
#endif /* _MAVLINK_HELPERS_H_ */
-298
View File
@@ -1,298 +0,0 @@
#ifndef MAVLINK_TYPES_H_
#define MAVLINK_TYPES_H_
#include "inttypes.h"
enum MAV_CLASS
{
MAV_CLASS_GENERIC = 0, ///< Generic autopilot, full support for everything
MAV_CLASS_PIXHAWK = 1, ///< PIXHAWK autopilot, http://pixhawk.ethz.ch
MAV_CLASS_SLUGS = 2, ///< SLUGS autopilot, http://slugsuav.soe.ucsc.edu
MAV_CLASS_ARDUPILOTMEGA = 3, ///< ArduPilotMega / ArduCopter, http://diydrones.com
MAV_CLASS_OPENPILOT = 4, ///< OpenPilot, http://openpilot.org
MAV_CLASS_GENERIC_MISSION_WAYPOINTS_ONLY = 5, ///< Generic autopilot only supporting simple waypoints
MAV_CLASS_GENERIC_MISSION_NAVIGATION_ONLY = 6, ///< Generic autopilot supporting waypoints and other simple navigation commands
MAV_CLASS_GENERIC_MISSION_FULL = 7, ///< Generic autopilot supporting the full mission command set
MAV_CLASS_NONE = 8, ///< No valid autopilot
MAV_CLASS_NB ///< Number of autopilot classes
};
enum MAV_ACTION
{
MAV_ACTION_HOLD = 0,
MAV_ACTION_MOTORS_START = 1,
MAV_ACTION_LAUNCH = 2,
MAV_ACTION_RETURN = 3,
MAV_ACTION_EMCY_LAND = 4,
MAV_ACTION_EMCY_KILL = 5,
MAV_ACTION_CONFIRM_KILL = 6,
MAV_ACTION_CONTINUE = 7,
MAV_ACTION_MOTORS_STOP = 8,
MAV_ACTION_HALT = 9,
MAV_ACTION_SHUTDOWN = 10,
MAV_ACTION_REBOOT = 11,
MAV_ACTION_SET_MANUAL = 12,
MAV_ACTION_SET_AUTO = 13,
MAV_ACTION_STORAGE_READ = 14,
MAV_ACTION_STORAGE_WRITE = 15,
MAV_ACTION_CALIBRATE_RC = 16,
MAV_ACTION_CALIBRATE_GYRO = 17,
MAV_ACTION_CALIBRATE_MAG = 18,
MAV_ACTION_CALIBRATE_ACC = 19,
MAV_ACTION_CALIBRATE_PRESSURE = 20,
MAV_ACTION_REC_START = 21,
MAV_ACTION_REC_PAUSE = 22,
MAV_ACTION_REC_STOP = 23,
MAV_ACTION_TAKEOFF = 24,
MAV_ACTION_NAVIGATE = 25,
MAV_ACTION_LAND = 26,
MAV_ACTION_LOITER = 27,
MAV_ACTION_SET_ORIGIN = 28,
MAV_ACTION_RELAY_ON = 29,
MAV_ACTION_RELAY_OFF = 30,
MAV_ACTION_GET_IMAGE = 31,
MAV_ACTION_VIDEO_START = 32,
MAV_ACTION_VIDEO_STOP = 33,
MAV_ACTION_RESET_MAP = 34,
MAV_ACTION_RESET_PLAN = 35,
MAV_ACTION_DELAY_BEFORE_COMMAND = 36,
MAV_ACTION_ASCEND_AT_RATE = 37,
MAV_ACTION_CHANGE_MODE = 38,
MAV_ACTION_LOITER_MAX_TURNS = 39,
MAV_ACTION_LOITER_MAX_TIME = 40,
MAV_ACTION_START_HILSIM = 41,
MAV_ACTION_STOP_HILSIM = 42,
MAV_ACTION_NB ///< Number of MAV actions
};
enum MAV_MODE
{
MAV_MODE_UNINIT = 0, ///< System is in undefined state
MAV_MODE_LOCKED = 1, ///< Motors are blocked, system is safe
MAV_MODE_MANUAL = 2, ///< System is allowed to be active, under manual (RC) control
MAV_MODE_GUIDED = 3, ///< System is allowed to be active, under autonomous control, manual setpoint
MAV_MODE_AUTO = 4, ///< System is allowed to be active, under autonomous control and navigation
MAV_MODE_TEST1 = 5, ///< Generic test mode, for custom use
MAV_MODE_TEST2 = 6, ///< Generic test mode, for custom use
MAV_MODE_TEST3 = 7, ///< Generic test mode, for custom use
MAV_MODE_READY = 8, ///< System is ready, motors are unblocked, but controllers are inactive
MAV_MODE_RC_TRAINING = 9 ///< System is blocked, only RC valued are read and reported back
};
enum MAV_STATE
{
MAV_STATE_UNINIT = 0,
MAV_STATE_BOOT,
MAV_STATE_CALIBRATING,
MAV_STATE_STANDBY,
MAV_STATE_ACTIVE,
MAV_STATE_CRITICAL,
MAV_STATE_EMERGENCY,
MAV_STATE_HILSIM,
MAV_STATE_POWEROFF
};
enum MAV_NAV
{
MAV_NAV_GROUNDED = 0,
MAV_NAV_LIFTOFF,
MAV_NAV_HOLD,
MAV_NAV_WAYPOINT,
MAV_NAV_VECTOR,
MAV_NAV_RETURNING,
MAV_NAV_LANDING,
MAV_NAV_LOST,
MAV_NAV_LOITER,
MAV_NAV_FREE_DRIFT
};
enum MAV_TYPE
{
MAV_GENERIC = 0,
MAV_FIXED_WING = 1,
MAV_QUADROTOR = 2,
MAV_COAXIAL = 3,
MAV_HELICOPTER = 4,
MAV_GROUND = 5,
OCU = 6,
MAV_AIRSHIP = 7,
MAV_FREE_BALLOON = 8,
MAV_ROCKET = 9,
UGV_GROUND_ROVER = 10,
UGV_SURFACE_SHIP = 11
};
enum MAV_AUTOPILOT_TYPE
{
MAV_AUTOPILOT_GENERIC = 0,
MAV_AUTOPILOT_PIXHAWK = 1,
MAV_AUTOPILOT_SLUGS = 2,
MAV_AUTOPILOT_ARDUPILOTMEGA = 3,
MAV_AUTOPILOT_NONE = 4
};
enum MAV_COMPONENT
{
MAV_COMP_ID_GPS,
MAV_COMP_ID_WAYPOINTPLANNER,
MAV_COMP_ID_BLOBTRACKER,
MAV_COMP_ID_PATHPLANNER,
MAV_COMP_ID_AIRSLAM,
MAV_COMP_ID_MAPPER,
MAV_COMP_ID_CAMERA,
MAV_COMP_ID_IMU = 200,
MAV_COMP_ID_IMU_2 = 201,
MAV_COMP_ID_IMU_3 = 202,
MAV_COMP_ID_UDP_BRIDGE = 240,
MAV_COMP_ID_UART_BRIDGE = 241,
MAV_COMP_ID_SYSTEM_CONTROL = 250
};
enum MAV_FRAME
{
MAV_FRAME_GLOBAL = 0,
MAV_FRAME_LOCAL = 1,
MAV_FRAME_MISSION = 2,
MAV_FRAME_GLOBAL_RELATIVE_ALT = 3,
MAV_FRAME_LOCAL_ENU = 4
};
enum MAVLINK_DATA_STREAM_TYPE
{
MAVLINK_DATA_STREAM_IMG_JPEG,
MAVLINK_DATA_STREAM_IMG_BMP,
MAVLINK_DATA_STREAM_IMG_RAW8U,
MAVLINK_DATA_STREAM_IMG_RAW32U,
MAVLINK_DATA_STREAM_IMG_PGM,
MAVLINK_DATA_STREAM_IMG_PNG
};
#ifndef MAVLINK_MAX_PAYLOAD_LEN
// it is possible to override this, but be careful!
#define MAVLINK_MAX_PAYLOAD_LEN 255 ///< Maximum payload length
#endif
#define MAVLINK_CORE_HEADER_LEN 5 ///< Length of core header (of the comm. layer): message length (1 byte) + message sequence (1 byte) + message system id (1 byte) + message component id (1 byte) + message type id (1 byte)
#define MAVLINK_NUM_HEADER_BYTES (MAVLINK_CORE_HEADER_LEN + 1) ///< Length of all header bytes, including core and checksum
#define MAVLINK_NUM_CHECKSUM_BYTES 2
#define MAVLINK_NUM_NON_PAYLOAD_BYTES (MAVLINK_NUM_HEADER_BYTES + MAVLINK_NUM_CHECKSUM_BYTES)
#define MAVLINK_MAX_PACKET_LEN (MAVLINK_MAX_PAYLOAD_LEN + MAVLINK_NUM_NON_PAYLOAD_BYTES) ///< Maximum packet length
typedef struct param_union {
union {
float param_float;
int32_t param_int32;
uint32_t param_uint32;
};
uint8_t type;
} mavlink_param_union_t;
typedef struct __mavlink_system {
uint8_t sysid; ///< Used by the MAVLink message_xx_send() convenience function
uint8_t compid; ///< Used by the MAVLink message_xx_send() convenience function
uint8_t type; ///< Unused, can be used by user to store the system's type
uint8_t state; ///< Unused, can be used by user to store the system's state
uint8_t mode; ///< Unused, can be used by user to store the system's mode
uint8_t nav_mode; ///< Unused, can be used by user to store the system's navigation mode
} mavlink_system_t;
typedef struct __mavlink_message {
uint16_t checksum; /// sent at end of packet
uint8_t magic; ///< protocol magic marker
uint8_t len; ///< Length of payload
uint8_t seq; ///< Sequence of packet
uint8_t sysid; ///< ID of message sender system/aircraft
uint8_t compid; ///< ID of the message sender component
uint8_t msgid; ///< ID of message in payload
uint64_t payload64[(MAVLINK_MAX_PAYLOAD_LEN+MAVLINK_NUM_CHECKSUM_BYTES+7)/8];
} mavlink_message_t;
typedef enum {
MAVLINK_TYPE_CHAR = 0,
MAVLINK_TYPE_UINT8_T = 1,
MAVLINK_TYPE_INT8_T = 2,
MAVLINK_TYPE_UINT16_T = 3,
MAVLINK_TYPE_INT16_T = 4,
MAVLINK_TYPE_UINT32_T = 5,
MAVLINK_TYPE_INT32_T = 6,
MAVLINK_TYPE_UINT64_T = 7,
MAVLINK_TYPE_INT64_T = 8,
MAVLINK_TYPE_FLOAT = 9,
MAVLINK_TYPE_DOUBLE = 10
} mavlink_message_type_t;
#define MAVLINK_MAX_FIELDS 64
typedef struct __mavlink_field_info {
const char *name; // name of this field
const char *print_format; // printing format hint, or NULL
mavlink_message_type_t type; // type of this field
unsigned array_length; // if non-zero, field is an array
unsigned wire_offset; // offset of each field in the payload
unsigned structure_offset; // offset in a C structure
} mavlink_field_info_t;
// note that in this structure the order of fields is the order
// in the XML file, not necessary the wire order
typedef struct __mavlink_message_info {
const char *name; // name of the message
unsigned num_fields; // how many fields in this message
mavlink_field_info_t fields[MAVLINK_MAX_FIELDS]; // field information
} mavlink_message_info_t;
#define _MAV_PAYLOAD(msg) ((char *)(&(msg)->payload64[0]))
// checksum is immediately after the payload bytes
#define mavlink_ck_a(msg) *(msg->len + (uint8_t *)_MAV_PAYLOAD(msg))
#define mavlink_ck_b(msg) *((msg->len+(uint16_t)1) + (uint8_t *)_MAV_PAYLOAD(msg))
typedef enum {
MAVLINK_COMM_0,
MAVLINK_COMM_1,
MAVLINK_COMM_2,
MAVLINK_COMM_3
} mavlink_channel_t;
/*
* applications can set MAVLINK_COMM_NUM_BUFFERS to the maximum number
* of buffers they will use. If more are used, then the result will be
* a stack overrun
*/
#ifndef MAVLINK_COMM_NUM_BUFFERS
#if (defined linux) | (defined __linux) | (defined __MACH__) | (defined _WIN32)
# define MAVLINK_COMM_NUM_BUFFERS 16
#else
# define MAVLINK_COMM_NUM_BUFFERS 4
#endif
#endif
typedef enum {
MAVLINK_PARSE_STATE_UNINIT=0,
MAVLINK_PARSE_STATE_IDLE,
MAVLINK_PARSE_STATE_GOT_STX,
MAVLINK_PARSE_STATE_GOT_SEQ,
MAVLINK_PARSE_STATE_GOT_LENGTH,
MAVLINK_PARSE_STATE_GOT_SYSID,
MAVLINK_PARSE_STATE_GOT_COMPID,
MAVLINK_PARSE_STATE_GOT_MSGID,
MAVLINK_PARSE_STATE_GOT_PAYLOAD,
MAVLINK_PARSE_STATE_GOT_CRC1
} mavlink_parse_state_t; ///< The state machine for the comm parser
typedef struct __mavlink_status {
uint8_t msg_received; ///< Number of received messages
uint8_t buffer_overrun; ///< Number of buffer overruns
uint8_t parse_error; ///< Number of parse errors
mavlink_parse_state_t parse_state; ///< Parsing state machine
uint8_t packet_idx; ///< Index in current packet
uint8_t current_rx_seq; ///< Sequence number of last packet received
uint8_t current_tx_seq; ///< Sequence number of last packet sent
uint16_t packet_rx_success_count; ///< Received packets
uint16_t packet_rx_drop_count; ///< Number of packet drops
} mavlink_status_t;
#define MAVLINK_BIG_ENDIAN 0
#define MAVLINK_LITTLE_ENDIAN 1
#endif /* MAVLINK_TYPES_H_ */
@@ -1,149 +0,0 @@
/** @file
* @brief MAVLink comm protocol generated from ardupilotmega.xml
* @see http://qgroundcontrol.org/mavlink/
*/
#ifndef ARDUPILOTMEGA_H
#define ARDUPILOTMEGA_H
#ifdef __cplusplus
extern "C" {
#endif
// MESSAGE LENGTHS AND CRCS
#ifndef MAVLINK_MESSAGE_LENGTHS
#define MAVLINK_MESSAGE_LENGTHS {9, 31, 12, 0, 14, 28, 3, 32, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 25, 23, 30, 101, 22, 26, 16, 14, 28, 32, 28, 28, 22, 22, 21, 6, 6, 37, 4, 4, 2, 2, 4, 2, 2, 3, 13, 12, 19, 17, 15, 15, 27, 25, 18, 18, 20, 20, 0, 0, 26, 0, 36, 0, 6, 4, 0, 21, 18, 0, 0, 0, 20, 0, 33, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 42, 33, 0, 0, 0, 0, 0, 0, 0, 18, 32, 32, 20, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 8, 4, 12, 15, 13, 6, 15, 14, 0, 12, 3, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 30, 18, 18, 51, 9, 3}
#endif
#ifndef MAVLINK_MESSAGE_CRCS
#define MAVLINK_MESSAGE_CRCS {50, 124, 137, 0, 237, 217, 104, 119, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 214, 159, 220, 168, 24, 23, 170, 144, 67, 115, 39, 246, 185, 104, 237, 244, 222, 212, 9, 254, 230, 28, 28, 132, 221, 232, 11, 153, 41, 39, 214, 223, 141, 33, 15, 3, 100, 24, 239, 238, 0, 0, 183, 0, 130, 0, 148, 21, 0, 52, 124, 0, 0, 0, 20, 0, 152, 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 183, 63, 54, 0, 0, 0, 0, 0, 0, 0, 19, 102, 158, 208, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 219, 208, 188, 84, 22, 19, 21, 134, 0, 78, 68, 189, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 49, 170, 44, 83, 46, 247}
#endif
#ifndef MAVLINK_MESSAGE_INFO
#define MAVLINK_MESSAGE_INFO {MAVLINK_MESSAGE_INFO_HEARTBEAT, MAVLINK_MESSAGE_INFO_SYS_STATUS, MAVLINK_MESSAGE_INFO_SYSTEM_TIME, {NULL}, MAVLINK_MESSAGE_INFO_PING, MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL, MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL_ACK, MAVLINK_MESSAGE_INFO_AUTH_KEY, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_SET_MODE, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_PARAM_REQUEST_READ, MAVLINK_MESSAGE_INFO_PARAM_REQUEST_LIST, MAVLINK_MESSAGE_INFO_PARAM_VALUE, MAVLINK_MESSAGE_INFO_PARAM_SET, MAVLINK_MESSAGE_INFO_GPS_RAW_INT, MAVLINK_MESSAGE_INFO_GPS_STATUS, MAVLINK_MESSAGE_INFO_SCALED_IMU, MAVLINK_MESSAGE_INFO_RAW_IMU, MAVLINK_MESSAGE_INFO_RAW_PRESSURE, MAVLINK_MESSAGE_INFO_SCALED_PRESSURE, MAVLINK_MESSAGE_INFO_ATTITUDE, MAVLINK_MESSAGE_INFO_ATTITUDE_QUATERNION, MAVLINK_MESSAGE_INFO_LOCAL_POSITION_NED, MAVLINK_MESSAGE_INFO_GLOBAL_POSITION_INT, MAVLINK_MESSAGE_INFO_RC_CHANNELS_SCALED, MAVLINK_MESSAGE_INFO_RC_CHANNELS_RAW, MAVLINK_MESSAGE_INFO_SERVO_OUTPUT_RAW, MAVLINK_MESSAGE_INFO_MISSION_REQUEST_PARTIAL_LIST, MAVLINK_MESSAGE_INFO_MISSION_WRITE_PARTIAL_LIST, MAVLINK_MESSAGE_INFO_MISSION_ITEM, MAVLINK_MESSAGE_INFO_MISSION_REQUEST, MAVLINK_MESSAGE_INFO_MISSION_SET_CURRENT, MAVLINK_MESSAGE_INFO_MISSION_CURRENT, MAVLINK_MESSAGE_INFO_MISSION_REQUEST_LIST, MAVLINK_MESSAGE_INFO_MISSION_COUNT, MAVLINK_MESSAGE_INFO_MISSION_CLEAR_ALL, MAVLINK_MESSAGE_INFO_MISSION_ITEM_REACHED, MAVLINK_MESSAGE_INFO_MISSION_ACK, MAVLINK_MESSAGE_INFO_SET_GPS_GLOBAL_ORIGIN, MAVLINK_MESSAGE_INFO_GPS_GLOBAL_ORIGIN, MAVLINK_MESSAGE_INFO_SET_LOCAL_POSITION_SETPOINT, MAVLINK_MESSAGE_INFO_LOCAL_POSITION_SETPOINT, MAVLINK_MESSAGE_INFO_GLOBAL_POSITION_SETPOINT_INT, MAVLINK_MESSAGE_INFO_SET_GLOBAL_POSITION_SETPOINT_INT, MAVLINK_MESSAGE_INFO_SAFETY_SET_ALLOWED_AREA, MAVLINK_MESSAGE_INFO_SAFETY_ALLOWED_AREA, MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_THRUST, MAVLINK_MESSAGE_INFO_SET_ROLL_PITCH_YAW_SPEED_THRUST, MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_THRUST_SETPOINT, MAVLINK_MESSAGE_INFO_ROLL_PITCH_YAW_SPEED_THRUST_SETPOINT, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_NAV_CONTROLLER_OUTPUT, {NULL}, MAVLINK_MESSAGE_INFO_STATE_CORRECTION, {NULL}, MAVLINK_MESSAGE_INFO_REQUEST_DATA_STREAM, MAVLINK_MESSAGE_INFO_DATA_STREAM, {NULL}, MAVLINK_MESSAGE_INFO_MANUAL_CONTROL, MAVLINK_MESSAGE_INFO_RC_CHANNELS_OVERRIDE, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_VFR_HUD, {NULL}, MAVLINK_MESSAGE_INFO_COMMAND_LONG, MAVLINK_MESSAGE_INFO_COMMAND_ACK, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_HIL_STATE, MAVLINK_MESSAGE_INFO_HIL_CONTROLS, MAVLINK_MESSAGE_INFO_HIL_RC_INPUTS_RAW, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_OPTICAL_FLOW, MAVLINK_MESSAGE_INFO_GLOBAL_VISION_POSITION_ESTIMATE, MAVLINK_MESSAGE_INFO_VISION_POSITION_ESTIMATE, MAVLINK_MESSAGE_INFO_VISION_SPEED_ESTIMATE, MAVLINK_MESSAGE_INFO_VICON_POSITION_ESTIMATE, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_SENSOR_OFFSETS, MAVLINK_MESSAGE_INFO_SET_MAG_OFFSETS, MAVLINK_MESSAGE_INFO_MEMINFO, MAVLINK_MESSAGE_INFO_AP_ADC, MAVLINK_MESSAGE_INFO_DIGICAM_CONFIGURE, MAVLINK_MESSAGE_INFO_DIGICAM_CONTROL, MAVLINK_MESSAGE_INFO_MOUNT_CONFIGURE, MAVLINK_MESSAGE_INFO_MOUNT_CONTROL, MAVLINK_MESSAGE_INFO_MOUNT_STATUS, {NULL}, MAVLINK_MESSAGE_INFO_FENCE_POINT, MAVLINK_MESSAGE_INFO_FENCE_FETCH_POINT, MAVLINK_MESSAGE_INFO_FENCE_STATUS, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, MAVLINK_MESSAGE_INFO_MEMORY_VECT, MAVLINK_MESSAGE_INFO_DEBUG_VECT, MAVLINK_MESSAGE_INFO_NAMED_VALUE_FLOAT, MAVLINK_MESSAGE_INFO_NAMED_VALUE_INT, MAVLINK_MESSAGE_INFO_STATUSTEXT, MAVLINK_MESSAGE_INFO_DEBUG, MAVLINK_MESSAGE_INFO_EXTENDED_MESSAGE}
#endif
#include "../protocol.h"
#define MAVLINK_ENABLED_ARDUPILOTMEGA
#include "../common/common.h"
// MAVLINK VERSION
#ifndef MAVLINK_VERSION
#define MAVLINK_VERSION 2
#endif
#if (MAVLINK_VERSION == 0)
#undef MAVLINK_VERSION
#define MAVLINK_VERSION 2
#endif
// ENUM DEFINITIONS
/** @brief Enumeration of possible mount operation modes */
#ifndef HAVE_ENUM_MAV_MOUNT_MODE
#define HAVE_ENUM_MAV_MOUNT_MODE
enum MAV_MOUNT_MODE
{
MAV_MOUNT_MODE_RETRACT=0, /* Load and keep safe position (Roll,Pitch,Yaw) from EEPROM and stop stabilization | */
MAV_MOUNT_MODE_NEUTRAL=1, /* Load and keep neutral position (Roll,Pitch,Yaw) from EEPROM. | */
MAV_MOUNT_MODE_MAVLINK_TARGETING=2, /* Load neutral position and start MAVLink Roll,Pitch,Yaw control with stabilization | */
MAV_MOUNT_MODE_RC_TARGETING=3, /* Load neutral position and start RC Roll,Pitch,Yaw control with stabilization | */
MAV_MOUNT_MODE_GPS_POINT=4, /* Load neutral position and start to point to Lat,Lon,Alt | */
MAV_MOUNT_MODE_ENUM_END=5, /* | */
};
#endif
/** @brief */
#ifndef HAVE_ENUM_MAV_CMD
#define HAVE_ENUM_MAV_CMD
enum MAV_CMD
{
MAV_CMD_NAV_WAYPOINT=16, /* Navigate to MISSION. |Hold time in decimal seconds. (ignored by fixed wing, time to stay at MISSION for rotary wing)| Acceptance radius in meters (if the sphere with this radius is hit, the MISSION counts as reached)| 0 to pass through the WP, if > 0 radius in meters to pass by WP. Positive value for clockwise orbit, negative value for counter-clockwise orbit. Allows trajectory control.| Desired yaw angle at MISSION (rotary wing)| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_LOITER_UNLIM=17, /* Loiter around this MISSION an unlimited amount of time |Empty| Empty| Radius around MISSION, in meters. If positive loiter clockwise, else counter-clockwise| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_LOITER_TURNS=18, /* Loiter around this MISSION for X turns |Turns| Empty| Radius around MISSION, in meters. If positive loiter clockwise, else counter-clockwise| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_LOITER_TIME=19, /* Loiter around this MISSION for X seconds |Seconds (decimal)| Empty| Radius around MISSION, in meters. If positive loiter clockwise, else counter-clockwise| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_RETURN_TO_LAUNCH=20, /* Return to launch location |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_NAV_LAND=21, /* Land at location |Empty| Empty| Empty| Desired yaw angle.| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_TAKEOFF=22, /* Takeoff from ground / hand |Minimum pitch (if airspeed sensor present), desired pitch without sensor| Empty| Empty| Yaw angle (if magnetometer present), ignored without magnetometer| Latitude| Longitude| Altitude| */
MAV_CMD_NAV_ROI=80, /* Sets the region of interest (ROI) for a sensor set or the
vehicle itself. This can then be used by the vehicles control
system to control the vehicle attitude and the attitude of various
sensors such as cameras. |Region of intereset mode. (see MAV_ROI enum)| MISSION index/ target ID. (see MAV_ROI enum)| ROI index (allows a vehicle to manage multiple ROI's)| Empty| x the location of the fixed ROI (see MAV_FRAME)| y| z| */
MAV_CMD_NAV_PATHPLANNING=81, /* Control autonomous path planning on the MAV. |0: Disable local obstacle avoidance / local path planning (without resetting map), 1: Enable local path planning, 2: Enable and reset local path planning| 0: Disable full path planning (without resetting map), 1: Enable, 2: Enable and reset map/occupancy grid, 3: Enable and reset planned route, but not occupancy grid| Empty| Yaw angle at goal, in compass degrees, [0..360]| Latitude/X of goal| Longitude/Y of goal| Altitude/Z of goal| */
MAV_CMD_NAV_LAST=95, /* NOP - This command is only used to mark the upper limit of the NAV/ACTION commands in the enumeration |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_CONDITION_DELAY=112, /* Delay mission state machine. |Delay in seconds (decimal)| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_CONDITION_CHANGE_ALT=113, /* Ascend/descend at rate. Delay mission state machine until desired altitude reached. |Descent / Ascend rate (m/s)| Empty| Empty| Empty| Empty| Empty| Finish Altitude| */
MAV_CMD_CONDITION_DISTANCE=114, /* Delay mission state machine until within desired distance of next NAV point. |Distance (meters)| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_CONDITION_YAW=115, /* Reach a certain target angle. |target angle: [0-360], 0 is north| speed during yaw change:[deg per second]| direction: negative: counter clockwise, positive: clockwise [-1,1]| relative offset or absolute angle: [ 1,0]| Empty| Empty| Empty| */
MAV_CMD_CONDITION_LAST=159, /* NOP - This command is only used to mark the upper limit of the CONDITION commands in the enumeration |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_MODE=176, /* Set system mode. |Mode, as defined by ENUM MAV_MODE| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_JUMP=177, /* Jump to the desired command in the mission list. Repeat this action only the specified number of times |Sequence number| Repeat count| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_CHANGE_SPEED=178, /* Change speed and/or throttle set points. |Speed type (0=Airspeed, 1=Ground Speed)| Speed (m/s, -1 indicates no change)| Throttle ( Percent, -1 indicates no change)| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_HOME=179, /* Changes the home location either to the current location or a specified location. |Use current (1=use current location, 0=use specified location)| Empty| Empty| Empty| Latitude| Longitude| Altitude| */
MAV_CMD_DO_SET_PARAMETER=180, /* Set a system parameter. Caution! Use of this command requires knowledge of the numeric enumeration value of the parameter. |Parameter number| Parameter value| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_RELAY=181, /* Set a relay to a condition. |Relay number| Setting (1=on, 0=off, others possible depending on system hardware)| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_REPEAT_RELAY=182, /* Cycle a relay on and off for a desired number of cyles with a desired period. |Relay number| Cycle count| Cycle time (seconds, decimal)| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_SET_SERVO=183, /* Set a servo to a desired PWM value. |Servo number| PWM (microseconds, 1000 to 2000 typical)| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_REPEAT_SERVO=184, /* Cycle a between its nominal setting and a desired PWM for a desired number of cycles with a desired period. |Servo number| PWM (microseconds, 1000 to 2000 typical)| Cycle count| Cycle time (seconds)| Empty| Empty| Empty| */
MAV_CMD_DO_CONTROL_VIDEO=200, /* Control onboard camera system. |Camera ID (-1 for all)| Transmission: 0: disabled, 1: enabled compressed, 2: enabled raw| Transmission mode: 0: video stream, >0: single images every n seconds (decimal)| Recording: 0: disabled, 1: enabled compressed, 2: enabled raw| Empty| Empty| Empty| */
MAV_CMD_DO_DIGICAM_CONFIGURE=202, /* Mission command to configure an on-board camera controller system. |Modes: P, TV, AV, M, Etc| Shutter speed: Divisor number for one second| Aperture: F stop number| ISO number e.g. 80, 100, 200, Etc| Exposure type enumerator| Command Identity| Main engine cut-off time before camera trigger in seconds/10 (0 means no cut-off)| */
MAV_CMD_DO_DIGICAM_CONTROL=203, /* Mission command to control an on-board camera controller system. |Session control e.g. show/hide lens| Zoom's absolute position| Zooming step value to offset zoom from the current position| Focus Locking, Unlocking or Re-locking| Shooting Command| Command Identity| Empty| */
MAV_CMD_DO_MOUNT_CONFIGURE=204, /* Mission command to configure a camera or antenna mount |Mount operation mode (see MAV_MOUNT_MODE enum)| stabilize roll? (1 = yes, 0 = no)| stabilize pitch? (1 = yes, 0 = no)| stabilize yaw? (1 = yes, 0 = no)| Empty| Empty| Empty| */
MAV_CMD_DO_MOUNT_CONTROL=205, /* Mission command to control a camera or antenna mount |pitch(deg*100) or lat, depending on mount mode.| roll(deg*100) or lon depending on mount mode| yaw(deg*100) or alt (in cm) depending on mount mode| Empty| Empty| Empty| Empty| */
MAV_CMD_DO_LAST=240, /* NOP - This command is only used to mark the upper limit of the DO commands in the enumeration |Empty| Empty| Empty| Empty| Empty| Empty| Empty| */
MAV_CMD_PREFLIGHT_CALIBRATION=241, /* Trigger calibration. This command will be only accepted if in pre-flight mode. |Gyro calibration: 0: no, 1: yes| Magnetometer calibration: 0: no, 1: yes| Ground pressure: 0: no, 1: yes| Radio calibration: 0: no, 1: yes| Empty| Empty| Empty| */
MAV_CMD_PREFLIGHT_SET_SENSOR_OFFSETS=242, /* Set sensor offsets. This command will be only accepted if in pre-flight mode. |Sensor to adjust the offsets for: 0: gyros, 1: accelerometer, 2: magnetometer, 3: barometer, 4: optical flow| X axis offset (or generic dimension 1), in the sensor's raw units| Y axis offset (or generic dimension 2), in the sensor's raw units| Z axis offset (or generic dimension 3), in the sensor's raw units| Generic dimension 4, in the sensor's raw units| Generic dimension 5, in the sensor's raw units| Generic dimension 6, in the sensor's raw units| */
MAV_CMD_PREFLIGHT_STORAGE=245, /* Request storage of different parameter values and logs. This command will be only accepted if in pre-flight mode. |Parameter storage: 0: READ FROM FLASH/EEPROM, 1: WRITE CURRENT TO FLASH/EEPROM| Mission storage: 0: READ FROM FLASH/EEPROM, 1: WRITE CURRENT TO FLASH/EEPROM| Reserved| Reserved| Empty| Empty| Empty| */
MAV_CMD_PREFLIGHT_REBOOT_SHUTDOWN=246, /* Request the reboot or shutdown of system components. |0: Do nothing for autopilot, 1: Reboot autopilot, 2: Shutdown autopilot.| 0: Do nothing for onboard computer, 1: Reboot onboard computer, 2: Shutdown onboard computer.| Reserved| Reserved| Empty| Empty| Empty| */
MAV_CMD_OVERRIDE_GOTO=252, /* Hold / continue the current action |MAV_GOTO_DO_HOLD: hold MAV_GOTO_DO_CONTINUE: continue with next item in mission plan| MAV_GOTO_HOLD_AT_CURRENT_POSITION: Hold at current position MAV_GOTO_HOLD_AT_SPECIFIED_POSITION: hold at specified position| MAV_FRAME coordinate frame of hold point| Desired yaw angle in degrees| Latitude / X position| Longitude / Y position| Altitude / Z position| */
MAV_CMD_MISSION_START=300, /* start running a mission |first_item: the first mission item to run| last_item: the last mission item to run (after this item is run, the mission ends)| */
MAV_CMD_ENUM_END=301, /* | */
};
#endif
/** @brief */
#ifndef HAVE_ENUM_FENCE_ACTION
#define HAVE_ENUM_FENCE_ACTION
enum FENCE_ACTION
{
FENCE_ACTION_NONE=0, /* Disable fenced mode | */
FENCE_ACTION_GUIDED=1, /* Switched to guided mode to return point (fence point 0) | */
FENCE_ACTION_ENUM_END=2, /* | */
};
#endif
/** @brief */
#ifndef HAVE_ENUM_FENCE_BREACH
#define HAVE_ENUM_FENCE_BREACH
enum FENCE_BREACH
{
FENCE_BREACH_NONE=0, /* No last fence breach | */
FENCE_BREACH_MINALT=1, /* Breached minimum altitude | */
FENCE_BREACH_MAXALT=2, /* Breached minimum altitude | */
FENCE_BREACH_BOUNDARY=3, /* Breached fence boundary | */
FENCE_BREACH_ENUM_END=4, /* | */
};
#endif
// MESSAGE DEFINITIONS
#include "./mavlink_msg_sensor_offsets.h"
#include "./mavlink_msg_set_mag_offsets.h"
#include "./mavlink_msg_meminfo.h"
#include "./mavlink_msg_ap_adc.h"
#include "./mavlink_msg_digicam_configure.h"
#include "./mavlink_msg_digicam_control.h"
#include "./mavlink_msg_mount_configure.h"
#include "./mavlink_msg_mount_control.h"
#include "./mavlink_msg_mount_status.h"
#include "./mavlink_msg_fence_point.h"
#include "./mavlink_msg_fence_fetch_point.h"
#include "./mavlink_msg_fence_status.h"
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // ARDUPILOTMEGA_H
@@ -1,254 +0,0 @@
// MESSAGE AP_ADC PACKING
#define MAVLINK_MSG_ID_AP_ADC 153
typedef struct __mavlink_ap_adc_t
{
uint16_t adc1; ///< ADC output 1
uint16_t adc2; ///< ADC output 2
uint16_t adc3; ///< ADC output 3
uint16_t adc4; ///< ADC output 4
uint16_t adc5; ///< ADC output 5
uint16_t adc6; ///< ADC output 6
} mavlink_ap_adc_t;
#define MAVLINK_MSG_ID_AP_ADC_LEN 12
#define MAVLINK_MSG_ID_153_LEN 12
#define MAVLINK_MESSAGE_INFO_AP_ADC { \
"AP_ADC", \
6, \
{ { "adc1", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_ap_adc_t, adc1) }, \
{ "adc2", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_ap_adc_t, adc2) }, \
{ "adc3", NULL, MAVLINK_TYPE_UINT16_T, 0, 4, offsetof(mavlink_ap_adc_t, adc3) }, \
{ "adc4", NULL, MAVLINK_TYPE_UINT16_T, 0, 6, offsetof(mavlink_ap_adc_t, adc4) }, \
{ "adc5", NULL, MAVLINK_TYPE_UINT16_T, 0, 8, offsetof(mavlink_ap_adc_t, adc5) }, \
{ "adc6", NULL, MAVLINK_TYPE_UINT16_T, 0, 10, offsetof(mavlink_ap_adc_t, adc6) }, \
} \
}
/**
* @brief Pack a ap_adc message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param adc1 ADC output 1
* @param adc2 ADC output 2
* @param adc3 ADC output 3
* @param adc4 ADC output 4
* @param adc5 ADC output 5
* @param adc6 ADC output 6
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_ap_adc_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint16_t adc1, uint16_t adc2, uint16_t adc3, uint16_t adc4, uint16_t adc5, uint16_t adc6)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_uint16_t(buf, 0, adc1);
_mav_put_uint16_t(buf, 2, adc2);
_mav_put_uint16_t(buf, 4, adc3);
_mav_put_uint16_t(buf, 6, adc4);
_mav_put_uint16_t(buf, 8, adc5);
_mav_put_uint16_t(buf, 10, adc6);
memcpy(_MAV_PAYLOAD(msg), buf, 12);
#else
mavlink_ap_adc_t packet;
packet.adc1 = adc1;
packet.adc2 = adc2;
packet.adc3 = adc3;
packet.adc4 = adc4;
packet.adc5 = adc5;
packet.adc6 = adc6;
memcpy(_MAV_PAYLOAD(msg), &packet, 12);
#endif
msg->msgid = MAVLINK_MSG_ID_AP_ADC;
return mavlink_finalize_message(msg, system_id, component_id, 12, 188);
}
/**
* @brief Pack a ap_adc message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param adc1 ADC output 1
* @param adc2 ADC output 2
* @param adc3 ADC output 3
* @param adc4 ADC output 4
* @param adc5 ADC output 5
* @param adc6 ADC output 6
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_ap_adc_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint16_t adc1,uint16_t adc2,uint16_t adc3,uint16_t adc4,uint16_t adc5,uint16_t adc6)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_uint16_t(buf, 0, adc1);
_mav_put_uint16_t(buf, 2, adc2);
_mav_put_uint16_t(buf, 4, adc3);
_mav_put_uint16_t(buf, 6, adc4);
_mav_put_uint16_t(buf, 8, adc5);
_mav_put_uint16_t(buf, 10, adc6);
memcpy(_MAV_PAYLOAD(msg), buf, 12);
#else
mavlink_ap_adc_t packet;
packet.adc1 = adc1;
packet.adc2 = adc2;
packet.adc3 = adc3;
packet.adc4 = adc4;
packet.adc5 = adc5;
packet.adc6 = adc6;
memcpy(_MAV_PAYLOAD(msg), &packet, 12);
#endif
msg->msgid = MAVLINK_MSG_ID_AP_ADC;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 12, 188);
}
/**
* @brief Encode a ap_adc struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param ap_adc C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_ap_adc_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_ap_adc_t* ap_adc)
{
return mavlink_msg_ap_adc_pack(system_id, component_id, msg, ap_adc->adc1, ap_adc->adc2, ap_adc->adc3, ap_adc->adc4, ap_adc->adc5, ap_adc->adc6);
}
/**
* @brief Send a ap_adc message
* @param chan MAVLink channel to send the message
*
* @param adc1 ADC output 1
* @param adc2 ADC output 2
* @param adc3 ADC output 3
* @param adc4 ADC output 4
* @param adc5 ADC output 5
* @param adc6 ADC output 6
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_ap_adc_send(mavlink_channel_t chan, uint16_t adc1, uint16_t adc2, uint16_t adc3, uint16_t adc4, uint16_t adc5, uint16_t adc6)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[12];
_mav_put_uint16_t(buf, 0, adc1);
_mav_put_uint16_t(buf, 2, adc2);
_mav_put_uint16_t(buf, 4, adc3);
_mav_put_uint16_t(buf, 6, adc4);
_mav_put_uint16_t(buf, 8, adc5);
_mav_put_uint16_t(buf, 10, adc6);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AP_ADC, buf, 12, 188);
#else
mavlink_ap_adc_t packet;
packet.adc1 = adc1;
packet.adc2 = adc2;
packet.adc3 = adc3;
packet.adc4 = adc4;
packet.adc5 = adc5;
packet.adc6 = adc6;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AP_ADC, (const char *)&packet, 12, 188);
#endif
}
#endif
// MESSAGE AP_ADC UNPACKING
/**
* @brief Get field adc1 from ap_adc message
*
* @return ADC output 1
*/
static inline uint16_t mavlink_msg_ap_adc_get_adc1(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 0);
}
/**
* @brief Get field adc2 from ap_adc message
*
* @return ADC output 2
*/
static inline uint16_t mavlink_msg_ap_adc_get_adc2(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Get field adc3 from ap_adc message
*
* @return ADC output 3
*/
static inline uint16_t mavlink_msg_ap_adc_get_adc3(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 4);
}
/**
* @brief Get field adc4 from ap_adc message
*
* @return ADC output 4
*/
static inline uint16_t mavlink_msg_ap_adc_get_adc4(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 6);
}
/**
* @brief Get field adc5 from ap_adc message
*
* @return ADC output 5
*/
static inline uint16_t mavlink_msg_ap_adc_get_adc5(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 8);
}
/**
* @brief Get field adc6 from ap_adc message
*
* @return ADC output 6
*/
static inline uint16_t mavlink_msg_ap_adc_get_adc6(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 10);
}
/**
* @brief Decode a ap_adc message into a struct
*
* @param msg The message to decode
* @param ap_adc C-struct to decode the message contents into
*/
static inline void mavlink_msg_ap_adc_decode(const mavlink_message_t* msg, mavlink_ap_adc_t* ap_adc)
{
#if MAVLINK_NEED_BYTE_SWAP
ap_adc->adc1 = mavlink_msg_ap_adc_get_adc1(msg);
ap_adc->adc2 = mavlink_msg_ap_adc_get_adc2(msg);
ap_adc->adc3 = mavlink_msg_ap_adc_get_adc3(msg);
ap_adc->adc4 = mavlink_msg_ap_adc_get_adc4(msg);
ap_adc->adc5 = mavlink_msg_ap_adc_get_adc5(msg);
ap_adc->adc6 = mavlink_msg_ap_adc_get_adc6(msg);
#else
memcpy(ap_adc, _MAV_PAYLOAD(msg), 12);
#endif
}
@@ -1,166 +0,0 @@
// MESSAGE MEMINFO PACKING
#define MAVLINK_MSG_ID_MEMINFO 152
typedef struct __mavlink_meminfo_t
{
uint16_t brkval; ///< heap top
uint16_t freemem; ///< free memory
} mavlink_meminfo_t;
#define MAVLINK_MSG_ID_MEMINFO_LEN 4
#define MAVLINK_MSG_ID_152_LEN 4
#define MAVLINK_MESSAGE_INFO_MEMINFO { \
"MEMINFO", \
2, \
{ { "brkval", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_meminfo_t, brkval) }, \
{ "freemem", NULL, MAVLINK_TYPE_UINT16_T, 0, 2, offsetof(mavlink_meminfo_t, freemem) }, \
} \
}
/**
* @brief Pack a meminfo message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param brkval heap top
* @param freemem free memory
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_meminfo_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint16_t brkval, uint16_t freemem)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint16_t(buf, 0, brkval);
_mav_put_uint16_t(buf, 2, freemem);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_meminfo_t packet;
packet.brkval = brkval;
packet.freemem = freemem;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_MEMINFO;
return mavlink_finalize_message(msg, system_id, component_id, 4, 208);
}
/**
* @brief Pack a meminfo message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param brkval heap top
* @param freemem free memory
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_meminfo_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint16_t brkval,uint16_t freemem)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint16_t(buf, 0, brkval);
_mav_put_uint16_t(buf, 2, freemem);
memcpy(_MAV_PAYLOAD(msg), buf, 4);
#else
mavlink_meminfo_t packet;
packet.brkval = brkval;
packet.freemem = freemem;
memcpy(_MAV_PAYLOAD(msg), &packet, 4);
#endif
msg->msgid = MAVLINK_MSG_ID_MEMINFO;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 4, 208);
}
/**
* @brief Encode a meminfo struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param meminfo C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_meminfo_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_meminfo_t* meminfo)
{
return mavlink_msg_meminfo_pack(system_id, component_id, msg, meminfo->brkval, meminfo->freemem);
}
/**
* @brief Send a meminfo message
* @param chan MAVLink channel to send the message
*
* @param brkval heap top
* @param freemem free memory
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_meminfo_send(mavlink_channel_t chan, uint16_t brkval, uint16_t freemem)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[4];
_mav_put_uint16_t(buf, 0, brkval);
_mav_put_uint16_t(buf, 2, freemem);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MEMINFO, buf, 4, 208);
#else
mavlink_meminfo_t packet;
packet.brkval = brkval;
packet.freemem = freemem;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MEMINFO, (const char *)&packet, 4, 208);
#endif
}
#endif
// MESSAGE MEMINFO UNPACKING
/**
* @brief Get field brkval from meminfo message
*
* @return heap top
*/
static inline uint16_t mavlink_msg_meminfo_get_brkval(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 0);
}
/**
* @brief Get field freemem from meminfo message
*
* @return free memory
*/
static inline uint16_t mavlink_msg_meminfo_get_freemem(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint16_t(msg, 2);
}
/**
* @brief Decode a meminfo message into a struct
*
* @param msg The message to decode
* @param meminfo C-struct to decode the message contents into
*/
static inline void mavlink_msg_meminfo_decode(const mavlink_message_t* msg, mavlink_meminfo_t* meminfo)
{
#if MAVLINK_NEED_BYTE_SWAP
meminfo->brkval = mavlink_msg_meminfo_get_brkval(msg);
meminfo->freemem = mavlink_msg_meminfo_get_freemem(msg);
#else
memcpy(meminfo, _MAV_PAYLOAD(msg), 4);
#endif
}
@@ -1,254 +0,0 @@
// MESSAGE MOUNT_CONFIGURE PACKING
#define MAVLINK_MSG_ID_MOUNT_CONFIGURE 156
typedef struct __mavlink_mount_configure_t
{
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
uint8_t mount_mode; ///< mount operating mode (see MAV_MOUNT_MODE enum)
uint8_t stab_roll; ///< (1 = yes, 0 = no)
uint8_t stab_pitch; ///< (1 = yes, 0 = no)
uint8_t stab_yaw; ///< (1 = yes, 0 = no)
} mavlink_mount_configure_t;
#define MAVLINK_MSG_ID_MOUNT_CONFIGURE_LEN 6
#define MAVLINK_MSG_ID_156_LEN 6
#define MAVLINK_MESSAGE_INFO_MOUNT_CONFIGURE { \
"MOUNT_CONFIGURE", \
6, \
{ { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_mount_configure_t, target_system) }, \
{ "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_mount_configure_t, target_component) }, \
{ "mount_mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_mount_configure_t, mount_mode) }, \
{ "stab_roll", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_mount_configure_t, stab_roll) }, \
{ "stab_pitch", NULL, MAVLINK_TYPE_UINT8_T, 0, 4, offsetof(mavlink_mount_configure_t, stab_pitch) }, \
{ "stab_yaw", NULL, MAVLINK_TYPE_UINT8_T, 0, 5, offsetof(mavlink_mount_configure_t, stab_yaw) }, \
} \
}
/**
* @brief Pack a mount_configure message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param mount_mode mount operating mode (see MAV_MOUNT_MODE enum)
* @param stab_roll (1 = yes, 0 = no)
* @param stab_pitch (1 = yes, 0 = no)
* @param stab_yaw (1 = yes, 0 = no)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_mount_configure_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target_system, uint8_t target_component, uint8_t mount_mode, uint8_t stab_roll, uint8_t stab_pitch, uint8_t stab_yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[6];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, mount_mode);
_mav_put_uint8_t(buf, 3, stab_roll);
_mav_put_uint8_t(buf, 4, stab_pitch);
_mav_put_uint8_t(buf, 5, stab_yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 6);
#else
mavlink_mount_configure_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mount_mode = mount_mode;
packet.stab_roll = stab_roll;
packet.stab_pitch = stab_pitch;
packet.stab_yaw = stab_yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 6);
#endif
msg->msgid = MAVLINK_MSG_ID_MOUNT_CONFIGURE;
return mavlink_finalize_message(msg, system_id, component_id, 6, 19);
}
/**
* @brief Pack a mount_configure message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param mount_mode mount operating mode (see MAV_MOUNT_MODE enum)
* @param stab_roll (1 = yes, 0 = no)
* @param stab_pitch (1 = yes, 0 = no)
* @param stab_yaw (1 = yes, 0 = no)
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_mount_configure_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target_system,uint8_t target_component,uint8_t mount_mode,uint8_t stab_roll,uint8_t stab_pitch,uint8_t stab_yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[6];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, mount_mode);
_mav_put_uint8_t(buf, 3, stab_roll);
_mav_put_uint8_t(buf, 4, stab_pitch);
_mav_put_uint8_t(buf, 5, stab_yaw);
memcpy(_MAV_PAYLOAD(msg), buf, 6);
#else
mavlink_mount_configure_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mount_mode = mount_mode;
packet.stab_roll = stab_roll;
packet.stab_pitch = stab_pitch;
packet.stab_yaw = stab_yaw;
memcpy(_MAV_PAYLOAD(msg), &packet, 6);
#endif
msg->msgid = MAVLINK_MSG_ID_MOUNT_CONFIGURE;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 6, 19);
}
/**
* @brief Encode a mount_configure struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param mount_configure C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_mount_configure_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_mount_configure_t* mount_configure)
{
return mavlink_msg_mount_configure_pack(system_id, component_id, msg, mount_configure->target_system, mount_configure->target_component, mount_configure->mount_mode, mount_configure->stab_roll, mount_configure->stab_pitch, mount_configure->stab_yaw);
}
/**
* @brief Send a mount_configure message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param mount_mode mount operating mode (see MAV_MOUNT_MODE enum)
* @param stab_roll (1 = yes, 0 = no)
* @param stab_pitch (1 = yes, 0 = no)
* @param stab_yaw (1 = yes, 0 = no)
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_mount_configure_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint8_t mount_mode, uint8_t stab_roll, uint8_t stab_pitch, uint8_t stab_yaw)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[6];
_mav_put_uint8_t(buf, 0, target_system);
_mav_put_uint8_t(buf, 1, target_component);
_mav_put_uint8_t(buf, 2, mount_mode);
_mav_put_uint8_t(buf, 3, stab_roll);
_mav_put_uint8_t(buf, 4, stab_pitch);
_mav_put_uint8_t(buf, 5, stab_yaw);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MOUNT_CONFIGURE, buf, 6, 19);
#else
mavlink_mount_configure_t packet;
packet.target_system = target_system;
packet.target_component = target_component;
packet.mount_mode = mount_mode;
packet.stab_roll = stab_roll;
packet.stab_pitch = stab_pitch;
packet.stab_yaw = stab_yaw;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MOUNT_CONFIGURE, (const char *)&packet, 6, 19);
#endif
}
#endif
// MESSAGE MOUNT_CONFIGURE UNPACKING
/**
* @brief Get field target_system from mount_configure message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_mount_configure_get_target_system(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field target_component from mount_configure message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_mount_configure_get_target_component(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field mount_mode from mount_configure message
*
* @return mount operating mode (see MAV_MOUNT_MODE enum)
*/
static inline uint8_t mavlink_msg_mount_configure_get_mount_mode(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Get field stab_roll from mount_configure message
*
* @return (1 = yes, 0 = no)
*/
static inline uint8_t mavlink_msg_mount_configure_get_stab_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 3);
}
/**
* @brief Get field stab_pitch from mount_configure message
*
* @return (1 = yes, 0 = no)
*/
static inline uint8_t mavlink_msg_mount_configure_get_stab_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 4);
}
/**
* @brief Get field stab_yaw from mount_configure message
*
* @return (1 = yes, 0 = no)
*/
static inline uint8_t mavlink_msg_mount_configure_get_stab_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 5);
}
/**
* @brief Decode a mount_configure message into a struct
*
* @param msg The message to decode
* @param mount_configure C-struct to decode the message contents into
*/
static inline void mavlink_msg_mount_configure_decode(const mavlink_message_t* msg, mavlink_mount_configure_t* mount_configure)
{
#if MAVLINK_NEED_BYTE_SWAP
mount_configure->target_system = mavlink_msg_mount_configure_get_target_system(msg);
mount_configure->target_component = mavlink_msg_mount_configure_get_target_component(msg);
mount_configure->mount_mode = mavlink_msg_mount_configure_get_mount_mode(msg);
mount_configure->stab_roll = mavlink_msg_mount_configure_get_stab_roll(msg);
mount_configure->stab_pitch = mavlink_msg_mount_configure_get_stab_pitch(msg);
mount_configure->stab_yaw = mavlink_msg_mount_configure_get_stab_yaw(msg);
#else
memcpy(mount_configure, _MAV_PAYLOAD(msg), 6);
#endif
}
-89
View File
@@ -1,89 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _CHECKSUM_H_
#define _CHECKSUM_H_
/**
*
* CALCULATE THE CHECKSUM
*
*/
#define X25_INIT_CRC 0xffff
#define X25_VALIDATE_CRC 0xf0b8
/**
* @brief Accumulate the X.25 CRC by adding one char at a time.
*
* The checksum function adds the hash of one char at a time to the
* 16 bit checksum (uint16_t).
*
* @param data new char to hash
* @param crcAccum the already accumulated checksum
**/
static inline void crc_accumulate(uint8_t data, uint16_t *crcAccum)
{
/*Accumulate one byte of data into the CRC*/
uint8_t tmp;
tmp = data ^ (uint8_t)(*crcAccum &0xff);
tmp ^= (tmp<<4);
*crcAccum = (*crcAccum>>8) ^ (tmp<<8) ^ (tmp <<3) ^ (tmp>>4);
}
/**
* @brief Initiliaze the buffer for the X.25 CRC
*
* @param crcAccum the 16 bit X.25 CRC
*/
static inline void crc_init(uint16_t* crcAccum)
{
*crcAccum = X25_INIT_CRC;
}
/**
* @brief Calculates the X.25 checksum on a byte buffer
*
* @param pBuffer buffer containing the byte array to hash
* @param length length of the byte array
* @return the checksum over the buffer bytes
**/
static inline uint16_t crc_calculate(uint8_t* pBuffer, uint16_t length)
{
uint16_t crcTmp;
crc_init(&crcTmp);
while (length--) {
crc_accumulate(*pBuffer++, &crcTmp);
}
return crcTmp;
}
/**
* @brief Accumulate the X.25 CRC by adding an array of bytes
*
* The checksum function adds the hash of one char at a time to the
* 16 bit checksum (uint16_t).
*
* @param data new bytes to hash
* @param crcAccum the already accumulated checksum
**/
static inline void crc_accumulate_buffer(uint16_t *crcAccum, const char *pBuffer, uint8_t length)
{
const uint8_t *p = (const uint8_t *)pBuffer;
while (length--) {
crc_accumulate(*p++, crcAccum);
}
}
#endif /* _CHECKSUM_H_ */
#ifdef __cplusplus
}
#endif
@@ -1,188 +0,0 @@
// MESSAGE CHANGE_OPERATOR_CONTROL_ACK PACKING
#define MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK 6
typedef struct __mavlink_change_operator_control_ack_t
{
uint8_t gcs_system_id; ///< ID of the GCS this message
uint8_t control_request; ///< 0: request control of this MAV, 1: Release control of this MAV
uint8_t ack; ///< 0: ACK, 1: NACK: Wrong passkey, 2: NACK: Unsupported passkey encryption method, 3: NACK: Already under control
} mavlink_change_operator_control_ack_t;
#define MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK_LEN 3
#define MAVLINK_MSG_ID_6_LEN 3
#define MAVLINK_MESSAGE_INFO_CHANGE_OPERATOR_CONTROL_ACK { \
"CHANGE_OPERATOR_CONTROL_ACK", \
3, \
{ { "gcs_system_id", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_change_operator_control_ack_t, gcs_system_id) }, \
{ "control_request", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_change_operator_control_ack_t, control_request) }, \
{ "ack", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_change_operator_control_ack_t, ack) }, \
} \
}
/**
* @brief Pack a change_operator_control_ack message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param gcs_system_id ID of the GCS this message
* @param control_request 0: request control of this MAV, 1: Release control of this MAV
* @param ack 0: ACK, 1: NACK: Wrong passkey, 2: NACK: Unsupported passkey encryption method, 3: NACK: Already under control
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_change_operator_control_ack_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t gcs_system_id, uint8_t control_request, uint8_t ack)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, gcs_system_id);
_mav_put_uint8_t(buf, 1, control_request);
_mav_put_uint8_t(buf, 2, ack);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_change_operator_control_ack_t packet;
packet.gcs_system_id = gcs_system_id;
packet.control_request = control_request;
packet.ack = ack;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK;
return mavlink_finalize_message(msg, system_id, component_id, 3, 104);
}
/**
* @brief Pack a change_operator_control_ack message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param gcs_system_id ID of the GCS this message
* @param control_request 0: request control of this MAV, 1: Release control of this MAV
* @param ack 0: ACK, 1: NACK: Wrong passkey, 2: NACK: Unsupported passkey encryption method, 3: NACK: Already under control
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_change_operator_control_ack_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t gcs_system_id,uint8_t control_request,uint8_t ack)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, gcs_system_id);
_mav_put_uint8_t(buf, 1, control_request);
_mav_put_uint8_t(buf, 2, ack);
memcpy(_MAV_PAYLOAD(msg), buf, 3);
#else
mavlink_change_operator_control_ack_t packet;
packet.gcs_system_id = gcs_system_id;
packet.control_request = control_request;
packet.ack = ack;
memcpy(_MAV_PAYLOAD(msg), &packet, 3);
#endif
msg->msgid = MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 3, 104);
}
/**
* @brief Encode a change_operator_control_ack struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param change_operator_control_ack C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_change_operator_control_ack_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_change_operator_control_ack_t* change_operator_control_ack)
{
return mavlink_msg_change_operator_control_ack_pack(system_id, component_id, msg, change_operator_control_ack->gcs_system_id, change_operator_control_ack->control_request, change_operator_control_ack->ack);
}
/**
* @brief Send a change_operator_control_ack message
* @param chan MAVLink channel to send the message
*
* @param gcs_system_id ID of the GCS this message
* @param control_request 0: request control of this MAV, 1: Release control of this MAV
* @param ack 0: ACK, 1: NACK: Wrong passkey, 2: NACK: Unsupported passkey encryption method, 3: NACK: Already under control
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_change_operator_control_ack_send(mavlink_channel_t chan, uint8_t gcs_system_id, uint8_t control_request, uint8_t ack)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[3];
_mav_put_uint8_t(buf, 0, gcs_system_id);
_mav_put_uint8_t(buf, 1, control_request);
_mav_put_uint8_t(buf, 2, ack);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK, buf, 3, 104);
#else
mavlink_change_operator_control_ack_t packet;
packet.gcs_system_id = gcs_system_id;
packet.control_request = control_request;
packet.ack = ack;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK, (const char *)&packet, 3, 104);
#endif
}
#endif
// MESSAGE CHANGE_OPERATOR_CONTROL_ACK UNPACKING
/**
* @brief Get field gcs_system_id from change_operator_control_ack message
*
* @return ID of the GCS this message
*/
static inline uint8_t mavlink_msg_change_operator_control_ack_get_gcs_system_id(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 0);
}
/**
* @brief Get field control_request from change_operator_control_ack message
*
* @return 0: request control of this MAV, 1: Release control of this MAV
*/
static inline uint8_t mavlink_msg_change_operator_control_ack_get_control_request(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 1);
}
/**
* @brief Get field ack from change_operator_control_ack message
*
* @return 0: ACK, 1: NACK: Wrong passkey, 2: NACK: Unsupported passkey encryption method, 3: NACK: Already under control
*/
static inline uint8_t mavlink_msg_change_operator_control_ack_get_ack(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 2);
}
/**
* @brief Decode a change_operator_control_ack message into a struct
*
* @param msg The message to decode
* @param change_operator_control_ack C-struct to decode the message contents into
*/
static inline void mavlink_msg_change_operator_control_ack_decode(const mavlink_message_t* msg, mavlink_change_operator_control_ack_t* change_operator_control_ack)
{
#if MAVLINK_NEED_BYTE_SWAP
change_operator_control_ack->gcs_system_id = mavlink_msg_change_operator_control_ack_get_gcs_system_id(msg);
change_operator_control_ack->control_request = mavlink_msg_change_operator_control_ack_get_control_request(msg);
change_operator_control_ack->ack = mavlink_msg_change_operator_control_ack_get_ack(msg);
#else
memcpy(change_operator_control_ack, _MAV_PAYLOAD(msg), 3);
#endif
}
@@ -1,320 +0,0 @@
// MESSAGE MANUAL_CONTROL PACKING
#define MAVLINK_MSG_ID_MANUAL_CONTROL 69
typedef struct __mavlink_manual_control_t
{
float roll; ///< roll
float pitch; ///< pitch
float yaw; ///< yaw
float thrust; ///< thrust
uint8_t target; ///< The system to be controlled
uint8_t roll_manual; ///< roll control enabled auto:0, manual:1
uint8_t pitch_manual; ///< pitch auto:0, manual:1
uint8_t yaw_manual; ///< yaw auto:0, manual:1
uint8_t thrust_manual; ///< thrust auto:0, manual:1
} mavlink_manual_control_t;
#define MAVLINK_MSG_ID_MANUAL_CONTROL_LEN 21
#define MAVLINK_MSG_ID_69_LEN 21
#define MAVLINK_MESSAGE_INFO_MANUAL_CONTROL { \
"MANUAL_CONTROL", \
9, \
{ { "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 0, offsetof(mavlink_manual_control_t, roll) }, \
{ "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_manual_control_t, pitch) }, \
{ "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_manual_control_t, yaw) }, \
{ "thrust", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_manual_control_t, thrust) }, \
{ "target", NULL, MAVLINK_TYPE_UINT8_T, 0, 16, offsetof(mavlink_manual_control_t, target) }, \
{ "roll_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 17, offsetof(mavlink_manual_control_t, roll_manual) }, \
{ "pitch_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 18, offsetof(mavlink_manual_control_t, pitch_manual) }, \
{ "yaw_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 19, offsetof(mavlink_manual_control_t, yaw_manual) }, \
{ "thrust_manual", NULL, MAVLINK_TYPE_UINT8_T, 0, 20, offsetof(mavlink_manual_control_t, thrust_manual) }, \
} \
}
/**
* @brief Pack a manual_control message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target The system to be controlled
* @param roll roll
* @param pitch pitch
* @param yaw yaw
* @param thrust thrust
* @param roll_manual roll control enabled auto:0, manual:1
* @param pitch_manual pitch auto:0, manual:1
* @param yaw_manual yaw auto:0, manual:1
* @param thrust_manual thrust auto:0, manual:1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_manual_control_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
uint8_t target, float roll, float pitch, float yaw, float thrust, uint8_t roll_manual, uint8_t pitch_manual, uint8_t yaw_manual, uint8_t thrust_manual)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_float(buf, 0, roll);
_mav_put_float(buf, 4, pitch);
_mav_put_float(buf, 8, yaw);
_mav_put_float(buf, 12, thrust);
_mav_put_uint8_t(buf, 16, target);
_mav_put_uint8_t(buf, 17, roll_manual);
_mav_put_uint8_t(buf, 18, pitch_manual);
_mav_put_uint8_t(buf, 19, yaw_manual);
_mav_put_uint8_t(buf, 20, thrust_manual);
memcpy(_MAV_PAYLOAD(msg), buf, 21);
#else
mavlink_manual_control_t packet;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
packet.target = target;
packet.roll_manual = roll_manual;
packet.pitch_manual = pitch_manual;
packet.yaw_manual = yaw_manual;
packet.thrust_manual = thrust_manual;
memcpy(_MAV_PAYLOAD(msg), &packet, 21);
#endif
msg->msgid = MAVLINK_MSG_ID_MANUAL_CONTROL;
return mavlink_finalize_message(msg, system_id, component_id, 21, 52);
}
/**
* @brief Pack a manual_control message on a channel
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target The system to be controlled
* @param roll roll
* @param pitch pitch
* @param yaw yaw
* @param thrust thrust
* @param roll_manual roll control enabled auto:0, manual:1
* @param pitch_manual pitch auto:0, manual:1
* @param yaw_manual yaw auto:0, manual:1
* @param thrust_manual thrust auto:0, manual:1
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_manual_control_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
mavlink_message_t* msg,
uint8_t target,float roll,float pitch,float yaw,float thrust,uint8_t roll_manual,uint8_t pitch_manual,uint8_t yaw_manual,uint8_t thrust_manual)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_float(buf, 0, roll);
_mav_put_float(buf, 4, pitch);
_mav_put_float(buf, 8, yaw);
_mav_put_float(buf, 12, thrust);
_mav_put_uint8_t(buf, 16, target);
_mav_put_uint8_t(buf, 17, roll_manual);
_mav_put_uint8_t(buf, 18, pitch_manual);
_mav_put_uint8_t(buf, 19, yaw_manual);
_mav_put_uint8_t(buf, 20, thrust_manual);
memcpy(_MAV_PAYLOAD(msg), buf, 21);
#else
mavlink_manual_control_t packet;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
packet.target = target;
packet.roll_manual = roll_manual;
packet.pitch_manual = pitch_manual;
packet.yaw_manual = yaw_manual;
packet.thrust_manual = thrust_manual;
memcpy(_MAV_PAYLOAD(msg), &packet, 21);
#endif
msg->msgid = MAVLINK_MSG_ID_MANUAL_CONTROL;
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 21, 52);
}
/**
* @brief Encode a manual_control struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param manual_control C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_manual_control_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_manual_control_t* manual_control)
{
return mavlink_msg_manual_control_pack(system_id, component_id, msg, manual_control->target, manual_control->roll, manual_control->pitch, manual_control->yaw, manual_control->thrust, manual_control->roll_manual, manual_control->pitch_manual, manual_control->yaw_manual, manual_control->thrust_manual);
}
/**
* @brief Send a manual_control message
* @param chan MAVLink channel to send the message
*
* @param target The system to be controlled
* @param roll roll
* @param pitch pitch
* @param yaw yaw
* @param thrust thrust
* @param roll_manual roll control enabled auto:0, manual:1
* @param pitch_manual pitch auto:0, manual:1
* @param yaw_manual yaw auto:0, manual:1
* @param thrust_manual thrust auto:0, manual:1
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_manual_control_send(mavlink_channel_t chan, uint8_t target, float roll, float pitch, float yaw, float thrust, uint8_t roll_manual, uint8_t pitch_manual, uint8_t yaw_manual, uint8_t thrust_manual)
{
#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
char buf[21];
_mav_put_float(buf, 0, roll);
_mav_put_float(buf, 4, pitch);
_mav_put_float(buf, 8, yaw);
_mav_put_float(buf, 12, thrust);
_mav_put_uint8_t(buf, 16, target);
_mav_put_uint8_t(buf, 17, roll_manual);
_mav_put_uint8_t(buf, 18, pitch_manual);
_mav_put_uint8_t(buf, 19, yaw_manual);
_mav_put_uint8_t(buf, 20, thrust_manual);
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MANUAL_CONTROL, buf, 21, 52);
#else
mavlink_manual_control_t packet;
packet.roll = roll;
packet.pitch = pitch;
packet.yaw = yaw;
packet.thrust = thrust;
packet.target = target;
packet.roll_manual = roll_manual;
packet.pitch_manual = pitch_manual;
packet.yaw_manual = yaw_manual;
packet.thrust_manual = thrust_manual;
_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_MANUAL_CONTROL, (const char *)&packet, 21, 52);
#endif
}
#endif
// MESSAGE MANUAL_CONTROL UNPACKING
/**
* @brief Get field target from manual_control message
*
* @return The system to be controlled
*/
static inline uint8_t mavlink_msg_manual_control_get_target(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 16);
}
/**
* @brief Get field roll from manual_control message
*
* @return roll
*/
static inline float mavlink_msg_manual_control_get_roll(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 0);
}
/**
* @brief Get field pitch from manual_control message
*
* @return pitch
*/
static inline float mavlink_msg_manual_control_get_pitch(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 4);
}
/**
* @brief Get field yaw from manual_control message
*
* @return yaw
*/
static inline float mavlink_msg_manual_control_get_yaw(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 8);
}
/**
* @brief Get field thrust from manual_control message
*
* @return thrust
*/
static inline float mavlink_msg_manual_control_get_thrust(const mavlink_message_t* msg)
{
return _MAV_RETURN_float(msg, 12);
}
/**
* @brief Get field roll_manual from manual_control message
*
* @return roll control enabled auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_roll_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 17);
}
/**
* @brief Get field pitch_manual from manual_control message
*
* @return pitch auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_pitch_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 18);
}
/**
* @brief Get field yaw_manual from manual_control message
*
* @return yaw auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_yaw_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 19);
}
/**
* @brief Get field thrust_manual from manual_control message
*
* @return thrust auto:0, manual:1
*/
static inline uint8_t mavlink_msg_manual_control_get_thrust_manual(const mavlink_message_t* msg)
{
return _MAV_RETURN_uint8_t(msg, 20);
}
/**
* @brief Decode a manual_control message into a struct
*
* @param msg The message to decode
* @param manual_control C-struct to decode the message contents into
*/
static inline void mavlink_msg_manual_control_decode(const mavlink_message_t* msg, mavlink_manual_control_t* manual_control)
{
#if MAVLINK_NEED_BYTE_SWAP
manual_control->roll = mavlink_msg_manual_control_get_roll(msg);
manual_control->pitch = mavlink_msg_manual_control_get_pitch(msg);
manual_control->yaw = mavlink_msg_manual_control_get_yaw(msg);
manual_control->thrust = mavlink_msg_manual_control_get_thrust(msg);
manual_control->target = mavlink_msg_manual_control_get_target(msg);
manual_control->roll_manual = mavlink_msg_manual_control_get_roll_manual(msg);
manual_control->pitch_manual = mavlink_msg_manual_control_get_pitch_manual(msg);
manual_control->yaw_manual = mavlink_msg_manual_control_get_yaw_manual(msg);
manual_control->thrust_manual = mavlink_msg_manual_control_get_thrust_manual(msg);
#else
memcpy(manual_control, _MAV_PAYLOAD(msg), 21);
#endif
}

Some files were not shown because too many files have changed in this diff Show More