├── .gitignore ├── LICENSE ├── LeptonFLiR.cpp ├── LeptonFLiR.h ├── LeptonFLiRDefs.h ├── README.md ├── examples ├── AdvancedExample │ └── AdvancedExample.ino ├── ImageCaptureExample │ └── ImageCaptureExample.ino ├── ModuleInfo │ └── ModuleInfo.ino ├── SimpleExample │ └── SimpleExample.ino └── SoftwareI2CExample │ └── SoftwareI2CExample.ino ├── library.properties └── support files ├── FLIR_Lepton_Data_Brief.pdf ├── FLIR_Lepton_Software_Interface_Description_Document_110_0144_03.pdf ├── LeptonModule.zip └── LeptonSDKEmb32PUB.zip /.gitignore: -------------------------------------------------------------------------------- 1 | # OS generated files # 2 | ###################### 3 | .DS_Store 4 | .DS_Store? 5 | ._* 6 | .Spotlight-V100 7 | .Trashes 8 | Icon? 9 | ehthumbs.db 10 | Thumbs.db 11 | 12 | # Generic: 13 | ############### 14 | *.bak -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 NachtRaveVL 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /LeptonFLiR.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/samyk/Lepton-FLiR-Arduino/f6fab989cbc929fae7ddbe98bf2e91263e1308a2/LeptonFLiR.cpp -------------------------------------------------------------------------------- /LeptonFLiR.h: -------------------------------------------------------------------------------- 1 | /* Arduino Library for the Lepton FLiR Thermal Camera Module. 2 | Copyright (c) 2016 NachtRaveVL 3 | 4 | Permission is hereby granted, free of charge, to any person 5 | obtaining a copy of this software and associated documentation 6 | files (the "Software"), to deal in the Software without 7 | restriction, including without limitation the rights to use, 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the 10 | Software is furnished to do so, subject to the following 11 | conditions: 12 | 13 | This permission notice shall be included in all copies or 14 | substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 18 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 19 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 20 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 21 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 22 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 | OTHER DEALINGS IN THE SOFTWARE. 24 | 25 | Lepton-FLiR-Arduino - Version 0.9.91 26 | */ 27 | 28 | #ifndef LeptonFLiR_H 29 | #define LeptonFLiR_H 30 | 31 | // Library Setup 32 | 33 | // Uncomment this define to enable use of the software i2c library (min 4MHz+ processor required). 34 | //#define LEPFLIR_ENABLE_SOFTWARE_I2C 1 // http://playground.arduino.cc/Main/SoftwareI2CLibrary 35 | 36 | // Uncomment this define to disable usage of the Scheduler library on SAM/SAMD architecures. 37 | //#define LEPFLIR_DISABLE_SCHEDULER 1 // https://github.com/arduino-libraries/Scheduler 38 | 39 | // Uncomment this define to disable 16 byte aligned memory allocations (may hinder performance). 40 | //#define LEPFLIR_DISABLE_ALIGNED_MALLOC 1 41 | 42 | // Uncomment this define if wanting to exclude extended i2c functions from compilation. 43 | //#define LEPFLIR_EXCLUDE_EXT_I2C_FUNCS 1 44 | 45 | // Uncomment this define to enable debug output. 46 | //#define LEPFLIR_ENABLE_DEBUG_OUTPUT 1 47 | 48 | // Hookup Instructions 49 | // Make sure to hookup the module's SPI lines MISO, MOSI, CLK (aka SCK), and CS (aka SS) 50 | // correctly (Due, Zero, ATmega, etc. often use pins 50=MISO, 51=MOSI, 52=SCK, 53=SS, but 51 | // one can just simply use the ICSP header pins ICSP-1=MISO, ICSP-4=MOSI, ICSP-3=SCK, 52 | // which are consistent across all boards - Due boards also have a SPI header, which is 53 | // set up exactly like the ICSP header). The module's MOSI line can simply be grounded 54 | // since the module only uses SPI for slave-out data transfers (slave-in data transfers 55 | // being ignored). The SS pin may be any digital output pin, with usage being active-low. 56 | // The recommended VCC power supply and logic level is 3.3v, but 5v is also supported. 57 | // The two issolated power pins on the side of the module's breakout can safely be left 58 | // disconnected. The minimum SPI transfer rate is ~2.2MHz, which means one needs at least 59 | // an 8MHz processor, but a 16MHz processor is the recommended minimum given the actual 60 | // processing work involved to resize/BLIT the final image. The actual SPI transfer rate 61 | // selected will be the first rate equal to or below 20MHz given the SPI clock divider 62 | // (i.e. processor speed /2, /4, /8, /16, ..., /128). 63 | 64 | #if defined(ARDUINO) && ARDUINO >= 100 65 | #include 66 | #else 67 | #include 68 | #endif 69 | #ifndef LEPFLIR_ENABLE_SOFTWARE_I2C 70 | #include 71 | #endif 72 | #include 73 | #include "LeptonFLiRDefs.h" 74 | 75 | #ifndef ENABLED 76 | #define ENABLED 0x1 77 | #endif 78 | #ifndef DISABLED 79 | #define DISABLED 0x0 80 | #endif 81 | 82 | typedef enum { 83 | TelemetryData_FFCState_NeverCommanded, 84 | TelemetryData_FFCState_InProgress, 85 | TelemetryData_FFCState_Complete 86 | } TelemetryData_FFCState; 87 | 88 | typedef struct { 89 | byte revisionMajor; 90 | byte revisionMinor; 91 | uint32_t cameraUptime; // (milliseconds) 92 | bool ffcDesired; 93 | TelemetryData_FFCState ffcState; 94 | bool agcEnabled; // def:disabled 95 | bool shutdownImminent; 96 | char serialNumber[24]; 97 | char softwareRevision[12]; 98 | uint32_t frameCounter; // increments every 3rd frame, useful for determining new unique frame 99 | uint16_t frameMean; 100 | float fpaTemperature; // min:-273.15C max:382.20C (celsius), min:-459.67F max:719.96F (fahrenheit), min:0.00K max:655.35K (kelvin) 101 | float housingTemperature; // min:-273.15C max:382.20C (celsius), min:-459.67F max:719.96F (fahrenheit), min:0.00K max:655.35K (kelvin) 102 | uint32_t lastFFCTime; // (milliseconds) 103 | float fpaTempAtLastFFC; // min:-273.15C max:382.20C (celsius), min:-459.67F max:719.96F (fahrenheit), min:0.00K max:655.35K (kelvin) 104 | float housingTempAtLastFFC; // min:-273.15C max:382.20C (celsius), min:-459.67F max:719.96F (fahrenheit), min:0.00K max:655.35K (kelvin) 105 | LEP_AGC_HISTOGRAM_ROI agcRegion;// min:0,0/end>beg, max:79,59/begbeg, max:79,59/begbeg, max:79,59/begbeg+1, max:78,58/beg 3 | 4 | Permission is hereby granted, free of charge, to any person 5 | obtaining a copy of this software and associated documentation 6 | files (the "Software"), to deal in the Software without 7 | restriction, including without limitation the rights to use, 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the 10 | Software is furnished to do so, subject to the following 11 | conditions: 12 | 13 | This permission notice shall be included in all copies or 14 | substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 18 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 19 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 20 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 21 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 22 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 | OTHER DEALINGS IN THE SOFTWARE. 24 | 25 | Lepton-FLiR-Arduino - Version 0.9.91 26 | */ 27 | 28 | // The majority of this file has been cherry picked from the Lepton FLiR 29 | // development SDK to maintain consistency with the software interface 30 | // description document.The following copyright notice is hearby included: 31 | /******************************************************************************* 32 | ** 33 | ** Copyright 2011,2012,2013,2014 FLIR Systems - Commercial 34 | ** Vision Systems. All rights reserved. 35 | ** 36 | ** Proprietary - PROPRIETARY - FLIR Systems Inc.. 37 | ** 38 | ** This document is controlled to FLIR Technology Level 2. 39 | ** The information contained in this document pertains to a 40 | ** dual use product Controlled for export by the Export 41 | ** Administration Regulations (EAR). Diversion contrary to 42 | ** US law is prohibited. US Department of Commerce 43 | ** authorization is not required prior to export or 44 | ** transfer to foreign persons or parties unless otherwise 45 | ** prohibited. 46 | ** 47 | ** Redistribution and use in source and binary forms, with 48 | ** or without modification, are permitted provided that the 49 | ** following conditions are met: 50 | ** 51 | ** Redistributions of source code must retain the above 52 | ** copyright notice, this list of conditions and the 53 | ** following disclaimer. 54 | ** 55 | ** Redistributions in binary form must reproduce the above 56 | ** copyright notice, this list of conditions and the 57 | ** following disclaimer in the documentation and/or other 58 | ** materials provided with the distribution. 59 | ** 60 | ** Neither the name of the FLIR Systems Corporation nor the 61 | ** names of its contributors may be used to endorse or 62 | ** promote products derived from this software without 63 | ** specific prior written permission. 64 | ** 65 | ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 66 | ** CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 67 | ** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 68 | ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 69 | ** PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 70 | ** COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY 71 | ** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 72 | ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 73 | ** PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 74 | ** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 75 | ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 76 | ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 77 | ** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 78 | ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 79 | ** OF SUCH DAMAGE. 80 | ** 81 | *******************************************************************************/ 82 | 83 | #ifndef LeptonFLiRDefs_H 84 | #define LeptonFLiRDefs_H 85 | 86 | #define LEP_I2C_DEVICE_ADDRESS (byte)0x2A 87 | 88 | #define LEP_I2C_COMMAND_MODULE_ID_BIT_MASK (uint16_t)0x0F00 89 | #define LEP_I2C_COMMAND_ID_BIT_MASK (uint16_t)0x00FC 90 | #define LEP_I2C_COMMAND_TYPE_BIT_MASK (uint16_t)0x0003 91 | 92 | #define LEP_I2C_COMMAND_TYPE_GET (uint16_t)0x0000 93 | #define LEP_I2C_COMMAND_TYPE_SET (uint16_t)0x0001 94 | #define LEP_I2C_COMMAND_TYPE_RUN (uint16_t)0x0002 95 | 96 | #define LEP_I2C_STATUS_BUSY_BIT_MASK (uint16_t)0x0001 97 | #define LEP_I2C_STATUS_BOOT_MODE_BIT_MASK (uint16_t)0x0002 98 | #define LEP_I2C_STATUS_BOOT_STATUS_BIT_MASK (uint16_t)0x0004 99 | #define LEP_I2C_STATUS_ERROR_CODE_BIT_MASK (uint16_t)0xFF00 100 | #define LEP_I2C_STATUS_ERROR_CODE_BIT_SHIFT 8 101 | 102 | #define LEP_I2C_REG_BASE_ADDR (uint16_t)0x0000 103 | #define LEP_I2C_POWER_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0000) 104 | #define LEP_I2C_STATUS_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0002) 105 | #define LEP_I2C_COMMAND_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0004) 106 | #define LEP_I2C_DATA_LENGTH_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0006) 107 | #define LEP_I2C_DATA_0_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0008) 108 | #define LEP_I2C_DATA_1_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x000A) 109 | #define LEP_I2C_DATA_2_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x000C) 110 | #define LEP_I2C_DATA_3_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x000E) 111 | #define LEP_I2C_DATA_4_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0010) 112 | #define LEP_I2C_DATA_5_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0012) 113 | #define LEP_I2C_DATA_6_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0014) 114 | #define LEP_I2C_DATA_7_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0016) 115 | #define LEP_I2C_DATA_8_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0018) 116 | #define LEP_I2C_DATA_9_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x001A) 117 | #define LEP_I2C_DATA_10_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x001C) 118 | #define LEP_I2C_DATA_11_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x001E) 119 | #define LEP_I2C_DATA_12_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0020) 120 | #define LEP_I2C_DATA_13_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0022) 121 | #define LEP_I2C_DATA_14_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0024) 122 | #define LEP_I2C_DATA_15_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0026) 123 | #define LEP_I2C_DATA_CRC_REG (uint16_t)(LEP_I2C_REG_BASE_ADDR + 0x0028) 124 | 125 | #define LEP_I2C_DATA_BUFFER (uint16_t)0xF800 126 | #define LEP_I2C_DATA_BUFFER_LENGTH (uint16_t)0x0800 127 | 128 | #define LEP_AGC_MODULE_BASE (uint16_t)0x0100 129 | #define LEP_CID_AGC_ENABLE_STATE (uint16_t)(LEP_AGC_MODULE_BASE + 0x0000) 130 | #define LEP_CID_AGC_POLICY (uint16_t)(LEP_AGC_MODULE_BASE + 0x0004) 131 | #define LEP_CID_AGC_ROI (uint16_t)(LEP_AGC_MODULE_BASE + 0x0008) 132 | #define LEP_CID_AGC_STATISTICS (uint16_t)(LEP_AGC_MODULE_BASE + 0x000C) 133 | #define LEP_CID_AGC_HISTOGRAM_CLIP_PERCENT (uint16_t)(LEP_AGC_MODULE_BASE + 0x0010) 134 | #define LEP_CID_AGC_HISTOGRAM_TAIL_SIZE (uint16_t)(LEP_AGC_MODULE_BASE + 0x0014) 135 | #define LEP_CID_AGC_LINEAR_MAX_GAIN (uint16_t)(LEP_AGC_MODULE_BASE + 0x0018) 136 | #define LEP_CID_AGC_LINEAR_MIDPOINT (uint16_t)(LEP_AGC_MODULE_BASE + 0x001C) 137 | #define LEP_CID_AGC_LINEAR_DAMPENING_FACTOR (uint16_t)(LEP_AGC_MODULE_BASE + 0x0020) 138 | #define LEP_CID_AGC_HEQ_DAMPENING_FACTOR (uint16_t)(LEP_AGC_MODULE_BASE + 0x0024) 139 | #define LEP_CID_AGC_HEQ_MAX_GAIN (uint16_t)(LEP_AGC_MODULE_BASE + 0x0028) 140 | #define LEP_CID_AGC_HEQ_CLIP_LIMIT_HIGH (uint16_t)(LEP_AGC_MODULE_BASE + 0x002C) 141 | #define LEP_CID_AGC_HEQ_CLIP_LIMIT_LOW (uint16_t)(LEP_AGC_MODULE_BASE + 0x0030) 142 | #define LEP_CID_AGC_HEQ_BIN_EXTENSION (uint16_t)(LEP_AGC_MODULE_BASE + 0x0034) 143 | #define LEP_CID_AGC_HEQ_MIDPOINT (uint16_t)(LEP_AGC_MODULE_BASE + 0x0038) 144 | #define LEP_CID_AGC_HEQ_EMPTY_COUNTS (uint16_t)(LEP_AGC_MODULE_BASE + 0x003C) 145 | #define LEP_CID_AGC_HEQ_NORMALIZATION_FACTOR (uint16_t)(LEP_AGC_MODULE_BASE + 0x0040) 146 | #define LEP_CID_AGC_HEQ_SCALE_FACTOR (uint16_t)(LEP_AGC_MODULE_BASE + 0x0044) 147 | #define LEP_CID_AGC_CALC_ENABLE_STATE (uint16_t)(LEP_AGC_MODULE_BASE + 0x0048) 148 | 149 | typedef enum { 150 | LEP_AGC_LINEAR = 0, 151 | LEP_AGC_HEQ, 152 | } LEP_AGC_POLICY; 153 | 154 | typedef struct { 155 | uint16_t startCol; 156 | uint16_t startRow; 157 | uint16_t endCol; 158 | uint16_t endRow; 159 | } LEP_AGC_HISTOGRAM_ROI; 160 | 161 | typedef struct { 162 | uint16_t minIntensity; 163 | uint16_t maxIntensity; 164 | uint16_t meanIntensity; 165 | uint16_t numPixels; // def: 4800 166 | } LEP_AGC_HISTOGRAM_STATISTICS; 167 | 168 | typedef enum { 169 | LEP_AGC_SCALE_TO_8_BITS = 0, 170 | LEP_AGC_SCALE_TO_14_BITS 171 | } LEP_AGC_HEQ_SCALE_FACTOR; 172 | 173 | 174 | #define LEP_SYS_MODULE_BASE (uint16_t)0x0200 175 | #define LEP_CID_SYS_PING (uint16_t)(LEP_SYS_MODULE_BASE + 0x0000) 176 | #define LEP_CID_SYS_CAM_STATUS (uint16_t)(LEP_SYS_MODULE_BASE + 0x0004) 177 | #define LEP_CID_SYS_FLIR_SERIAL_NUMBER (uint16_t)(LEP_SYS_MODULE_BASE + 0x0008) 178 | #define LEP_CID_SYS_CAM_UPTIME (uint16_t)(LEP_SYS_MODULE_BASE + 0x000C) 179 | #define LEP_CID_SYS_AUX_TEMPERATURE_KELVIN (uint16_t)(LEP_SYS_MODULE_BASE + 0x0010) 180 | #define LEP_CID_SYS_FPA_TEMPERATURE_KELVIN (uint16_t)(LEP_SYS_MODULE_BASE + 0x0014) 181 | #define LEP_CID_SYS_TELEMETRY_ENABLE_STATE (uint16_t)(LEP_SYS_MODULE_BASE + 0x0018) 182 | #define LEP_CID_SYS_TELEMETRY_LOCATION (uint16_t)(LEP_SYS_MODULE_BASE + 0x001C) 183 | #define LEP_CID_SYS_EXECTUE_FRAME_AVERAGE (uint16_t)(LEP_SYS_MODULE_BASE + 0x0020) 184 | #define LEP_CID_SYS_NUM_FRAMES_TO_AVERAGE (uint16_t)(LEP_SYS_MODULE_BASE + 0x0024) 185 | #define LEP_CID_SYS_CUST_SERIAL_NUMBER (uint16_t)(LEP_SYS_MODULE_BASE + 0x0028) 186 | #define LEP_CID_SYS_SCENE_STATISTICS (uint16_t)(LEP_SYS_MODULE_BASE + 0x002C) 187 | #define LEP_CID_SYS_SCENE_ROI (uint16_t)(LEP_SYS_MODULE_BASE + 0x0030) 188 | #define LEP_CID_SYS_THERMAL_SHUTDOWN_COUNT (uint16_t)(LEP_SYS_MODULE_BASE + 0x0034) 189 | #define LEP_CID_SYS_SHUTTER_POSITION (uint16_t)(LEP_SYS_MODULE_BASE + 0x0038) 190 | #define LEP_CID_SYS_FFC_SHUTTER_MODE (uint16_t)(LEP_SYS_MODULE_BASE + 0x003C) 191 | #define LEP_CID_SYS_RUN_FFC (uint16_t)(LEP_SYS_MODULE_BASE + 0x0042) 192 | #define LEP_CID_SYS_FFC_STATUS (uint16_t)(LEP_SYS_MODULE_BASE + 0x0044) 193 | 194 | typedef enum { 195 | LEP_SYSTEM_READY = 0, 196 | LEP_SYSTEM_INITIALIZING, 197 | LEP_SYSTEM_IN_LOW_POWER_MODE, 198 | LEP_SYSTEM_GOING_INTO_STANDBY, 199 | LEP_SYSTEM_FLAT_FIELD_IN_PROCESS 200 | } LEP_SYS_CAM_STATUS_STATES; 201 | 202 | typedef struct { 203 | uint32_t camStatus; // LEP_SYS_CAM_STATUS_STATES 204 | uint16_t commandCount; 205 | uint16_t reserved; 206 | } LEP_SYS_CAM_STATUS; 207 | 208 | typedef enum { 209 | LEP_TELEMETRY_LOCATION_HEADER = 0, 210 | LEP_TELEMETRY_LOCATION_FOOTER 211 | } LEP_SYS_TELEMETRY_LOCATION; 212 | 213 | typedef enum { 214 | LEP_SYS_FA_DIV_1 = 0, 215 | LEP_SYS_FA_DIV_2, 216 | LEP_SYS_FA_DIV_4, 217 | LEP_SYS_FA_DIV_8, 218 | LEP_SYS_FA_DIV_16, 219 | LEP_SYS_FA_DIV_32, 220 | LEP_SYS_FA_DIV_64, 221 | LEP_SYS_FA_DIV_128 222 | } LEP_SYS_FRAME_AVERAGE; 223 | 224 | typedef struct { 225 | uint16_t meanIntensity; 226 | uint16_t maxIntensity; 227 | uint16_t minIntensity; 228 | uint16_t numPixels; 229 | } LEP_SYS_SCENE_STATISTICS; 230 | 231 | typedef struct { 232 | uint16_t startCol; 233 | uint16_t startRow; 234 | uint16_t endCol; 235 | uint16_t endRow; 236 | } LEP_SYS_SCENE_ROI; 237 | 238 | typedef enum { 239 | LEP_SYS_SHUTTER_POSITION_UNKNOWN = -1, 240 | LEP_SYS_SHUTTER_POSITION_IDLE = 0, 241 | LEP_SYS_SHUTTER_POSITION_OPEN, 242 | LEP_SYS_SHUTTER_POSITION_CLOSED, 243 | LEP_SYS_SHUTTER_POSITION_BRAKE_ON 244 | } LEP_SYS_SHUTTER_POSITION; 245 | 246 | typedef enum { 247 | LEP_SYS_FFC_SHUTTER_MODE_MANUAL = 0, 248 | LEP_SYS_FFC_SHUTTER_MODE_AUTO, 249 | LEP_SYS_FFC_SHUTTER_MODE_EXTERNAL 250 | } LEP_SYS_FFC_SHUTTER_MODE_STATE; 251 | 252 | typedef enum { 253 | LEP_SYS_SHUTTER_LOCKOUT_INACTIVE = 0, 254 | LEP_SYS_SHUTTER_LOCKOUT_HIGH, 255 | LEP_SYS_SHUTTER_LOCKOUT_LOW 256 | } LEP_SYS_SHUTTER_TEMP_LOCKOUT_STATE; 257 | 258 | typedef struct { 259 | uint32_t shutterMode; // LEP_SYS_FFC_SHUTTER_MODE_STATE def:LEP_SYS_FFC_SHUTTER_MODE_EXTERNAL 260 | uint32_t tempLockoutState; // LEP_SYS_SHUTTER_TEMP_LOCKOUT_STATE def:LEP_SYS_SHUTTER_LOCKOUT_INACTIVE 261 | uint32_t videoFreezeDuringFFC; // bool def:enabled 262 | uint32_t ffcDesired; // bool def:disabled 263 | uint32_t elapsedTimeSinceLastFFC; // (ms) 264 | uint32_t desiredFFCPeriod; // def:300000 (ms) 265 | uint32_t explicitCmdToOpen; // bool def:disabled 266 | uint16_t desiredFFCTempDelta; // def:300 (kelvins*100) 267 | uint16_t imminentDelay; // def:52 (frame counts) 268 | } LEP_SYS_FFC_SHUTTER_MODE; 269 | 270 | typedef enum { 271 | LEP_SYS_FFC_STATUS_WRITE_ERROR = -2, 272 | LEP_SYS_FFC_STATUS_ERROR = -1, 273 | LEP_SYS_FFC_STATUS_READY = 0, 274 | LEP_SYS_FFC_STATUS_BUSY, 275 | LEP_SYS_FRAME_AVERAGE_COLLECTING_FRAMES, 276 | } LEP_SYS_FFC_STATUS; 277 | 278 | 279 | #define LEP_VID_MODULE_BASE (uint16_t)0x0300 280 | #define LEP_CID_VID_POLARITY_SELECT (uint16_t)(LEP_VID_MODULE_BASE + 0x0000) 281 | #define LEP_CID_VID_LUT_SELECT (uint16_t)(LEP_VID_MODULE_BASE + 0x0004) 282 | #define LEP_CID_VID_LUT_TRANSFER (uint16_t)(LEP_VID_MODULE_BASE + 0x0008) 283 | #define LEP_CID_VID_FOCUS_CALC_ENABLE (uint16_t)(LEP_VID_MODULE_BASE + 0x000C) 284 | #define LEP_CID_VID_FOCUS_ROI (uint16_t)(LEP_VID_MODULE_BASE + 0x0010) 285 | #define LEP_CID_VID_FOCUS_THRESHOLD (uint16_t)(LEP_VID_MODULE_BASE + 0x0014) 286 | #define LEP_CID_VID_FOCUS_METRIC (uint16_t)(LEP_VID_MODULE_BASE + 0x0018) 287 | #define LEP_CID_VID_SBNUC_ENABLE (uint16_t)(LEP_VID_MODULE_BASE + 0x001C) 288 | #define LEP_CID_VID_GAMMA_SELECT (uint16_t)(LEP_VID_MODULE_BASE + 0x0020) 289 | #define LEP_CID_VID_FREEZE_ENABLE (uint16_t)(LEP_VID_MODULE_BASE + 0x0024) 290 | 291 | typedef enum { 292 | LEP_VID_WHITE_HOT = 0, 293 | LEP_VID_BLACK_HOT 294 | } LEP_VID_POLARITY; 295 | 296 | typedef enum { 297 | LEP_VID_WHEEL6_LUT = 0, 298 | LEP_VID_FUSION_LUT, 299 | LEP_VID_RAINBOW_LUT, 300 | LEP_VID_GLOBOW_LUT, 301 | LEP_VID_SEPIA_LUT, 302 | LEP_VID_COLOR_LUT, 303 | LEP_VID_ICE_FIRE_LUT, 304 | LEP_VID_RAIN_LUT, 305 | LEP_VID_USER_LUT, 306 | } LEP_VID_PCOLOR_LUT; 307 | 308 | typedef struct { 309 | uint8_t reserved; 310 | uint8_t red; 311 | uint8_t green; 312 | uint8_t blue; 313 | } LEP_VID_LUT_PIXEL; 314 | 315 | typedef struct { 316 | LEP_VID_LUT_PIXEL bin[256]; 317 | } LEP_VID_LUT_BUFFER; 318 | 319 | typedef struct { 320 | uint16_t startCol; 321 | uint16_t startRow; 322 | uint16_t endCol; 323 | uint16_t endRow; 324 | } LEP_VID_FOCUS_ROI; 325 | 326 | 327 | typedef enum { 328 | LEP_OK = 0, /* Camera ok */ 329 | LEP_COMM_OK = LEP_OK, /* Camera comm ok (same as LEP_OK) */ 330 | 331 | LEP_ERROR = -1, /* Camera general error */ 332 | LEP_NOT_READY = -2, /* Camera not ready error */ 333 | LEP_RANGE_ERROR = -3, /* Camera range error */ 334 | LEP_CHECKSUM_ERROR = -4, /* Camera checksum error */ 335 | LEP_BAD_ARG_POINTER_ERROR = -5, /* Camera Bad argument error */ 336 | LEP_DATA_SIZE_ERROR = -6, /* Camera byte count error */ 337 | LEP_UNDEFINED_FUNCTION_ERROR = -7, /* Camera undefined function error */ 338 | LEP_FUNCTION_NOT_SUPPORTED = -8, /* Camera function not yet supported error */ 339 | 340 | /* OTP access errors */ 341 | LEP_OTP_WRITE_ERROR = -15, /*!< Camera OTP write error */ 342 | LEP_OTP_READ_ERROR = -16, /* double bit error detected (uncorrectible) */ 343 | 344 | LEP_OTP_NOT_PROGRAMMED_ERROR = -18, /* Flag read as non-zero */ 345 | 346 | /* I2C Errors */ 347 | LEP_ERROR_I2C_BUS_NOT_READY = -20, /* I2C Bus Error - Bus Not Avaialble */ 348 | LEP_ERROR_I2C_BUFFER_OVERFLOW = -22, /* I2C Bus Error - Buffer Overflow */ 349 | LEP_ERROR_I2C_ARBITRATION_LOST = -23, /* I2C Bus Error - Bus Arbitration Lost */ 350 | LEP_ERROR_I2C_BUS_ERROR = -24, /* I2C Bus Error - General Bus Error */ 351 | LEP_ERROR_I2C_NACK_RECEIVED = -25, /* I2C Bus Error - NACK Received */ 352 | LEP_ERROR_I2C_FAIL = -26, /* I2C Bus Error - General Failure */ 353 | 354 | /* Processing Errors */ 355 | LEP_DIV_ZERO_ERROR = -80, /* Attempted div by zero */ 356 | 357 | /* Comm Errors */ 358 | LEP_COMM_PORT_NOT_OPEN = -101, /* Comm port not open */ 359 | LEP_COMM_INVALID_PORT_ERROR = -102, /* Comm port no such port error */ 360 | LEP_COMM_RANGE_ERROR = -103, /* Comm port range error */ 361 | LEP_ERROR_CREATING_COMM = -104, /* Error creating comm */ 362 | LEP_ERROR_STARTING_COMM = -105, /* Error starting comm */ 363 | LEP_ERROR_CLOSING_COMM = -106, /* Error closing comm */ 364 | LEP_COMM_CHECKSUM_ERROR = -107, /* Comm checksum error */ 365 | LEP_COMM_NO_DEV = -108, /* No comm device */ 366 | LEP_TIMEOUT_ERROR = -109, /* Comm timeout error */ 367 | LEP_COMM_ERROR_WRITING_COMM = -110, /* Error writing comm */ 368 | LEP_COMM_ERROR_READING_COMM = -111, /* Error reading comm */ 369 | LEP_COMM_COUNT_ERROR = -112, /* Comm byte count error */ 370 | 371 | /* Other Errors */ 372 | LEP_OPERATION_CANCELED = -126, /* Camera operation canceled */ 373 | LEP_UNDEFINED_ERROR_CODE = -127 /* Undefined error */ 374 | } LEP_RESULT; 375 | 376 | #endif 377 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/samyk/Lepton-FLiR-Arduino/f6fab989cbc929fae7ddbe98bf2e91263e1308a2/README.md -------------------------------------------------------------------------------- /examples/AdvancedExample/AdvancedExample.ino: -------------------------------------------------------------------------------- 1 | // Lepton-FLiR-Arduino Advanced Example 2 | // In this example, we will utilize various features of the library. We will be using 3 | // Wire1, which is only available on boards with SDA1/SCL1 (Due, Zero, etc.) - change to 4 | // Wire if Wire1 is unavailable. We will also be using the digitalWriteFast library, 5 | // available at: https://github.com/watterott/Arduino-Libs/tree/master/digitalWriteFast 6 | 7 | #include "LeptonFLiR.h" 8 | #include "digitalWriteFast.h" 9 | 10 | const byte flirCSPin = 22; 11 | LeptonFLiR flirController(Wire1, flirCSPin); // Library using Wire1 and chip select pin D22 12 | 13 | // Fast CS enable/disable routines, using the digitalWriteFast library 14 | static void fastEnableCS(byte pin) { digitalWriteFast(pin, LOW); } 15 | static void fastDisableCS(byte pin) { digitalWriteFast(pin, HIGH); } 16 | 17 | void setup() { 18 | Serial.begin(115200); 19 | 20 | Wire1.begin(); // Wire1 must be started first 21 | Wire1.setClock(400000); // Supported baud rates are 100kHz, 400kHz, and 1000kHz 22 | SPI.begin(); // SPI must be started first as well 23 | 24 | // Using default memory allocation mode 80x60 16bpp and default celsius temperature mode 25 | flirController.init(); 26 | 27 | // Setting use of fast enable/disable methods for chip select 28 | flirController.setFastCSFuncs(fastEnableCS, fastDisableCS); 29 | 30 | flirController.sys_setTelemetryEnabled(ENABLED); // Ensure telemetry is enabled 31 | } 32 | 33 | void loop() { 34 | if (flirController.readNextFrame()) { // Read next frame and store result into internal imageData 35 | // Find the hottest spot on the frame 36 | int hotVal = 0; hotX, hotY; 37 | 38 | for (int y = 0; y < flirController.getImageHeight(); ++y) { 39 | for (int x = 0; x < flirController.getImageWidth(); ++x) { 40 | int val = flirController.getImageDataRowCol(y, x); 41 | 42 | if (val > hotVal) { 43 | hotVal = val; 44 | hotX = x; hotY = y; 45 | } 46 | } 47 | } 48 | 49 | Serial.print("Hottest point: ["); 50 | Serial.print(hotX); 51 | Serial.print(","); 52 | Serial.print(hotY); 53 | Serial.println("]"); 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /examples/ImageCaptureExample/ImageCaptureExample.ino: -------------------------------------------------------------------------------- 1 | // Lepton-FLiR-Arduino Image Capture Example 2 | // In this example, we will copy out thermal image frames to individual BMP files located 3 | // on a MicroSD card using the SD library. Note that you will need a MicroSD card reader 4 | // module for this example to work. Both the FLiR module and MicroSD card reader module 5 | // will be on the same SPI lines, just using different chip enable pins/wires. 6 | 7 | #include "LeptonFLiR.h" 8 | #include 9 | 10 | const byte flirCSPin = 22; 11 | LeptonFLiR flirController(Wire, flirCSPin); // Library using Wire and chip select pin D22 12 | 13 | const byte cardCSPin = 24; 14 | 15 | void setup() { 16 | Serial.begin(115200); 17 | 18 | Wire.begin(); // Wire must be started first 19 | Wire.setClock(400000); // Supported baud rates are 100kHz, 400kHz, and 1000kHz 20 | SPI.begin(); // SPI must be started first as well 21 | 22 | SD.begin(cardCSPin); // SD library using chip select pin D24 23 | 24 | // Using memory allocation mode 80x60 8bpp and fahrenheit temperature mode 25 | flirController.init(LeptonFLiR_ImageStorageMode_80x60_8bpp, LeptonFLiR_TemperatureMode_Fahrenheit); 26 | 27 | // Setting use of AGC for histogram equalization (since we only have 8-bit per pixel data anyways) 28 | flirController.agc_setAGCEnabled(ENABLED); 29 | 30 | flirController.sys_setTelemetryEnabled(ENABLED); // Ensure telemetry is enabled 31 | 32 | SD.rmdir("FLIR"); // Starting fresh with new frame captures 33 | } 34 | 35 | uint32_t lastFrameNumber = -1; // Tracks for when a new frame is available 36 | 37 | void loop() { 38 | if (flirController.readNextFrame()) { // Read next frame and store result into internal imageData 39 | uint32_t frameNumber = flirController.getTelemetryFrameCounter(); 40 | 41 | if (frameNumber > lastFrameNumber) { // Frame counter increments every 3rd frame due to export restrictions 42 | lastFrameNumber = frameNumber; 43 | 44 | char fileName[] = "FLIR/IMG0000.BMP"; 45 | uint16_t fileNumber = (uint16_t)(frameNumber / 3); 46 | wordsToHexString((uint16_t *)&fileNumber, 1, &fileName[8], 4); 47 | 48 | File bmpFile = SD.open(fileName, FILE_WRITE); 49 | 50 | if (bmpFile) { 51 | writeBMPFile(bmpFile, 52 | flirController.getImageData(), 53 | flirController.getImageWidth(), 54 | flirController.getImageHeight(), 55 | flirController.getImagePitch()); 56 | 57 | bmpFile.close(); 58 | 59 | Serial.print(fileName); 60 | Serial.println(" written..."); 61 | } 62 | } 63 | 64 | // Occasionally flat field correction normalization needs ran 65 | if (flirController.getShouldRunFFCNormalization()) 66 | flirController.sys_runFFCNormalization(); 67 | } 68 | } 69 | 70 | // Writes a BMP file out, code from: http://stackoverflow.com/questions/2654480/writing-bmp-image-in-pure-c-c-without-other-libraries 71 | void writeBMPFile(File &bmpFile, byte *imageData, int width, int height, int pitch) { 72 | byte file[14] = { 73 | 'B','M', // magic 74 | 0,0,0,0, // size in bytes 75 | 0,0, // app data 76 | 0,0, // app data 77 | 40+14,0,0,0 // start of data offset 78 | }; 79 | byte info[40] = { 80 | 40,0,0,0, // info hd size 81 | 0,0,0,0, // width 82 | 0,0,0,0, // heigth 83 | 1,0, // number color planes 84 | 24,0, // bits per pixel 85 | 0,0,0,0, // compression is none 86 | 0,0,0,0, // image bits size 87 | 0x13,0x0B,0,0, // horz resoluition in pixel / m 88 | 0x13,0x0B,0,0, // vert resolutions (0x03C3 = 96 dpi, 0x0B13 = 72 dpi) 89 | 0,0,0,0, // #colors in pallete 90 | 0,0,0,0, // #important colors 91 | }; 92 | 93 | uint32_t padSize = (4-(width*3)%4)%4; 94 | uint32_t sizeData = width*height*3 + height*padSize; 95 | uint32_t sizeAll = sizeData + sizeof(file) + sizeof(info); 96 | 97 | file[ 2] = (byte)((sizeAll ) & 0xFF); 98 | file[ 3] = (byte)((sizeAll >> 8) & 0xFF); 99 | file[ 4] = (byte)((sizeAll >> 16) & 0xFF); 100 | file[ 5] = (byte)((sizeAll >> 24) & 0xFF); 101 | info[ 4] = (byte)((width ) & 0xFF); 102 | info[ 5] = (byte)((width >> 8) & 0xFF); 103 | info[ 6] = (byte)((width >> 16) & 0xFF); 104 | info[ 7] = (byte)((width >> 24) & 0xFF); 105 | info[ 8] = (byte)((height ) & 0xFF); 106 | info[ 9] = (byte)((height >> 8) & 0xFF); 107 | info[10] = (byte)((height >> 16) & 0xFF); 108 | info[11] = (byte)((height >> 24) & 0xFF); 109 | info[20] = (byte)((sizeData ) & 0xFF); 110 | info[21] = (byte)((sizeData >> 8) & 0xFF); 111 | info[22] = (byte)((sizeData >> 16) & 0xFF); 112 | info[23] = (byte)((sizeData >> 24) & 0xFF); 113 | 114 | bmpFile.write((byte *)file, sizeof(file)); 115 | bmpFile.write((byte *)info, sizeof(info)); 116 | 117 | byte pad[3] = {0,0,0}; 118 | imageData += (height - 1) * pitch; 119 | 120 | for (int y = height - 1; y >= 0; --y) { 121 | for (int x = 0; x < width; ++x) { 122 | byte pixel[3]; // blue green red 123 | pixel[0] = pixel[1] = pixel[2] = imageData[x]; 124 | 125 | bmpFile.write((byte *)pixel, 3); 126 | } 127 | 128 | bmpFile.write((byte *)pad, padSize); 129 | imageData -= pitch; 130 | } 131 | } 132 | -------------------------------------------------------------------------------- /examples/ModuleInfo/ModuleInfo.ino: -------------------------------------------------------------------------------- 1 | // Lepton-FLiR-Arduino Module Info 2 | // If one uncomments the LEPFLIR_ENABLE_DEBUG_OUTPUT define in the libraries main header 3 | // file (thus enabling debug output) the printModuleInfo() method becomes available, 4 | // which will display information about the module itself, including initalized states, 5 | // register values, current settings, etc. All calls being made will display internal 6 | // debug information about the structure of the call itself. 7 | 8 | // Uncomment this define to enable debug output. 9 | #define LEPFLIR_ENABLE_DEBUG_OUTPUT 1 10 | 11 | #include "LeptonFLiR.h" 12 | 13 | LeptonFLiR flirController; 14 | 15 | void setup() { 16 | Serial.begin(115200); 17 | 18 | flirController.printModuleInfo(); 19 | } 20 | 21 | void loop() { 22 | } 23 | -------------------------------------------------------------------------------- /examples/SimpleExample/SimpleExample.ino: -------------------------------------------------------------------------------- 1 | // Lepton-FLiR-Arduino Simple Example 2 | 3 | #include "LeptonFLiR.h" 4 | 5 | LeptonFLiR flirController; // Library using default Wire and default chip select pin D53 6 | 7 | void setup() { 8 | Serial.begin(115200); 9 | 10 | Wire.begin(); // Wire must be started first 11 | Wire.setClock(400000); // Supported baud rates are 100kHz, 400kHz, and 1000kHz 12 | SPI.begin(); // SPI must be started first as well 13 | 14 | // Using 40x30 8bpp memory allocation mode and default celsius temperature mode 15 | flirController.init(LeptonFLiR_ImageStorageMode_40x30_8bpp); 16 | } 17 | 18 | void loop() { 19 | flirController.readNextFrame(); // Read next frame and store result into internal imageData 20 | } 21 | -------------------------------------------------------------------------------- /examples/SoftwareI2CExample/SoftwareI2CExample.ino: -------------------------------------------------------------------------------- 1 | // Lepton-FLiR-Arduino Software I2C Example 2 | // In this example, we utilize the software I2C functionality for chips that do not have 3 | // a hardware I2C bus. We must uncomment the LEPFLIR_ENABLE_SOFTWARE_I2C define in the 4 | // libraries main header file for software I2C mode to be enabled. 5 | 6 | // Uncomment this define to enable use of the software i2c library (min 4MHz+ processor required). 7 | #define LEPFLIR_ENABLE_SOFTWARE_I2C 1 // http://playground.arduino.cc/Main/SoftwareI2CLibrary 8 | 9 | #include "LeptonFLiR.h" 10 | 11 | #define SCL_PIN 2 // Setup defines are written before library include 12 | #define SCL_PORT PORTD 13 | #define SDA_PIN 0 14 | #define SDA_PORT PORTC 15 | 16 | #if F_CPU >= 16000000 17 | #define I2C_FASTMODE 1 // Running a 16MHz processor allows us to use I2C fast mode 18 | #endif 19 | 20 | #include "SoftI2CMaster.h" // Include must come after setup defines 21 | 22 | const byte csPin = 4; 23 | LeptonFLiR flirController(csPin); // Library using chip select pin 4 24 | 25 | void setup() { 26 | Serial.begin(115200); 27 | 28 | i2c_init(); // Software I2C must be started first 29 | SPI.begin(); // SPI must be started first as well 30 | 31 | // Using lowest memory allocation mode 20x15 8bpp and default celsius temperature mode 32 | flirController.init(LeptonFLiR_ImageStorageMode_20x15_8bpp); 33 | 34 | flirController.sys_setTelemetryEnabled(DISABLED); // Default mode is enabled 35 | } 36 | 37 | void loop() { 38 | flirController.readNextFrame(); // Reads next frame and stores result into internal imageData 39 | } 40 | -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=Lepton FLiR Thermal Camera Module Library 2 | version=0.9.91 3 | author=NachtRaveVL 4 | maintainer=NachtRaveVL 5 | sentence=Library to control a Lepton FLiR (forward looking infrared) thermal camera module from an Arduino board (Due, Zero, etc. recommended). 6 | paragraph=This library allows communication with boards running a Lepton FLiR thermal camera module. It provides a wide range of functionality from adjustable memory footprint size, adjustable temperature display mode, fast chip select enable/disable routines, to exposing the full functionality of the thermal camera itself. 7 | category=Device Control 8 | url=https://github.com/NachtRaveVL/Lepton-FLiR-Arduino 9 | architectures=* 10 | -------------------------------------------------------------------------------- /support files/FLIR_Lepton_Data_Brief.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/samyk/Lepton-FLiR-Arduino/f6fab989cbc929fae7ddbe98bf2e91263e1308a2/support files/FLIR_Lepton_Data_Brief.pdf -------------------------------------------------------------------------------- /support files/FLIR_Lepton_Software_Interface_Description_Document_110_0144_03.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/samyk/Lepton-FLiR-Arduino/f6fab989cbc929fae7ddbe98bf2e91263e1308a2/support files/FLIR_Lepton_Software_Interface_Description_Document_110_0144_03.pdf -------------------------------------------------------------------------------- /support files/LeptonModule.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/samyk/Lepton-FLiR-Arduino/f6fab989cbc929fae7ddbe98bf2e91263e1308a2/support files/LeptonModule.zip -------------------------------------------------------------------------------- /support files/LeptonSDKEmb32PUB.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/samyk/Lepton-FLiR-Arduino/f6fab989cbc929fae7ddbe98bf2e91263e1308a2/support files/LeptonSDKEmb32PUB.zip --------------------------------------------------------------------------------