├── .github
    └── workflows
    │   └── githubci.yml
├── .gitignore
├── Adafruit_Sensor.cpp
├── Adafruit_Sensor.h
├── LICENSE.txt
├── README.md
├── examples
    └── sensortest
    │   └── sensortest.ino
└── library.properties


/.github/workflows/githubci.yml:
--------------------------------------------------------------------------------
 1 | name: Arduino Library CI
 2 | 
 3 | on: [pull_request, push, repository_dispatch]
 4 | 
 5 | jobs:
 6 |   build:
 7 |     runs-on: ubuntu-latest
 8 |     
 9 |     steps:
10 |     - uses: actions/setup-python@v4
11 |       with:
12 |         python-version: '3.x'
13 |     - uses: actions/checkout@v3
14 |     - uses: actions/checkout@v3
15 |       with:
16 |          repository: adafruit/ci-arduino
17 |          path: ci
18 | 
19 |     - name: pre-install
20 |       run: bash ci/actions_install.sh
21 | 
22 |     # manually install ADXL343
23 |     - name: extra libraries
24 |       run: |
25 |         export PATH=$PATH:$GITHUB_WORKSPACE/bin
26 |         arduino-cli lib install "Adafruit ADXL343"
27 | 
28 |     - name: test platforms
29 |       run: python3 ci/build_platform.py main_platforms
30 | 
31 |     - name: clang
32 |       run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r . 
33 | 
34 |     - name: doxygen
35 |       env:
36 |         GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }}
37 |         PRETTYNAME : "Adafruit Unified Sensor Library"
38 |       run: bash ci/doxy_gen_and_deploy.sh
39 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | #
  2 | # NOTE! Don't add files that are generated in specific
  3 | # subdirectories here. Add them in the ".gitignore" file
  4 | # in that subdirectory instead.
  5 | #
  6 | # NOTE! Please use 'git ls-files -i --exclude-standard'
  7 | # command after changing this file, to see if there are
  8 | # any tracked files which get ignored after the change.
  9 | #
 10 | # Normal rules
 11 | #
 12 | .*
 13 | *.o
 14 | *.o.*
 15 | *.a
 16 | *.s
 17 | *.ko
 18 | *.so
 19 | *.so.dbg
 20 | *.mod.c
 21 | *.i
 22 | *.lst
 23 | *.symtypes
 24 | *.order
 25 | modules.builtin
 26 | *.elf
 27 | *.bin
 28 | *.gz
 29 | *.bz2
 30 | *.lzma
 31 | *.patch
 32 | *.gcno
 33 | 
 34 | #
 35 | # Top-level generic files
 36 | #
 37 | /tags
 38 | /TAGS
 39 | /linux
 40 | /vmlinux
 41 | /vmlinuz
 42 | /System.map
 43 | /Module.markers
 44 | /Module.symvers
 45 | 
 46 | #
 47 | # git files that we don't want to ignore even it they are dot-files
 48 | #
 49 | !.gitignore
 50 | !.mailmap
 51 | 
 52 | #
 53 | # Generated include files
 54 | #
 55 | include/config
 56 | include/linux/version.h
 57 | include/generated
 58 | 
 59 | # stgit generated dirs
 60 | patches-*
 61 | 
 62 | # quilt's files
 63 | patches
 64 | series
 65 | 
 66 | # cscope files
 67 | cscope.*
 68 | ncscope.*
 69 | 
 70 | # gnu global files
 71 | GPATH
 72 | GRTAGS
 73 | GSYMS
 74 | GTAGS
 75 | 
 76 | # QT-Creator files
 77 | Makefile.am.user
 78 | *.config
 79 | *.creator
 80 | *.creator.user
 81 | *.files
 82 | *.includes
 83 | 
 84 | *.orig
 85 | *~
 86 | \#*#
 87 | *.lo
 88 | *.la
 89 | Makefile
 90 | Makefile.in
 91 | aclocal.m4
 92 | autoconfig.h
 93 | autoconfig.h.in
 94 | autom4te.cache/
 95 | build-aux/
 96 | config.log
 97 | config.status
 98 | configure
 99 | libtool
100 | libupnp.pc
101 | m4/libtool.m4
102 | m4/ltoptions.m4
103 | m4/ltsugar.m4
104 | m4/ltversion.m4
105 | m4/lt~obsolete.m4
106 | stamp-h1
107 | docs/doxygen
108 | 
109 | 


