fixes and whatnot - update mavlink parser to upstream, and add the start of some copter support

assets/mavFlightMode.js

@@ -86,9 +86,9 @@ MavFlightMode.prototype.attachHandlers = function(sysid,mavlink,mavlinkParser,st
 
 
         // else ignore data for other sysids than the one we are interested in.
-        if ( heartbeat.header.srcSystem != sysid ) return; 
+        if ( heartbeat._header.srcSystem != sysid ) return; 
 
-        //console.log('zzzzzzzzzzzzzzzzzzzz'+heartbeat.header.srcSystem);
+        //console.log('zzzzzzzzzzzzzzzzzzzz'+heartbeat._header.srcSystem);
         //console.log('xxxxxxxxxxxxxxxxxxxx'+sysid);
         //console.log(`custom mode: ${heartbeat.custom_mode}`);
         //console.log(`base mode: ${heartbeat.base_mode}`);
@@ -102,8 +102,17 @@ MavFlightMode.prototype.attachHandlers = function(sysid,mavlink,mavlinkParser,st
 
 		// Translate the bitfields for use in the client.
 
-        // arduplane uses packet.custom_mode to index into mode_mapping_apm - TODO copter uses acm
-        newState.mode = mode_mapping_apm[heartbeat.custom_mode]; 
+
+        //copter or plane or something else?
+        if (heartbeat.type == mavlink20.MAV_TYPE_FIXED_WING ) {
+            // arduplane uses packet.custom_mode to index into mode_mapping_apm 
+            newState.mode = mode_mapping_apm[heartbeat.custom_mode]; 
+        }
+        if (heartbeat.type == mavlink20.MAV_TYPE_QUADROTOR ) {
+            // arducopter uses packet.custom_mode to index into mode_mapping_acm 
+            newState.mode = mode_mapping_acm[heartbeat.custom_mode]; 
+        }
+
         //console.log("ardumode:"+newState.mode);
 		newState.armed = ( mavlink.MAV_MODE_FLAG_SAFETY_ARMED & heartbeat.base_mode ) ? true : false;		
 

local_modules/README.md

@@ -0,0 +1,6 @@
+This folder is a locally modified copy of some Node/npm packages 'jspack' and 'long'. we have copied them here and tweaked them to be compatible with our needs, please see their respective README.md file for their original info, which we have not changed. 
+
+This README.md serves to make you aware that these two packages as stored here in the 'jspack' and 'long' folders ARE MODIFIED from the originals.
+By placing this statement here, and putting a notice in long.js as well, we feel are in compliance with the LICENSE file of 'long' , wich requires us to tell you they are modified.
+
+We have included their original license files, in compliance with them, as both license/s permit distribution of derived works in source and/or binary form.

local_modules/jspack/.npmignore

@@ -0,0 +1,19 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+*.pyc
+
+pids
+logs
+results
+
+npm-debug.log
+node_modules
+
+**~
+**.swp

local_modules/jspack/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2008, Fair Oaks Labs, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list
+      of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice, this
+      list of conditions and the following disclaimer in the documentation and/or other
+      materials provided with the distribution.
+
+    * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors may be
+      used to endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

local_modules/jspack/README.md

@@ -0,0 +1,147 @@
+jspack - library to pack primitives to octet arrays
+====================================================
+
+[![Build status](https://travis-ci.org/birchroad/node-jspack.svg?branch=master)](https://travis-ci.org/birchroad/node-jspack)
+
+## Disclaimer
+The jspack module and documentation are essentially ports of the
+Python struct module and documentation, with such changes as were necessary. The port was originaly made by Fair Oaks Labs, Inc. and published at http://code.google.com/p/jspack/
+If any Python people are miffed that their documentation got ripped off, let me know,
+and I'll gladly revise them.
+
+This module performs conversions between JavaScript values and C structs
+represented as octet arrays (i.e. JavaScript arrays of integral numbers
+between 0 and 255, inclusive).  It uses format strings (explained below) as
+compact descriptions of the layout of the C structs and the intended conversion
+to/from JavaScript values.  This can be used to handle binary data stored in
+files, or received from network connections or other sources.
+
+## Install
+    npm install jspack
+
+## Reference
+
+The module defines the following functions:
+
+### Unpack(fmt, a, p)
+Return an array containing values unpacked from the octet array a,
+beginning at position p, according to the supplied format string.  If there
+are more octets in a than required by the format string, the excess is
+ignored.  If there are fewer octets than required, Unpack() will return
+undefined.  If no value is supplied for the p argument, zero is assumed.
+
+### PackTo(fmt, a, p, values)
+Pack and store the values array into the supplied octet array a, beginning
+at position p.  If there are more values supplied than are specified in the
+format string, the excess is ignored.  If there are fewer values supplied,
+PackTo() will return false.  If there is insufficient space in a to store
+the packed values, PackTo() will return false.  On success, PackTo() returns
+the a argument. If any value is of an inappropriate type, the results are
+undefined.
+
+### Pack(fmt, values)
+Return an octet array containing the packed values array.  If there are
+more values supplied than are specified in the format string, the excess is
+ignored.  If there are fewer values supplied, Pack() will return false.  If
+any value is of an inappropriate type, the results are undefined.
+
+### CalcLength(fmt)
+Return the number of octets required to store the given format string.
+
+
+## Formats
+Format characters have the following meanings; the conversion between C and
+JavaScript values should be obvious given their types:
+
+    Format | C Type         | JavaScript Type   | Size (octets) | Notes
+    -------------------------------------------------------------------
+       A   | char[]         | Array             |     Length     |  (1)
+       x   | pad byte       | N/A               |        1       |
+       c   | char           | string (length 1) |        1       |  (2)
+       b   | signed char    | number            |        1       |  (3)
+       B   | unsigned char  | number            |        1       |  (3)
+       h   | signed short   | number            |        2       |  (3)
+       H   | unsigned short | number            |        2       |  (3)
+       i   | signed int     | number            |        4       |  (3)
+       I   | unsigned int   | number            |        4       |  (3)
+       l   | signed long    | number            |        4       |  (3)
+       L   | unsigned long  | number            |        4       |  (3)
+       q   | signed long    | number            |        8       |  (6)
+       Q   | unsigned long  | number            |        8       |  (6)
+       s   | char[]         | string            |     Length     |  (2)
+       f   | float          | number            |        4       |  (4)
+       d   | double         | number            |        8       |  (5)
+
+*Notes:*
+
+  **(1)** The "A" code simply returns a slice of the source octet array.  This is
+  primarily useful when a data structure contains bytes which are subject to
+  multiple intepretations (e.g. unions), and the data structure is being
+  decoded in multiple passes.
+
+  **(2)** The "c" and "s" codes handle strings with codepoints between 0 and 255,
+  inclusive.  The data are not bounds-checked, so strings containing  characters
+  with codepoints outside this range will encode to "octet" arrays that contain
+  values outside the range of an octet.  Furthermore, since these codes decode
+  octet arrays by assuming the octets represent UNICODE codepoints, they may
+  not "correctly" decode bytes in the range 128-255, since that range is subject
+  to multiple interpretations.  Caveat coder!
+
+  **(3)** The 8 "integer" codes clip their encoded values to the minima and maxmima
+  of their respective types:  If you invoke Struct.Pack('b', [-129]), for
+  instance, the result will be [128], which is the octet encoding of -128,
+  which is the minima of a signed char.  Similarly, Struct.Pack('h', [-32769])
+  returns [128, 0].  Fractions are truncated.
+
+  **(4)** Since JavaScript doesn't natively support 32-bit floats, whenever a float
+  is stored, the source JavaScript number must be rounded.  This module applies
+  correct rounding during this process.  Numbers with magnitude greater than or
+  equal to 2^128-2^103 round to either positive or negative Infinity. The
+  rounding algorithm assumes that JavsScript is using exactly 64 bits of
+  floating point precision; 128-bit floating point will result in subtle errors.
+
+  **(5)** This module assumes that JavaScript is using 64 bits of floating point
+  precision, so the "d" code performs no rounding.  128-bit floating point will
+  cause the "d" code to simply truncate significands to 52 bits.
+
+  **(6)** Since 64bit longs cannot be represented by numbers JavaScript, this version of
+  jspack will process longs as arrays in the form: ```[lowBits, hightBits]```. The
+  decoded long array contains a third element, the unsigned flag, which is ```false``` for signed
+  and ```true``` for unsigned values.
+  This representation is similar to what [Long.js](https://github.com/dcodeIO/Long.js), and
+  therefore the [Google Closure Libaray](https://github.com/google/closure-library), uses.
+  See [test/int64.js](test/int64.js) for examples how to work with Long.js.
+
+A format character may be preceded by an integral repeat count.  For example,
+the format string "4h" means exactly the same thing as "hhhh".
+
+Whitespace characters between formats are ignored; a count and its format must
+not be separated by whitespace, however.
+
+For the "A" format character, the count is interpreted as the size of the
+array, not a repeat count as for the other format characters; for example, "10A"
+means a single 10-octet array.  When packing, the Array is truncated or padded
+with 0 bytes as appropriate to make it conform to the specified length.  When
+unpacking, the resulting Array always has exactly the specified number of bytes.
+As a special case, "0A" means a single, empty Array.
+
+For the "s" format character, the count is interpreted as the size of the
+string, not a repeat count as for the other format characters; for example,
+"10s" means a single 10-byte string, while "10c" means 10 characters.  When
+packing, the string is truncated or padded with 0 bytes as appropriate to make
+it conform to the specified length.  When unpacking, the resulting string always
+has exactly the specified number of bytes.  As a special case, "0s" means a
+single, empty string (while "0c" means 0 characters).
+
+
+By default, C numbers are represented in network (or big-endian) byte order.
+Alternatively, the first character of the format string can be used to indicate
+byte order of the packed data, according to the following table:
+
+    Character | Byte Order
+    ----------------------------------
+        <     | little-endian
+        >     | big-endian
+        !     | network (= big-endian)
+
+If the first character is not one of these, "!" is assumed.