--------------------------------------------------------------------------------
/Adafruit_Sensor.cpp:
--------------------------------------------------------------------------------
  1 | #include "Adafruit_Sensor.h"
  2 | 
  3 | /**************************************************************************/
  4 | /*!
  5 |     @brief  Prints sensor information to serial console
  6 | */
  7 | /**************************************************************************/
  8 | void Adafruit_Sensor::printSensorDetails(void) {
  9 |   sensor_t sensor;
 10 |   getSensor(&sensor);
 11 |   Serial.println(F("------------------------------------"));
 12 |   Serial.print(F("Sensor:       "));
 13 |   Serial.println(sensor.name);
 14 |   Serial.print(F("Type:         "));
 15 |   switch ((sensors_type_t)sensor.type) {
 16 |   case SENSOR_TYPE_ACCELEROMETER:
 17 |     Serial.print(F("Acceleration (m/s2)"));
 18 |     break;
 19 |   case SENSOR_TYPE_MAGNETIC_FIELD:
 20 |     Serial.print(F("Magnetic (uT)"));
 21 |     break;
 22 |   case SENSOR_TYPE_ORIENTATION:
 23 |     Serial.print(F("Orientation (degrees)"));
 24 |     break;
 25 |   case SENSOR_TYPE_GYROSCOPE:
 26 |     Serial.print(F("Gyroscopic (rad/s)"));
 27 |     break;
 28 |   case SENSOR_TYPE_LIGHT:
 29 |     Serial.print(F("Light (lux)"));
 30 |     break;
 31 |   case SENSOR_TYPE_PRESSURE:
 32 |     Serial.print(F("Pressure (hPa)"));
 33 |     break;
 34 |   case SENSOR_TYPE_PROXIMITY:
 35 |     Serial.print(F("Distance (cm)"));
 36 |     break;
 37 |   case SENSOR_TYPE_GRAVITY:
 38 |     Serial.print(F("Gravity (m/s2)"));
 39 |     break;
 40 |   case SENSOR_TYPE_LINEAR_ACCELERATION:
 41 |     Serial.print(F("Linear Acceleration (m/s2)"));
 42 |     break;
 43 |   case SENSOR_TYPE_ROTATION_VECTOR:
 44 |     Serial.print(F("Rotation vector"));
 45 |     break;
 46 |   case SENSOR_TYPE_RELATIVE_HUMIDITY:
 47 |     Serial.print(F("Relative Humidity (%)"));
 48 |     break;
 49 |   case SENSOR_TYPE_AMBIENT_TEMPERATURE:
 50 |     Serial.print(F("Ambient Temp (C)"));
 51 |     break;
 52 |   case SENSOR_TYPE_OBJECT_TEMPERATURE:
 53 |     Serial.print(F("Object Temp (C)"));
 54 |     break;
 55 |   case SENSOR_TYPE_VOLTAGE:
 56 |     Serial.print(F("Voltage (V)"));
 57 |     break;
 58 |   case SENSOR_TYPE_CURRENT:
 59 |     Serial.print(F("Current (mA)"));
 60 |     break;
 61 |   case SENSOR_TYPE_COLOR:
 62 |     Serial.print(F("Color (RGBA)"));
 63 |     break;
 64 |   case SENSOR_TYPE_TVOC:
 65 |     Serial.print(F("Total Volatile Organic Compounds (ppb)"));
 66 |     break;
 67 |   case SENSOR_TYPE_VOC_INDEX:
 68 |     Serial.print(F("Volatile Organic Compounds (Index)"));
 69 |     break;
 70 |   case SENSOR_TYPE_NOX_INDEX:
 71 |     Serial.print(F("Nitrogen Oxides (Index)"));
 72 |     break;
 73 |   case SENSOR_TYPE_CO2:
 74 |     Serial.print(F("Carbon Dioxide (ppm)"));
 75 |     break;
 76 |   case SENSOR_TYPE_ECO2:
 77 |     Serial.print(F("Equivalent/estimated CO2 (ppm)"));
 78 |     break;
 79 |   case SENSOR_TYPE_PM10_STD:
 80 |     Serial.print(F("Standard Particulate Matter 1.0 (ppm)"));
 81 |     break;
 82 |   case SENSOR_TYPE_PM25_STD:
 83 |     Serial.print(F("Standard Particulate Matter 2.5 (ppm)"));
 84 |     break;
 85 |   case SENSOR_TYPE_PM100_STD:
 86 |     Serial.print(F("Standard Particulate Matter 10.0 (ppm)"));
 87 |     break;
 88 |   case SENSOR_TYPE_PM10_ENV:
 89 |     Serial.print(F("Environmental Particulate Matter 1.0 (ppm)"));
 90 |     break;
 91 |   case SENSOR_TYPE_PM25_ENV:
 92 |     Serial.print(F("Environmental Particulate Matter 2.5 (ppm)"));
 93 |     break;
 94 |   case SENSOR_TYPE_PM100_ENV:
 95 |     Serial.print(F("Environmental Particulate Matter 10.0 (ppm)"));
 96 |     break;
 97 |   case SENSOR_TYPE_GAS_RESISTANCE:
 98 |     Serial.print(F("Gas Resistance (ohms)"));
 99 |     break;
100 |   case SENSOR_TYPE_UNITLESS_PERCENT:
101 |     Serial.print(F("Unitless Percent (%)"));
102 |     break;
103 |   case SENSOR_TYPE_ALTITUDE:
104 |     Serial.print(F("Altitude (m)"));
105 |     break;
106 |   }
107 | 
108 |   Serial.println();
109 |   Serial.print(F("Driver Ver:   "));
110 |   Serial.println(sensor.version);
111 |   Serial.print(F("Unique ID:    "));
112 |   Serial.println(sensor.sensor_id);
113 |   Serial.print(F("Min Value:    "));
114 |   Serial.println(sensor.min_value);
115 |   Serial.print(F("Max Value:    "));
116 |   Serial.println(sensor.max_value);
117 |   Serial.print(F("Resolution:   "));
118 |   Serial.println(sensor.resolution);
119 |   Serial.println(F("------------------------------------\n"));
120 | }
121 | 


--------------------------------------------------------------------------------
/Adafruit_Sensor.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (C) 2008 The Android Open Source Project
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  * http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software< /span>
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /* Update by K. Townsend (Adafruit Industries) for lighter typedefs, and
 18 |  * extended sensor support to include color, voltage and current */
 19 | 
 20 | #ifndef _ADAFRUIT_SENSOR_H
 21 | #define _ADAFRUIT_SENSOR_H
 22 | 
 23 | #ifndef ARDUINO
 24 | #include <stdint.h>
 25 | #elif ARDUINO >= 100
 26 | #include "Arduino.h"
 27 | #include "Print.h"
 28 | #else
 29 | #include "WProgram.h"
 30 | #endif
 31 | 
 32 | /* Constants */
 33 | #define SENSORS_GRAVITY_EARTH (9.80665F) /**< Earth's gravity in m/s^2 */
 34 | #define SENSORS_GRAVITY_MOON (1.6F)      /**< The moon's gravity in m/s^2 */
 35 | #define SENSORS_GRAVITY_SUN (275.0F)     /**< The sun's gravity in m/s^2 */
 36 | #define SENSORS_GRAVITY_STANDARD (SENSORS_GRAVITY_EARTH)
 37 | #define SENSORS_MAGFIELD_EARTH_MAX                                             \
 38 |   (60.0F) /**< Maximum magnetic field on Earth's surface */
 39 | #define SENSORS_MAGFIELD_EARTH_MIN                                             \
 40 |   (30.0F) /**< Minimum magnetic field on Earth's surface */
 41 | #define SENSORS_PRESSURE_SEALEVELHPA                                           \
 42 |   (1013.25F) /**< Average sea level pressure is 1013.25 hPa */
 43 | #define SENSORS_DPS_TO_RADS                                                    \
 44 |   (0.017453293F) /**< Degrees/s to rad/s multiplier                            \
 45 |                   */
 46 | #define SENSORS_RADS_TO_DPS                                                    \
 47 |   (57.29577793F) /**< Rad/s to degrees/s  multiplier */
 48 | #define SENSORS_GAUSS_TO_MICROTESLA                                            \
 49 |   (100) /**< Gauss to micro-Tesla multiplier */
 50 | 
 51 | /** Sensor types */
 52 | typedef enum {
 53 |   SENSOR_TYPE_ACCELEROMETER = (1), /**< Gravity + linear acceleration */
 54 |   SENSOR_TYPE_MAGNETIC_FIELD = (2),
 55 |   SENSOR_TYPE_ORIENTATION = (3),
 56 |   SENSOR_TYPE_GYROSCOPE = (4),
 57 |   SENSOR_TYPE_LIGHT = (5),
 58 |   SENSOR_TYPE_PRESSURE = (6),
 59 |   SENSOR_TYPE_PROXIMITY = (8),
 60 |   SENSOR_TYPE_GRAVITY = (9),
 61 |   SENSOR_TYPE_LINEAR_ACCELERATION =
 62 |       (10), /**< Acceleration not including gravity */
 63 |   SENSOR_TYPE_ROTATION_VECTOR = (11),
 64 |   SENSOR_TYPE_RELATIVE_HUMIDITY = (12),
 65 |   SENSOR_TYPE_AMBIENT_TEMPERATURE = (13),
 66 |   SENSOR_TYPE_OBJECT_TEMPERATURE = (14),
 67 |   SENSOR_TYPE_VOLTAGE = (15),
 68 |   SENSOR_TYPE_CURRENT = (16),
 69 |   SENSOR_TYPE_COLOR = (17),
 70 |   SENSOR_TYPE_TVOC = (18),
 71 |   SENSOR_TYPE_VOC_INDEX = (19),
 72 |   SENSOR_TYPE_NOX_INDEX = (20),
 73 |   SENSOR_TYPE_CO2 = (21),
 74 |   SENSOR_TYPE_ECO2 = (22),
 75 |   SENSOR_TYPE_PM10_STD = (23),
 76 |   SENSOR_TYPE_PM25_STD = (24),
 77 |   SENSOR_TYPE_PM100_STD = (25),
 78 |   SENSOR_TYPE_PM10_ENV = (26),
 79 |   SENSOR_TYPE_PM25_ENV = (27),
 80 |   SENSOR_TYPE_PM100_ENV = (28),
 81 |   SENSOR_TYPE_GAS_RESISTANCE = (29),
 82 |   SENSOR_TYPE_UNITLESS_PERCENT = (30),
 83 |   SENSOR_TYPE_ALTITUDE = (31)
 84 | } sensors_type_t;
 85 | 
 86 | /** struct sensors_vec_s is used to return a vector in a common format. */
 87 | typedef struct {
 88 |   union {
 89 |     float v[3]; ///< 3D vector elements
 90 |     struct {
 91 |       float x; ///< X component of vector
 92 |       float y; ///< Y component of vector
 93 |       float z; ///< Z component of vector
 94 |     };         ///< Struct for holding XYZ component
 95 |     /* Orientation sensors */
 96 |     struct {
 97 |       float roll; /**< Rotation around the longitudinal axis (the plane body, 'X
 98 |                      axis'). Roll is positive and increasing when moving
 99 |                      downward. -90 degrees <= roll <= 90 degrees */
100 |       float pitch;   /**< Rotation around the lateral axis (the wing span, 'Y
101 |                         axis'). Pitch is positive and increasing when moving
102 |                         upwards. -180 degrees <= pitch <= 180 degrees) */
103 |       float heading; /**< Angle between the longitudinal axis (the plane body)
104 |                         and magnetic north, measured clockwise when viewing from
105 |                         the top of the device. 0-359 degrees */
106 |     };               ///< Struct for holding roll/pitch/heading
107 |   };                 ///< Union that can hold 3D vector array, XYZ components or
108 |                      ///< roll/pitch/heading
109 |   int8_t status;     ///< Status byte
110 |   uint8_t reserved[3]; ///< Reserved
111 | } sensors_vec_t;
112 | 
113 | /** struct sensors_color_s is used to return color data in a common format. */
114 | typedef struct {
115 |   union {
116 |     float c[3]; ///< Raw 3-element data
117 |     /* RGB color space */
118 |     struct {
119 |       float r;   /**< Red component */
120 |       float g;   /**< Green component */
121 |       float b;   /**< Blue component */
122 |     };           ///< RGB data in floating point notation
123 |   };             ///< Union of various ways to describe RGB colorspace
124 |   uint32_t rgba; /**< 24-bit RGBA value */
125 | } sensors_color_t;
126 | 
127 | /* Sensor event (36 bytes) */
128 | /** struct sensor_event_s is used to provide a single sensor event in a common
129 |  * format. */
130 | typedef struct {
131 |   int32_t version;   /**< must be sizeof(struct sensors_event_t) */
132 |   int32_t sensor_id; /**< unique sensor identifier */
133 |   int32_t type;      /**< sensor type */
134 |   int32_t reserved0; /**< reserved */
135 |   int32_t timestamp; /**< time is in milliseconds */
136 |   union {
137 |     float data[4];              ///< Raw data */
138 |     sensors_vec_t acceleration; /**< acceleration values are in meter per second
139 |                                    per second (m/s^2) */
140 |     sensors_vec_t
141 |         magnetic; /**< magnetic vector values are in micro-Tesla (uT) */
142 |     sensors_vec_t orientation; /**< orientation values are in degrees */
143 |     sensors_vec_t gyro;        /**< gyroscope values are in rad/s */
144 |     float temperature; /**< temperature is in degrees centigrade (Celsius) */
145 |     float distance;    /**< distance in centimeters */
146 |     float light;       /**< light in SI lux units */
147 |     float pressure;    /**< pressure in hectopascal (hPa) */
148 |     float relative_humidity; /**< relative humidity in percent */
149 |     float current;           /**< current in milliamps (mA) */
150 |     float voltage;           /**< voltage in volts (V) */
151 |     float tvoc;              /**< Total Volatile Organic Compounds, in ppb */
152 |     float voc_index; /**< VOC (Volatile Organic Compound) index where 100 is
153 |                           normal (unitless) */
154 |     float nox_index; /**< NOx (Nitrogen Oxides) index where 1 is normal
155 |                           (unitless) */
156 |     float CO2;       /**< Measured CO2 in parts per million (ppm) */
157 |     float eCO2;      /**< equivalent/estimated CO2 in parts per million (ppm
158 |                         estimated from some other measurement) */
159 |     float pm10_std;  /**< Standard Particulate Matter <=1.0 in parts per million
160 |                         (ppm) */
161 |     float pm25_std;  /**< Standard Particulate Matter <=2.5 in parts per million
162 |                         (ppm) */
163 |     float pm100_std; /**< Standard Particulate Matter <=10.0 in parts per
164 |                         million (ppm) */
165 |     float pm10_env;  /**< Environmental Particulate Matter <=1.0 in parts per
166 |                         million (ppm) */
167 |     float pm25_env;  /**< Environmental Particulate Matter <=2.5 in parts per
168 |                         million (ppm) */
169 |     float pm100_env; /**< Environmental Particulate Matter <=10.0 in parts per
170 |                         million (ppm) */
171 |     float gas_resistance;   /**< Proportional to the amount of VOC particles in
172 |                                the air (Ohms) */
173 |     float unitless_percent; /**<Percentage, unit-less (%) */
174 |     sensors_color_t color;  /**< color in RGB component values */
175 |     float altitude; /**< Distance between a reference datum and a point or
176 |                        object, in meters. */
177 |   };                ///< Union for the wide ranges of data we can carry
178 | } sensors_event_t;
179 | 
180 | /* Sensor details (40 bytes) */
181 | /** struct sensor_s is used to describe basic information about a specific
182 |  * sensor. */
183 | typedef struct {
184 |   char name[12];     /**< sensor name */
185 |   int32_t version;   /**< version of the hardware + driver */
186 |   int32_t sensor_id; /**< unique sensor identifier */
187 |   int32_t type;      /**< this sensor's type (ex. SENSOR_TYPE_LIGHT) */
188 |   float max_value;   /**< maximum value of this sensor's value in SI units */
189 |   float min_value;   /**< minimum value of this sensor's value in SI units */
190 |   float resolution; /**< smallest difference between two values reported by this
191 |                        sensor */
192 |   int32_t min_delay; /**< min delay in microseconds between events. zero = not a
193 |                         constant rate */
194 | } sensor_t;
195 | 
196 | /** @brief Common sensor interface to unify various sensors.
197 |  * Intentionally modeled after sensors.h in the Android API:
198 |  * https://github.com/android/platform_hardware_libhardware/blob/master/include/hardware/sensors.h
199 |  */
200 | class Adafruit_Sensor {
201 | public:
202 |   // Constructor(s)
203 |   Adafruit_Sensor() {}
204 |   virtual ~Adafruit_Sensor() {}
205 | 
206 |   // These must be defined by the subclass
207 | 
208 |   /*! @brief Whether we should automatically change the range (if possible) for
209 |      higher precision
210 |       @param enabled True if we will try to autorange */
211 |   virtual void enableAutoRange(bool enabled) {
212 |     (void)enabled; /* suppress unused warning */
213 |   };
214 | 
215 |   /*! @brief Get the latest sensor event
216 |       @returns True if able to fetch an event */
217 |   virtual bool getEvent(sensors_event_t *) = 0;
218 |   /*! @brief Get info about the sensor itself */
219 |   virtual void getSensor(sensor_t *) = 0;
220 | 
221 |   void printSensorDetails(void);
222 | };
223 | 
224 | #endif
225 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Adafruit Unified Sensor Driver #
  2 | 
  3 | Many small embedded systems exist to collect data from sensors, analyse the data, and either take an appropriate action or send that sensor data to another system for processing.
  4 | 
  5 | One of the many challenges of embedded systems design is the fact that parts you used today may be out of production tomorrow, or system requirements may change and you may need to choose a different sensor down the road.
  6 | 
  7 | Creating new drivers is a relatively easy task, but integrating them into existing systems is both error prone and time consuming since sensors rarely use the exact same units of measurement.
  8 | 
  9 | By reducing all data to a single **sensors\_event\_t** 'type' and settling on specific, **standardised SI units** for each sensor family the same sensor types return values that are comparable with any other similar sensor.  This enables you to switch sensor models with very little impact on the rest of the system, which can help mitigate some of the risks and problems of sensor availability and code reuse.
 10 | 
 11 | The unified sensor abstraction layer is also useful for data-logging and data-transmission since you only have one well-known type to log or transmit over the air or wire.
 12 | 
 13 | ## Unified Sensor Drivers ##
 14 | 
 15 | The following drivers are based on the Adafruit Unified Sensor Driver:
 16 | 
 17 | **Accelerometers**
 18 |   - [Adafruit\_ADXL345](https://github.com/adafruit/Adafruit_ADXL345)
 19 |   - [Adafruit\_LSM303DLHC](https://github.com/adafruit/Adafruit_LSM303DLHC)
 20 |   - [Adafruit\_MMA8451\_Library](https://github.com/adafruit/Adafruit_MMA8451_Library)
 21 | 
 22 | **Gyroscope**
 23 |   - [Adafruit\_L3GD20\_U](https://github.com/adafruit/Adafruit_L3GD20_U)
 24 | 
 25 | **Light**
 26 |   - [Adafruit\_TSL2561](https://github.com/adafruit/Adafruit_TSL2561)
 27 |   - [Adafruit\_TSL2591\_Library](https://github.com/adafruit/Adafruit_TSL2591_Library)
 28 | 
 29 | **Magnetometers**
 30 |   - [Adafruit\_LSM303DLHC](https://github.com/adafruit/Adafruit_LSM303DLHC)
 31 |   - [Adafruit\_HMC5883\_Unified](https://github.com/adafruit/Adafruit_HMC5883_Unified)
 32 |   
 33 | **Barometric Pressure**
 34 |   - [Adafruit\_BMP085\_Unified](https://github.com/adafruit/Adafruit_BMP085_Unified)
 35 |   - [Adafruit\_BMP183\_Unified\_Library](https://github.com/adafruit/Adafruit_BMP183_Unified_Library)
 36 | 
 37 | **Humidity & Temperature**
 38 |   - [DHT-sensor-library](https://github.com/adafruit/DHT-sensor-library)
 39 | 
 40 | **Humidity, Temperature, & Barometric Pressure**
 41 |   - [Adafruit_BME280_Library](https://github.com/adafruit/Adafruit_BME280_Library/)
 42 | 
 43 | **Orientation**
 44 |  - [Adafruit_BNO055](https://github.com/adafruit/Adafruit_BNO055)
 45 | 
 46 | **All in one device**
 47 | - [Adafruit_LSM9DS0](https://github.com/adafruit/Adafruit_LSM9DS0_Library) (accelerometer, gyroscope, magnetometer)
 48 | - [Adafruit_LSM9DS1](https://github.com/adafruit/Adafruit_LSM9DS1/) (accelerometer, gyroscope, magnetometer)
 49 | 
 50 | 
 51 | ## How Does it Work? ##
 52 | 
 53 | Any driver that supports the Adafruit unified sensor abstraction layer will implement the Adafruit\_Sensor base class.  There are two main typedefs and one enum defined in Adafruit_Sensor.h that are used to 'abstract' away the sensor details and values:
 54 | 
 55 | ## Sensor Types (`sensors_type_t`)
 56 | 
 57 | These pre-defined sensor types are used to properly handle the two related typedefs below, and allows us determine what types of units the sensor uses, etc.
 58 | 
 59 | ```c++
 60 | /** Sensor types */
 61 | typedef enum
 62 | {
 63 |   SENSOR_TYPE_ACCELEROMETER         = (1),
 64 |   SENSOR_TYPE_MAGNETIC_FIELD        = (2),
 65 |   SENSOR_TYPE_ORIENTATION           = (3),
 66 |   SENSOR_TYPE_GYROSCOPE             = (4),
 67 |   SENSOR_TYPE_LIGHT                 = (5),
 68 |   SENSOR_TYPE_PRESSURE              = (6),
 69 |   SENSOR_TYPE_PROXIMITY             = (8),
 70 |   SENSOR_TYPE_GRAVITY               = (9),
 71 |   SENSOR_TYPE_LINEAR_ACCELERATION   = (10),
 72 |   SENSOR_TYPE_ROTATION_VECTOR       = (11),
 73 |   SENSOR_TYPE_RELATIVE_HUMIDITY     = (12),
 74 |   SENSOR_TYPE_AMBIENT_TEMPERATURE   = (13),
 75 |   SENSOR_TYPE_VOLTAGE               = (15),
 76 |   SENSOR_TYPE_CURRENT               = (16),
 77 |   SENSOR_TYPE_COLOR                 = (17),
 78 |   SENSOR_TYPE_TVOC                  = (18),
 79 |   SENSOR_TYPE_VOC_INDEX             = (19),
 80 |   SENSOR_TYPE_NOX_INDEX             = (20),
 81 |   SENSOR_TYPE_CO2                   = (21),
 82 |   SENSOR_TYPE_ECO2                  = (22),
 83 |   SENSOR_TYPE_PM10_STD              = (23),
 84 |   SENSOR_TYPE_PM25_STD              = (24),
 85 |   SENSOR_TYPE_PM100_STD             = (25),
 86 |   SENSOR_TYPE_PM10_ENV              = (26),
 87 |   SENSOR_TYPE_PM25_ENV              = (27),
 88 |   SENSOR_TYPE_PM100_ENV             = (28),
 89 |   SENSOR_TYPE_GAS_RESISTANCE        = (29),
 90 |   SENSOR_TYPE_UNITLESS_PERCENT      = (30),
 91 |   SENSOR_TYPE_ALTITUDE              = (31),
 92 | } sensors_type_t;
 93 | ```
 94 | 
 95 | ## Sensor Details (`sensor_t`)
 96 | 
 97 | This typedef describes the specific capabilities of this sensor, and allows us to know what sensor we are using beneath the abstraction layer.
 98 | 
 99 | ```c++
100 | /* Sensor details (40 bytes) */
101 | /** struct sensor_s is used to describe basic information about a specific sensor. */
102 | typedef struct
103 | {
104 |     char     name[12];
105 |     int32_t  version;
106 |     int32_t  sensor_id;
107 |     int32_t  type;
108 |     float    max_value;
109 |     float    min_value;
110 |     float    resolution;
111 |     int32_t  min_delay;
112 | } sensor_t;
113 | ```
114 | 
115 | The individual fields are intended to be used as follows:
116 | 
117 | - **name**: The sensor name or ID, up to a maximum of twelve characters (ex. "MPL115A2")
118 | - **version**: The version of the sensor HW and the driver to allow us to differentiate versions of the board or driver
119 | - **sensor\_id**: A unique sensor identifier that is used to differentiate this specific sensor instance from any others that are present on the system or in the sensor network
120 | - **type**: The sensor type, based on **sensors\_type\_t** in sensors.h
121 | - **max\_value**: The maximum value that this sensor can return (in the appropriate SI unit)
122 | - **min\_value**: The minimum value that this sensor can return (in the appropriate SI unit)
123 | - **resolution**: The smallest difference between two values that this sensor can report (in the appropriate SI unit)
124 | - **min\_delay**: The minimum delay in microseconds between two sensor events, or '0' if there is no constant sensor rate
125 | 
126 | ## Sensor Data/Events (`sensors_event_t`)
127 | 
128 | This typedef is used to return sensor data from any sensor supported by the abstraction layer, using standard SI units and scales.
129 | 
130 | ```c++
131 | /* Sensor event (36 bytes) */
132 | /** struct sensor_event_s is used to provide a single sensor event in a common format. */
133 | typedef struct
134 | {
135 |     int32_t version;
136 |     int32_t sensor_id;
137 |     int32_t type;
138 |     int32_t reserved0;
139 |     int32_t timestamp;
140 |     union
141 |     {
142 |         float           data[4];
143 |         sensors_vec_t   acceleration;
144 |         sensors_vec_t   magnetic;
145 |         sensors_vec_t   orientation;
146 |         sensors_vec_t   gyro;
147 |         float           temperature;
148 |         float           distance;
149 |         float           light;
150 |         float           pressure;
151 |         float           relative_humidity;
152 |         float           current;
153 |         float           voltage;
154 |         float           tvoc;
155 |         float           voc_index;
156 |         float           nox_index;
157 |         float           CO2,
158 |         float           eCO2,
159 |         float           pm10_std,
160 |         float           pm25_std,
161 |         float           pm100_std,
162 |         float           pm10_env,
163 |         float           pm25_env,
164 |         float           pm100_env,
165 |         float           gas_resistance,
166 |         float           unitless_percent,
167 |         float           altitude,
168 |         sensors_color_t color;
169 |     };
170 | } sensors_event_t;
171 | ```
172 | It includes the following fields:
173 | 
174 | - **version**: Contain 'sizeof(sensors\_event\_t)' to identify which version of the API we're using in case this changes in the future
175 | - **sensor\_id**: A unique sensor identifier that is used to differentiate this specific sensor instance from any others that are present on the system or in the sensor network (must match the sensor\_id value in the corresponding sensor\_t enum above!)
176 | - **type**: the sensor type, based on **sensors\_type\_t** in sensors.h
177 | - **timestamp**: time in milliseconds when the sensor value was read
178 | - **data[4]**: An array of four 32-bit values that allows us to encapsulate any type of sensor data via a simple union (further described below)
179 | 
180 | ## Required Functions
181 | 
182 | In addition to the two standard types and the sensor type enum, all drivers based on Adafruit_Sensor must also implement the following two functions:
183 | 
184 | ```c++
185 | bool getEvent(sensors_event_t*);
186 | ```
187 | Calling this function will populate the supplied sensors\_event\_t reference with the latest available sensor data.  You should call this function as often as you want to update your data.
188 | 
189 | ```c++
190 | void getSensor(sensor_t*);
191 | ```
192 | Calling this function will provide some basic information about the sensor (the sensor name, driver version, min and max values, etc.
193 | 
194 | ## Standardised SI values for `sensors_event_t`
195 | 
196 | A key part of the abstraction layer is the standardization of values on SI units of a particular scale, which is accomplished via the data[4] union in sensors\_event\_t above.  This 16 byte union includes fields for each main sensor type, and uses the following SI units and scales:
197 | 
198 | - **acceleration**: values are in **meter per second per second** (m/s^2)
199 | - **magnetic**: values are in **micro-Tesla** (uT)
200 | - **orientation**: values are in **degrees**
201 | - **gyro**: values are in **rad/s**
202 | - **temperature**: values in **degrees centigrade** (Celsius) 
203 | - **distance**: values are in **centimeters**
204 | - **light**: values are in **SI lux** units
205 | - **pressure**: values are in **hectopascal** (hPa)
206 | - **relative\_humidity**: values are in **percent**
207 | - **current**: values are in **milliamps** (mA)
208 | - **voltage**: values are in **volts** (V)
209 | - **color**: values are in 0..1.0 RGB channel luminosity and 32-bit RGBA format
210 | - **tvoc**: values are in **parts per billion** (ppb)
211 | - **voc_index**: values are an **index** from 1-500 with 100 being normal
212 | - **nox_index**: values are an **index** from 1-500 with 100 being normal
213 | - **CO2**: values are in **parts per million** (ppm)
214 | - **eCO2**: values are in **parts per million** (ppm)
215 | - **pm10_std**: values are in **parts per million** (ppm)
216 | - **pm25_std**: values are in **parts per million** (ppm)
217 | - **pm100_std**: values are in **parts per million** (ppm)
218 | - **pm10_env**: values are in **parts per million** (ppm)
219 | - **pm25_env**: values are in **parts per million** (ppm)
220 | - **pm100_env**: values are in **parts per million** (ppm)
221 | - **gas_resistance**: values are in **ohms**
222 | - **unitless_percent**: values are in **%**
223 | - **altitude**: values are in **meters** (m)
224 | 
225 | ## The Unified Driver Abstraction Layer in Practice ##
226 | 
227 | Using the unified sensor abstraction layer is relatively easy once a compliant driver has been created.
228 | 
229 | Every compliant sensor can now be read using a single, well-known 'type' (sensors\_event\_t), and there is a standardized way of interrogating a sensor about its specific capabilities (via sensor\_t).
230 | 
231 | An example of reading the [TSL2561](https://github.com/adafruit/Adafruit_TSL2561) light sensor can be seen below:
232 | 
233 | ```c++
234 |  Adafruit_TSL2561 tsl = Adafruit_TSL2561(TSL2561_ADDR_FLOAT, 12345);
235 |  ...
236 |  /* Get a new sensor event */ 
237 |  sensors_event_t event;
238 |  tsl.getEvent(&event);
239 |  
240 |  /* Display the results (light is measured in lux) */
241 |  if (event.light)
242 |  {
243 |    Serial.print(event.light); Serial.println(" lux");
244 |  }
245 |  else
246 |  {
247 |    /* If event.light = 0 lux the sensor is probably saturated
248 |       and no reliable data could be generated! */
249 |    Serial.println("Sensor overload");
250 |  }
251 | ```
252 | 
253 | Similarly, we can get the basic technical capabilities of this sensor with the following code:
254 | 
255 | ```c++
256 |  sensor_t sensor;
257 |  
258 |  sensor_t sensor;
259 |  tsl.getSensor(&sensor);
260 | 
261 |  /* Display the sensor details */
262 |  Serial.println("------------------------------------");
263 |  Serial.print  ("Sensor:       "); Serial.println(sensor.name);
264 |  Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
265 |  Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
266 |  Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" lux");
267 |  Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" lux");
268 |  Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" lux");  
269 |  Serial.println("------------------------------------");
270 |  Serial.println("");
271 | ```
272 | 


--------------------------------------------------------------------------------
/examples/sensortest/sensortest.ino:
--------------------------------------------------------------------------------
  1 | #include <Wire.h>
  2 | #include <Adafruit_Sensor.h>
  3 | #include <Adafruit_ADXL343.h>
  4 | 
  5 | /* Assign a unique ID to this sensor at the same time */
  6 | /* Uncomment following line for default Wire bus      */
  7 | Adafruit_ADXL343 accel = Adafruit_ADXL343(12345);
  8 | 
  9 | /* NeoTrellis M4, etc.                    */
 10 | /* Uncomment following line for Wire1 bus */
 11 | //Adafruit_ADXL343 accel = Adafruit_ADXL343(12345, &Wire1);
 12 | 
 13 | void displaySensorDetails(void)
 14 | {
 15 |   sensor_t sensor;
 16 |   accel.getSensor(&sensor);
 17 |   Serial.println("------------------------------------");
 18 |   Serial.print  ("Sensor:       "); Serial.println(sensor.name);
 19 |   Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
 20 |   Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
 21 |   Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" m/s^2");
 22 |   Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" m/s^2");
 23 |   Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" m/s^2");
 24 |   Serial.println("------------------------------------");
 25 |   Serial.println("");
 26 |   delay(500);
 27 | }
 28 | 
 29 | void displayDataRate(void)
 30 | {
 31 |   Serial.print  ("Data Rate:    ");
 32 | 
 33 |   switch(accel.getDataRate())
 34 |   {
 35 |     case ADXL343_DATARATE_3200_HZ:
 36 |       Serial.print  ("3200 ");
 37 |       break;
 38 |     case ADXL343_DATARATE_1600_HZ:
 39 |       Serial.print  ("1600 ");
 40 |       break;
 41 |     case ADXL343_DATARATE_800_HZ:
 42 |       Serial.print  ("800 ");
 43 |       break;
 44 |     case ADXL343_DATARATE_400_HZ:
 45 |       Serial.print  ("400 ");
 46 |       break;
 47 |     case ADXL343_DATARATE_200_HZ:
 48 |       Serial.print  ("200 ");
 49 |       break;
 50 |     case ADXL343_DATARATE_100_HZ:
 51 |       Serial.print  ("100 ");
 52 |       break;
 53 |     case ADXL343_DATARATE_50_HZ:
 54 |       Serial.print  ("50 ");
 55 |       break;
 56 |     case ADXL343_DATARATE_25_HZ:
 57 |       Serial.print  ("25 ");
 58 |       break;
 59 |     case ADXL343_DATARATE_12_5_HZ:
 60 |       Serial.print  ("12.5 ");
 61 |       break;
 62 |     case ADXL343_DATARATE_6_25HZ:
 63 |       Serial.print  ("6.25 ");
 64 |       break;
 65 |     case ADXL343_DATARATE_3_13_HZ:
 66 |       Serial.print  ("3.13 ");
 67 |       break;
 68 |     case ADXL343_DATARATE_1_56_HZ:
 69 |       Serial.print  ("1.56 ");
 70 |       break;
 71 |     case ADXL343_DATARATE_0_78_HZ:
 72 |       Serial.print  ("0.78 ");
 73 |       break;
 74 |     case ADXL343_DATARATE_0_39_HZ:
 75 |       Serial.print  ("0.39 ");
 76 |       break;
 77 |     case ADXL343_DATARATE_0_20_HZ:
 78 |       Serial.print  ("0.20 ");
 79 |       break;
 80 |     case ADXL343_DATARATE_0_10_HZ:
 81 |       Serial.print  ("0.10 ");
 82 |       break;
 83 |     default:
 84 |       Serial.print  ("???? ");
 85 |       break;
 86 |   }
 87 |   Serial.println(" Hz");
 88 | }
 89 | 
 90 | void displayRange(void)
 91 | {
 92 |   Serial.print  ("Range:         +/- ");
 93 | 
 94 |   switch(accel.getRange())
 95 |   {
 96 |     case ADXL343_RANGE_16_G:
 97 |       Serial.print  ("16 ");
 98 |       break;
 99 |     case ADXL343_RANGE_8_G:
100 |       Serial.print  ("8 ");
101 |       break;
102 |     case ADXL343_RANGE_4_G:
103 |       Serial.print  ("4 ");
104 |       break;
105 |     case ADXL343_RANGE_2_G:
106 |       Serial.print  ("2 ");
107 |       break;
108 |     default:
109 |       Serial.print  ("?? ");
110 |       break;
111 |   }
112 |   Serial.println(" g");
113 | }
114 | 
115 | void setup(void)
116 | {
117 |   Serial.begin(9600);
118 |   while (!Serial);
119 |   Serial.println("Accelerometer Test"); Serial.println("");
120 | 
121 |   /* Initialise the sensor */
122 |   if(!accel.begin())
123 |   {
124 |     /* There was a problem detecting the ADXL343 ... check your connections */
125 |     Serial.println("Ooops, no ADXL343 detected ... Check your wiring!");
126 |     while(1);
127 |   }
128 | 
129 |   /* Set the range to whatever is appropriate for your project */
130 |   accel.setRange(ADXL343_RANGE_16_G);
131 |   // accel.setRange(ADXL343_RANGE_8_G);
132 |   // accel.setRange(ADXL343_RANGE_4_G);
133 |   // accel.setRange(ADXL343_RANGE_2_G);
134 | 
135 |   /* Display some basic information on this sensor */
136 |   displaySensorDetails();
137 |   displayDataRate();
138 |   displayRange();
139 |   Serial.println("");
140 | }
141 | 
142 | void loop(void)
143 | {
144 |   /* Get a new sensor event */
145 |   sensors_event_t event;
146 |   accel.getEvent(&event);
147 | 
148 |   /* Display the results (acceleration is measured in m/s^2) */
149 |   Serial.print("X: "); Serial.print(event.acceleration.x); Serial.print("  ");
150 |   Serial.print("Y: "); Serial.print(event.acceleration.y); Serial.print("  ");
151 |   Serial.print("Z: "); Serial.print(event.acceleration.z); Serial.print("  ");Serial.println("m/s^2 ");
152 |   delay(500);
153 | }
154 | 


--------------------------------------------------------------------------------
/library.properties:
--------------------------------------------------------------------------------
 1 | name=Adafruit Unified Sensor
 2 | version=1.1.15
 3 | author=Adafruit <info@adafruit.com>
 4 | maintainer=Adafruit <info@adafruit.com>
 5 | sentence=Required for all Adafruit Unified Sensor based libraries.
 6 | paragraph=A unified sensor abstraction layer used by many Adafruit sensor libraries.
 7 | category=Sensors
 8 | url=https://github.com/adafruit/Adafruit_Sensor
 9 | architectures=*
10 | includes=Adafruit_Sensor.h
11 | 
12 | 


--------------------------------------------------------------------------------