diff --git a/I2CDEVICES.md b/I2CDEVICES.md
index 457116347..5d60c5fb4 100644
--- a/I2CDEVICES.md
+++ b/I2CDEVICES.md
@@ -74,4 +74,5 @@ Index | Define              | Driver  | Device   | Address(es) | Description
   49  | USE_VEML6075        | xsns_70 | VEML6075 | 0x10        | UVA/UVB/UVINDEX Sensor
   50  | USE_VEML7700        | xsns_71 | VEML7700 | 0x10        | Ambient light intensity sensor
   51  | USE_MCP9808         | xsns_72 | MCP9808  | 0x18 - 0x1F | Temperature sensor
-  52  | USE_HP303B          | xsns_73 | HP303B   | 0x76 - 0x77 | Pressure and temperature sensor
\ No newline at end of file
+  52  | USE_HP303B          | xsns_73 | HP303B   | 0x76 - 0x77 | Pressure and temperature sensor
+  53  | USE_MLX90640        | xdrv_84 | MLX90640 | 0x33        | IR array temperature sensor
\ No newline at end of file
diff --git a/lib/mlx90640-library/MLX90640_API.cpp b/lib/mlx90640-library/MLX90640_API.cpp
new file mode 100644
index 000000000..87d871530
--- /dev/null
+++ b/lib/mlx90640-library/MLX90640_API.cpp
@@ -0,0 +1,1640 @@
+/**
+ * @copyright (C) 2017 Melexis N.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <MLX90640_API.h>
+#include <math.h>
+#include <Wire.h>
+
+void ExtractVDDParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractPTATParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractGainParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractTgcParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractResolutionParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractKsTaParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractKsToParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractAlphaParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractOffsetParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractKtaPixelParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractKvPixelParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractCPParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+void ExtractCILCParameters(uint16_t *eeData, paramsMLX90640 *mlx90640);
+int ExtractDeviatingPixels(uint16_t *eeData, paramsMLX90640 *mlx90640);
+int CheckAdjacentPixels(uint16_t pix1, uint16_t pix2);  
+float GetMedian(float *values, int n);
+int IsPixelBad(uint16_t pixel,paramsMLX90640 *params);
+int ValidateFrameData(uint16_t *frameData);
+int ValidateAuxData(uint16_t *auxData);
+int MLX90640_I2CRead(uint8_t addr, uint32_t reg, uint16_t len, uint16_t *reg_data);
+int MLX90640_I2CWrite(uint8_t _deviceAddress, unsigned int writeAddress, uint16_t data);
+
+// I2C
+#define I2C_BUFFER_LENGTH 128
+
+int MLX90640_I2CRead(uint8_t addr, uint32_t reg, uint16_t len, uint16_t *reg_data){
+  int bytesRemaining = len * 2;
+  int dataSpot = 0; //Start at beginning of array
+  while (bytesRemaining > 0)
+  {
+    Wire.beginTransmission(addr);
+    Wire.write(reg >> 8); //MSB
+    Wire.write(reg & 0xFF); //LSB
+    if (Wire.endTransmission(false) != 0) //Do not release bus
+    {
+      return (0); //Sensor did not ACK
+    }
+    int numberOfBytesToRead = bytesRemaining;
+    if (numberOfBytesToRead > I2C_BUFFER_LENGTH) numberOfBytesToRead = I2C_BUFFER_LENGTH;
+    Wire.requestFrom((int)addr, numberOfBytesToRead);
+    if (Wire.available())
+    {
+      for (uint32_t x = 0 ; x < numberOfBytesToRead / 2; x++)
+      {
+        reg_data[dataSpot] = Wire.read() << 8; //MSB
+        reg_data[dataSpot] |= Wire.read(); //LSB
+        dataSpot++;
+      }
+    }
+    bytesRemaining -= numberOfBytesToRead;
+    reg += numberOfBytesToRead / 2;
+  }
+  return (0); //Success
+}
+
+int MLX90640_I2CWrite(uint8_t _deviceAddress, unsigned int writeAddress, uint16_t data)
+{
+  Wire.beginTransmission((uint8_t)_deviceAddress);
+  Wire.write(writeAddress >> 8); //MSB
+  Wire.write(writeAddress & 0xFF); //LSB
+  Wire.write(data >> 8); //MSB
+  Wire.write(data & 0xFF); //LSB
+  if (Wire.endTransmission() != 0)
+  {
+    //Sensor did not ACK
+    return (-1);
+  }
+  uint16_t dataCheck;
+  MLX90640_I2CRead(_deviceAddress, writeAddress, 1, &dataCheck);
+  if (dataCheck != data)
+  {
+    return -2;
+  }
+  return (0); //Success
+}
+  
+int MLX90640_DumpEE(uint8_t slaveAddr, uint16_t *eeData)
+{
+     return MLX90640_I2CRead(slaveAddr, 0x2400, 832, eeData);
+}
+
+int MLX90640_SynchFrame(uint8_t slaveAddr)
+{
+    uint16_t dataReady = 0;
+    uint16_t statusRegister;
+    int error = 1;
+    
+    error = MLX90640_I2CWrite(slaveAddr, 0x8000, 0x0030);
+    if(error == -1)
+    {
+        return error;
+    }
+    
+    while(dataReady == 0)
+    {
+        error = MLX90640_I2CRead(slaveAddr, 0x8000, 1, &statusRegister);
+        if(error != 0)
+        {
+            return error;
+        }    
+        dataReady = statusRegister & 0x0008;
+    }      
+    
+   return 0;   
+}
+
+// int MLX90640_TriggerMeasurement(uint8_t slaveAddr) // ATM not used in Tasmota
+// {
+//     int error = 1;
+//     uint16_t ctrlReg;
+    
+//     error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &ctrlReg);
+    
+//     if ( error != 0) 
+//     {
+//         return error;
+//     }    
+                                                
+//     ctrlReg |= 0x8000;
+//     error = MLX90640_I2CWrite(slaveAddr, 0x800D, ctrlReg);
+    
+//     if ( error != 0)
+//     {
+//         return error;
+//     }    
+    
+//     // error = MLX90640_I2CGeneralReset();
+    
+//     // if ( error != 0)
+//     // {
+//     //     return error;
+//     // }    
+    
+//     error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &ctrlReg);
+    
+//     if ( error != 0)
+//     {
+//         return error;
+//     }    
+    
+//     if ((ctrlReg & 0x8000) != 0)
+//     {
+//         return -9;
+//     }
+    
+//     return 0;    
+// }
+    
+int MLX90640_GetFrameData(uint8_t slaveAddr, uint16_t *frameData)
+{
+    uint16_t dataReady = 0;
+    uint16_t controlRegister1;
+    uint16_t statusRegister;
+    int error = 1;
+    uint16_t data[64];
+    uint8_t cnt = 0;
+    
+    while(dataReady == 0)
+    {
+        error = MLX90640_I2CRead(slaveAddr, 0x8000, 1, &statusRegister);
+        if(error != 0)
+        {
+            return error;
+        }    
+        dataReady = statusRegister & 0x0008;
+    }      
+    
+    error = MLX90640_I2CWrite(slaveAddr, 0x8000, 0x0030);
+    if(error == -1)
+    {
+        return error;
+    }
+                     
+    error = MLX90640_I2CRead(slaveAddr, 0x0400, 768, frameData); 
+    if(error != 0)
+    {
+        return error;
+    }                       
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x0700, 64, data); 
+    if(error != 0)
+    {
+        return error;
+    }     
+        
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    frameData[832] = controlRegister1;
+    frameData[833] = statusRegister & 0x0001;
+    
+    if(error != 0)
+    {
+        return error;
+    }
+    
+    error = ValidateAuxData(data);
+    if(error == 0)
+    {
+        for(cnt=0; cnt<64; cnt++)
+        {
+            frameData[cnt+768] = data[cnt];
+        }
+    }        
+    
+    error = ValidateFrameData(frameData);
+    if (error != 0)
+    {
+        return error;
+    }
+    
+    return frameData[833];    
+}
+
+int ValidateFrameData(uint16_t *frameData)
+{
+    uint8_t line = 0;
+    
+    for(int i=0; i<768; i+=32)
+    {
+        if((frameData[i] == 0x7FFF) && (line%2 == frameData[833])) return -8;
+        line = line + 1;
+    }    
+        
+    return 0;    
+}
+
+int ValidateAuxData(uint16_t *auxData)
+{
+    
+    if(auxData[0] == 0x7FFF) return -8;    
+    
+    for(int i=8; i<19; i++)
+    {
+        if(auxData[i] == 0x7FFF) return -8;
+    }
+    
+    for(int i=20; i<23; i++)
+    {
+        if(auxData[i] == 0x7FFF) return -8;
+    }
+    
+    for(int i=24; i<33; i++)
+    {
+        if(auxData[i] == 0x7FFF) return -8;
+    }
+    
+    for(int i=40; i<51; i++)
+    {
+        if(auxData[i] == 0x7FFF) return -8;
+    }
+    
+    for(int i=52; i<55; i++)
+    {
+        if(auxData[i] == 0x7FFF) return -8;
+    }
+    
+    for(int i=56; i<64; i++)
+    {
+        if(auxData[i] == 0x7FFF) return -8;
+    }
+    
+    return 0;
+    
+}
+    
+int MLX90640_ExtractParameters(uint16_t *eeData, paramsMLX90640 *mlx90640, int _chunk) // Tasmota
+{
+    int error = 0;
+    switch(_chunk){
+      case 0:
+        ExtractVDDParameters(eeData, mlx90640);
+        ExtractPTATParameters(eeData, mlx90640);
+        ExtractGainParameters(eeData, mlx90640);
+        ExtractTgcParameters(eeData, mlx90640);
+        ExtractResolutionParameters(eeData, mlx90640);
+        ExtractKsTaParameters(eeData, mlx90640);
+        ExtractKsToParameters(eeData, mlx90640);
+      break;
+      case 1:
+        ExtractCPParameters(eeData, mlx90640);
+        ExtractAlphaParameters(eeData, mlx90640);
+      break;
+      case 2:
+        ExtractOffsetParameters(eeData, mlx90640);
+      break;
+      case 3:
+        ExtractKtaPixelParameters(eeData, mlx90640);
+      break;
+      case 4:
+        ExtractKvPixelParameters(eeData, mlx90640);
+      break;
+      case 5:
+        ExtractCILCParameters(eeData, mlx90640);
+        error = ExtractDeviatingPixels(eeData, mlx90640);
+      break;
+    }
+    return error;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_SetResolution(uint8_t slaveAddr, uint8_t resolution)
+{
+    uint16_t controlRegister1;
+    int value;
+    int error;
+    
+    value = (resolution & 0x03) << 10;
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    
+    if(error == 0)
+    {
+        value = (controlRegister1 & 0xF3FF) | value;
+        error = MLX90640_I2CWrite(slaveAddr, 0x800D, value);        
+    }    
+    
+    return error;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_GetCurResolution(uint8_t slaveAddr)
+{
+    uint16_t controlRegister1;
+    int resolutionRAM;
+    int error;
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    if(error != 0)
+    {
+        return error;
+    }    
+    resolutionRAM = (controlRegister1 & 0x0C00) >> 10;
+    
+    return resolutionRAM; 
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_SetRefreshRate(uint8_t slaveAddr, uint8_t refreshRate)
+{
+    uint16_t controlRegister1;
+    int value;
+    int error;
+    
+    value = (refreshRate & 0x07)<<7;
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    if(error == 0)
+    {
+        value = (controlRegister1 & 0xFC7F) | value;
+        error = MLX90640_I2CWrite(slaveAddr, 0x800D, value);
+    }    
+    
+    return error;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_GetRefreshRate(uint8_t slaveAddr)
+{
+    uint16_t controlRegister1;
+    int refreshRate;
+    int error;
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    if(error != 0)
+    {
+        return error;
+    }    
+    refreshRate = (controlRegister1 & 0x0380) >> 7;
+    
+    return refreshRate;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_SetInterleavedMode(uint8_t slaveAddr)
+{
+    uint16_t controlRegister1;
+    int value;
+    int error;
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    
+    if(error == 0)
+    {
+        value = (controlRegister1 & 0xEFFF);
+        error = MLX90640_I2CWrite(slaveAddr, 0x800D, value);        
+    }    
+    
+    return error;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_SetChessMode(uint8_t slaveAddr)
+{
+    uint16_t controlRegister1;
+    int value;
+    int error;
+        
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    
+    if(error == 0)
+    {
+        value = (controlRegister1 | 0x1000);
+        error = MLX90640_I2CWrite(slaveAddr, 0x800D, value);        
+    }    
+    
+    return error;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_GetCurMode(uint8_t slaveAddr)
+{
+    uint16_t controlRegister1;
+    int modeRAM;
+    int error;
+    
+    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
+    if(error != 0)
+    {
+        return error;
+    }    
+    modeRAM = (controlRegister1 & 0x1000) >> 12;
+    
+    return modeRAM; 
+}
+
+//------------------------------------------------------------------------------
+void MLX90640_CalculateTo(uint16_t *frameData, const paramsMLX90640 *params, float emissivity, float tr, float *result, uint8_t _part)
+{
+    float vdd;
+    float ta;
+    float ta4;
+    float tr4;
+    float taTr;
+    float gain;
+    float irDataCP[2];
+    float irData;
+    float alphaCompensated;
+    uint8_t mode;
+    int8_t ilPattern;
+    int8_t chessPattern;
+    int8_t pattern;
+    int8_t conversionPattern;
+    float Sx;
+    float To;
+    float alphaCorrR[4];
+    int8_t range;
+    uint16_t subPage;
+    float ktaScale;
+    float kvScale;
+    float alphaScale;
+    float kta;
+    float kv;
+    
+    subPage = frameData[833];
+    vdd = MLX90640_GetVdd(frameData, params);
+    ta = MLX90640_GetTa(frameData, params);
+    
+    ta4 = (ta + 273.15);
+    ta4 = ta4 * ta4;
+    ta4 = ta4 * ta4;
+    tr4 = (tr + 273.15);
+    tr4 = tr4 * tr4;
+    tr4 = tr4 * tr4;
+    taTr = tr4 - (tr4-ta4)/emissivity;
+    
+    ktaScale = pow(2,(double)params->ktaScale);
+    kvScale = pow(2,(double)params->kvScale);
+    alphaScale = pow(2,(double)params->alphaScale);
+    
+    alphaCorrR[0] = 1 / (1 + params->ksTo[0] * 40);
+    alphaCorrR[1] = 1 ;
+    alphaCorrR[2] = (1 + params->ksTo[1] * params->ct[2]);
+    alphaCorrR[3] = alphaCorrR[2] * (1 + params->ksTo[2] * (params->ct[3] - params->ct[2]));
+    
+//------------------------- Gain calculation -----------------------------------    
+    gain = frameData[778];
+    if(gain > 32767)
+    {
+        gain = gain - 65536;
+    }
+    
+    gain = params->gainEE / gain; 
+  
+//------------------------- To calculation -------------------------------------    
+    mode = (frameData[832] & 0x1000) >> 5;
+    
+    irDataCP[0] = frameData[776];  
+    irDataCP[1] = frameData[808];
+    for( int i = 0; i < 2; i++)
+    {
+        if(irDataCP[i] > 32767)
+        {
+            irDataCP[i] = irDataCP[i] - 65536;
+        }
+        irDataCP[i] = irDataCP[i] * gain;
+    }
+    irDataCP[0] = irDataCP[0] - params->cpOffset[0] * (1 + params->cpKta * (ta - 25)) * (1 + params->cpKv * (vdd - 3.3));
+    if( mode ==  params->calibrationModeEE)
+    {
+        irDataCP[1] = irDataCP[1] - params->cpOffset[1] * (1 + params->cpKta * (ta - 25)) * (1 + params->cpKv * (vdd - 3.3));
+    }
+    else
+    {
+      irDataCP[1] = irDataCP[1] - (params->cpOffset[1] + params->ilChessC[0]) * (1 + params->cpKta * (ta - 25)) * (1 + params->cpKv * (vdd - 3.3));
+    }
+
+    uint32_t _offset = _part*(768/2);
+    for( int pixelNumber = _offset; pixelNumber < (_offset+(768/2)); pixelNumber++)
+    {
+        ilPattern = pixelNumber / 32 - (pixelNumber / 64) * 2; 
+        chessPattern = ilPattern ^ (pixelNumber - (pixelNumber/2)*2); 
+        conversionPattern = ((pixelNumber + 2) / 4 - (pixelNumber + 3) / 4 + (pixelNumber + 1) / 4 - pixelNumber / 4) * (1 - 2 * ilPattern);
+        
+        if(mode == 0)
+        {
+          pattern = ilPattern; 
+        }
+        else 
+        {
+          pattern = chessPattern; 
+        }               
+        
+        if(pattern == frameData[833])
+        {    
+            irData = frameData[pixelNumber];
+            if(irData > 32767)
+            {
+                irData = irData - 65536;
+            }
+            irData = irData * gain;
+            
+            kta = params->kta[pixelNumber]/ktaScale;
+            kv = params->kv[pixelNumber]/kvScale;
+            irData = irData - params->offset[pixelNumber]*(1 + kta*(ta - 25))*(1 + kv*(vdd - 3.3));
+            
+            if(mode !=  params->calibrationModeEE)
+            {
+              irData = irData + params->ilChessC[2] * (2 * ilPattern - 1) - params->ilChessC[1] * conversionPattern; 
+            }                       
+    
+            irData = irData - params->tgc * irDataCP[subPage];
+            irData = irData / emissivity;
+            
+            alphaCompensated = SCALEALPHA*alphaScale/params->alpha[pixelNumber];
+            alphaCompensated = alphaCompensated*(1 + params->KsTa * (ta - 25));
+                        
+            Sx = alphaCompensated * alphaCompensated * alphaCompensated * (irData + alphaCompensated * taTr);
+            Sx = sqrt(sqrt(Sx)) * params->ksTo[1];            
+            
+            To = sqrt(sqrt(irData/(alphaCompensated * (1 - params->ksTo[1] * 273.15) + Sx) + taTr)) - 273.15;                     
+                    
+            if(To < params->ct[1])
+            {
+                range = 0;
+            }
+            else if(To < params->ct[2])   
+            {
+                range = 1;            
+            }   
+            else if(To < params->ct[3])
+            {
+                range = 2;            
+            }
+            else
+            {
+                range = 3;            
+            }      
+            
+            To = sqrt(sqrt(irData / (alphaCompensated * alphaCorrR[range] * (1 + params->ksTo[range] * (To - params->ct[range]))) + taTr)) - 273.15;
+                        
+            result[pixelNumber] = To;
+        }
+    }
+}
+
+//------------------------------------------------------------------------------
+
+// void MLX90640_GetImage(uint16_t *frameData, const paramsMLX90640 *params, float *result)
+// {
+//     float vdd;
+//     float ta;
+//     float gain;
+//     float irDataCP[2];
+//     float irData;
+//     float alphaCompensated;
+//     uint8_t mode;
+//     int8_t ilPattern;
+//     int8_t chessPattern;
+//     int8_t pattern;
+//     int8_t conversionPattern;
+//     float image;
+//     uint16_t subPage;
+//     float ktaScale;
+//     float kvScale;
+//     float kta;
+//     float kv;
+    
+//     subPage = frameData[833];
+//     vdd = MLX90640_GetVdd(frameData, params);
+//     ta = MLX90640_GetTa(frameData, params);
+    
+//     ktaScale = pow(2,(double)params->ktaScale);
+//     kvScale = pow(2,(double)params->kvScale);
+    
+// //------------------------- Gain calculation -----------------------------------    
+//     gain = frameData[778];
+//     if(gain > 32767)
+//     {
+//         gain = gain - 65536;
+//     }
+    
+//     gain = params->gainEE / gain; 
+  
+// //------------------------- Image calculation -------------------------------------    
+//     mode = (frameData[832] & 0x1000) >> 5;
+    
+//     irDataCP[0] = frameData[776];  
+//     irDataCP[1] = frameData[808];
+//     for( int i = 0; i < 2; i++)
+//     {
+//         if(irDataCP[i] > 32767)
+//         {
+//             irDataCP[i] = irDataCP[i] - 65536;
+//         }
+//         irDataCP[i] = irDataCP[i] * gain;
+//     }
+//     irDataCP[0] = irDataCP[0] - params->cpOffset[0] * (1 + params->cpKta * (ta - 25)) * (1 + params->cpKv * (vdd - 3.3));
+//     if( mode ==  params->calibrationModeEE)
+//     {
+//         irDataCP[1] = irDataCP[1] - params->cpOffset[1] * (1 + params->cpKta * (ta - 25)) * (1 + params->cpKv * (vdd - 3.3));
+//     }
+//     else
+//     {
+//       irDataCP[1] = irDataCP[1] - (params->cpOffset[1] + params->ilChessC[0]) * (1 + params->cpKta * (ta - 25)) * (1 + params->cpKv * (vdd - 3.3));
+//     }
+
+//     for( int pixelNumber = 0; pixelNumber < 768; pixelNumber++)
+//     {
+//         ilPattern = pixelNumber / 32 - (pixelNumber / 64) * 2; 
+//         chessPattern = ilPattern ^ (pixelNumber - (pixelNumber/2)*2); 
+//         conversionPattern = ((pixelNumber + 2) / 4 - (pixelNumber + 3) / 4 + (pixelNumber + 1) / 4 - pixelNumber / 4) * (1 - 2 * ilPattern);
+        
+//         if(mode == 0)
+//         {
+//           pattern = ilPattern; 
+//         }
+//         else 
+//         {
+//           pattern = chessPattern; 
+//         }
+        
+//         if(pattern == frameData[833])
+//         {    
+//             irData = frameData[pixelNumber];
+//             if(irData > 32767)
+//             {
+//                 irData = irData - 65536;
+//             }
+//             irData = irData * gain;
+            
+//             kta = params->kta[pixelNumber]/ktaScale;
+//             kv = params->kv[pixelNumber]/kvScale;
+//             irData = irData - params->offset[pixelNumber]*(1 + kta*(ta - 25))*(1 + kv*(vdd - 3.3));
+
+//             if(mode !=  params->calibrationModeEE)
+//             {
+//               irData = irData + params->ilChessC[2] * (2 * ilPattern - 1) - params->ilChessC[1] * conversionPattern; 
+//             }
+            
+//             irData = irData - params->tgc * irDataCP[subPage];
+                        
+//             alphaCompensated = params->alpha[pixelNumber];
+            
+//             image = irData*alphaCompensated;
+            
+//             result[pixelNumber] = image;
+//         }
+//     }
+// }
+
+//------------------------------------------------------------------------------
+
+float MLX90640_GetVdd(uint16_t *frameData, const paramsMLX90640 *params)
+{
+    float vdd;
+    float resolutionCorrection;
+
+    int resolutionRAM;    
+    
+    vdd = frameData[810];
+    if(vdd > 32767)
+    {
+        vdd = vdd - 65536;
+    }
+    resolutionRAM = (frameData[832] & 0x0C00) >> 10;
+    resolutionCorrection = pow(2, (double)params->resolutionEE) / pow(2, (double)resolutionRAM);
+    vdd = (resolutionCorrection * vdd - params->vdd25) / params->kVdd + 3.3;
+    
+    return vdd;
+}
+
+//------------------------------------------------------------------------------
+
+float MLX90640_GetTa(uint16_t *frameData, const paramsMLX90640 *params)
+{
+    float ptat;
+    float ptatArt;
+    float vdd;
+    float ta;
+    
+    vdd = MLX90640_GetVdd(frameData, params);
+    
+    ptat = frameData[800];
+    if(ptat > 32767)
+    {
+        ptat = ptat - 65536;
+    }
+    
+    ptatArt = frameData[768];
+    if(ptatArt > 32767)
+    {
+        ptatArt = ptatArt - 65536;
+    }
+    ptatArt = (ptat / (ptat * params->alphaPTAT + ptatArt)) * pow(2, (double)18);
+    
+    ta = (ptatArt / (1 + params->KvPTAT * (vdd - 3.3)) - params->vPTAT25);
+    ta = ta / params->KtPTAT + 25;
+    
+    return ta;
+}
+
+//------------------------------------------------------------------------------
+
+int MLX90640_GetSubPageNumber(uint16_t *frameData)
+{
+    return frameData[833];    
+
+}    
+
+//------------------------------------------------------------------------------
+void MLX90640_BadPixelsCorrection(uint16_t *pixels, float *to, int mode, paramsMLX90640 *params)
+{   
+    float ap[4];
+    uint8_t pix;
+    uint8_t line;
+    uint8_t column;
+    
+    pix = 0;
+    while(pixels[pix] != 0xFFFF)
+    {
+        line = pixels[pix]>>5;
+        column = pixels[pix] - (line<<5);
+        
+        if(mode == 1)
+        {        
+            if(line == 0)
+            {
+                if(column == 0)
+                {        
+                    to[pixels[pix]] = to[33];                    
+                }
+                else if(column == 31)
+                {
+                    to[pixels[pix]] = to[62];                      
+                }
+                else
+                {
+                    to[pixels[pix]] = (to[pixels[pix]+31] + to[pixels[pix]+33])/2.0;                    
+                }        
+            }
+            else if(line == 23)
+            {
+                if(column == 0)
+                {
+                    to[pixels[pix]] = to[705];                    
+                }
+                else if(column == 31)
+                {
+                    to[pixels[pix]] = to[734];                       
+                }
+                else
+                {
+                    to[pixels[pix]] = (to[pixels[pix]-33] + to[pixels[pix]-31])/2.0;                       
+                }                       
+            } 
+            else if(column == 0)
+            {
+                to[pixels[pix]] = (to[pixels[pix]-31] + to[pixels[pix]+33])/2.0;                
+            }
+            else if(column == 31)
+            {
+                to[pixels[pix]] = (to[pixels[pix]-33] + to[pixels[pix]+31])/2.0;                
+            } 
+            else
+            {
+                ap[0] = to[pixels[pix]-33];
+                ap[1] = to[pixels[pix]-31];
+                ap[2] = to[pixels[pix]+31];
+                ap[3] = to[pixels[pix]+33];
+                to[pixels[pix]] = GetMedian(ap,4);
+            }                   
+        }
+        else
+        {        
+            if(column == 0)
+            {
+                to[pixels[pix]] = to[pixels[pix]+1];            
+            }
+            else if(column == 1 || column == 30)
+            {
+                to[pixels[pix]] = (to[pixels[pix]-1]+to[pixels[pix]+1])/2.0;                
+            } 
+            else if(column == 31)
+            {
+                to[pixels[pix]] = to[pixels[pix]-1];
+            } 
+            else
+            {
+                if(IsPixelBad(pixels[pix]-2,params) == 0 && IsPixelBad(pixels[pix]+2,params) == 0)
+                {
+                    ap[0] = to[pixels[pix]+1] - to[pixels[pix]+2];
+                    ap[1] = to[pixels[pix]-1] - to[pixels[pix]-2];
+                    if(fabs(ap[0]) > fabs(ap[1]))
+                    {
+                        to[pixels[pix]] = to[pixels[pix]-1] + ap[1];                        
+                    }
+                    else
+                    {
+                        to[pixels[pix]] = to[pixels[pix]+1] + ap[0];                        
+                    }
+                }
+                else
+                {
+                    to[pixels[pix]] = (to[pixels[pix]-1]+to[pixels[pix]+1])/2.0;                    
+                }            
+            }                      
+        } 
+        pix = pix + 1;    
+    }    
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractVDDParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int16_t kVdd;
+    int16_t vdd25;
+    
+    kVdd = eeData[51];
+    
+    kVdd = (eeData[51] & 0xFF00) >> 8;
+    if(kVdd > 127)
+    {
+        kVdd = kVdd - 256;
+    }
+    kVdd = 32 * kVdd;
+    vdd25 = eeData[51] & 0x00FF;
+    vdd25 = ((vdd25 - 256) << 5) - 8192;
+    
+    mlx90640->kVdd = kVdd;
+    mlx90640->vdd25 = vdd25; 
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractPTATParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    float KvPTAT;
+    float KtPTAT;
+    int16_t vPTAT25;
+    float alphaPTAT;
+    
+    KvPTAT = (eeData[50] & 0xFC00) >> 10;
+    if(KvPTAT > 31)
+    {
+        KvPTAT = KvPTAT - 64;
+    }
+    KvPTAT = KvPTAT/4096;
+    
+    KtPTAT = eeData[50] & 0x03FF;
+    if(KtPTAT > 511)
+    {
+        KtPTAT = KtPTAT - 1024;
+    }
+    KtPTAT = KtPTAT/8;
+    
+    vPTAT25 = eeData[49];
+    
+    alphaPTAT = (eeData[16] & 0xF000) / pow(2, (double)14) + 8.0f;
+    
+    mlx90640->KvPTAT = KvPTAT;
+    mlx90640->KtPTAT = KtPTAT;    
+    mlx90640->vPTAT25 = vPTAT25;
+    mlx90640->alphaPTAT = alphaPTAT;   
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractGainParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int16_t gainEE;
+    
+    gainEE = eeData[48];
+    if(gainEE > 32767)
+    {
+        gainEE = gainEE -65536;
+    }
+    
+    mlx90640->gainEE = gainEE;    
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractTgcParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    float tgc;
+    tgc = eeData[60] & 0x00FF;
+    if(tgc > 127)
+    {
+        tgc = tgc - 256;
+    }
+    tgc = tgc / 32.0f;
+    
+    mlx90640->tgc = tgc;        
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractResolutionParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    uint8_t resolutionEE;
+    resolutionEE = (eeData[56] & 0x3000) >> 12;    
+    
+    mlx90640->resolutionEE = resolutionEE;
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractKsTaParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    float KsTa;
+    KsTa = (eeData[60] & 0xFF00) >> 8;
+    if(KsTa > 127)
+    {
+        KsTa = KsTa -256;
+    }
+    KsTa = KsTa / 8192.0f;
+    
+    mlx90640->KsTa = KsTa;
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractKsToParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int KsToScale;
+    int8_t step;
+    
+    step = ((eeData[63] & 0x3000) >> 12) * 10;
+    
+    mlx90640->ct[0] = -40;
+    mlx90640->ct[1] = 0;
+    mlx90640->ct[2] = (eeData[63] & 0x00F0) >> 4;
+    mlx90640->ct[3] = (eeData[63] & 0x0F00) >> 8;    
+    
+    mlx90640->ct[2] = mlx90640->ct[2]*step;
+    mlx90640->ct[3] = mlx90640->ct[2] + mlx90640->ct[3]*step;
+    mlx90640->ct[4] = 400;
+    
+    KsToScale = (eeData[63] & 0x000F) + 8;
+    KsToScale = 1 << KsToScale;
+    
+    mlx90640->ksTo[0] = eeData[61] & 0x00FF;
+    mlx90640->ksTo[1] = (eeData[61] & 0xFF00) >> 8;
+    mlx90640->ksTo[2] = eeData[62] & 0x00FF;
+    mlx90640->ksTo[3] = (eeData[62] & 0xFF00) >> 8;      
+    
+    for(int i = 0; i < 4; i++)
+    {
+        if(mlx90640->ksTo[i] > 127)
+        {
+            mlx90640->ksTo[i] = mlx90640->ksTo[i] - 256;
+        }
+        mlx90640->ksTo[i] = mlx90640->ksTo[i] / KsToScale;
+    } 
+    
+    mlx90640->ksTo[4] = -0.0002;
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractAlphaParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int accRow[24];
+    int accColumn[32];
+    int p = 0;
+    int alphaRef;
+    uint8_t alphaScale;
+    uint8_t accRowScale;
+    uint8_t accColumnScale;
+    uint8_t accRemScale;
+    float alphaTemp[768];
+    float temp;
+    
+
+    accRemScale = eeData[32] & 0x000F;
+    accColumnScale = (eeData[32] & 0x00F0) >> 4;
+    accRowScale = (eeData[32] & 0x0F00) >> 8;
+    alphaScale = ((eeData[32] & 0xF000) >> 12) + 30;
+    alphaRef = eeData[33];
+    
+    for(int i = 0; i < 6; i++)
+    {
+        p = i * 4;
+        accRow[p + 0] = (eeData[34 + i] & 0x000F);
+        accRow[p + 1] = (eeData[34 + i] & 0x00F0) >> 4;
+        accRow[p + 2] = (eeData[34 + i] & 0x0F00) >> 8;
+        accRow[p + 3] = (eeData[34 + i] & 0xF000) >> 12;
+    }
+    
+    for(int i = 0; i < 24; i++)
+    {
+        if (accRow[i] > 7)
+        {
+            accRow[i] = accRow[i] - 16;
+        }
+    }
+    
+    for(int i = 0; i < 8; i++)
+    {
+        p = i * 4;
+        accColumn[p + 0] = (eeData[40 + i] & 0x000F);
+        accColumn[p + 1] = (eeData[40 + i] & 0x00F0) >> 4;
+        accColumn[p + 2] = (eeData[40 + i] & 0x0F00) >> 8;
+        accColumn[p + 3] = (eeData[40 + i] & 0xF000) >> 12;
+    }
+    
+    for(int i = 0; i < 32; i ++)
+    {
+        if (accColumn[i] > 7)
+        {
+            accColumn[i] = accColumn[i] - 16;
+        }
+    }
+
+    for(int i = 0; i < 24; i++)
+    {
+        for(int j = 0; j < 32; j ++)
+        {
+            p = 32 * i +j;
+            alphaTemp[p] = (eeData[64 + p] & 0x03F0) >> 4;
+            if (alphaTemp[p] > 31)
+            {
+                alphaTemp[p] = alphaTemp[p] - 64;
+            }
+            alphaTemp[p] = alphaTemp[p]*(1 << accRemScale);
+            alphaTemp[p] = (alphaRef + (accRow[i] << accRowScale) + (accColumn[j] << accColumnScale) + alphaTemp[p]);
+            alphaTemp[p] = alphaTemp[p] / pow(2,(double)alphaScale);
+            alphaTemp[p] = alphaTemp[p] - mlx90640->tgc * (mlx90640->cpAlpha[0] + mlx90640->cpAlpha[1])/2;
+            alphaTemp[p] = SCALEALPHA/alphaTemp[p];
+        }
+    }
+    
+    temp = alphaTemp[0];
+    for(int i = 1; i < 768; i++)
+    {
+        if (alphaTemp[i] > temp)
+        {
+            temp = alphaTemp[i];
+        }
+    }
+    
+    alphaScale = 0;
+    while(temp < 32767.4)
+    {
+        temp = temp*2;
+        alphaScale = alphaScale + 1;
+    } 
+    
+    for(int i = 0; i < 768; i++)
+    {
+        temp = alphaTemp[i] * pow(2,(double)alphaScale);        
+        mlx90640->alpha[i] = (temp + 0.5);        
+        
+    } 
+    
+    mlx90640->alphaScale = alphaScale;      
+   
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractOffsetParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int occRow[24];
+    int occColumn[32];
+    int p = 0;
+    int16_t offsetRef;
+    uint8_t occRowScale;
+    uint8_t occColumnScale;
+    uint8_t occRemScale;
+    
+
+    occRemScale = (eeData[16] & 0x000F);
+    occColumnScale = (eeData[16] & 0x00F0) >> 4;
+    occRowScale = (eeData[16] & 0x0F00) >> 8;
+    offsetRef = eeData[17];
+    if (offsetRef > 32767)
+    {
+        offsetRef = offsetRef - 65536;
+    }
+    
+    for(int i = 0; i < 6; i++)
+    {
+        p = i * 4;
+        occRow[p + 0] = (eeData[18 + i] & 0x000F);
+        occRow[p + 1] = (eeData[18 + i] & 0x00F0) >> 4;
+        occRow[p + 2] = (eeData[18 + i] & 0x0F00) >> 8;
+        occRow[p + 3] = (eeData[18 + i] & 0xF000) >> 12;
+    }
+    
+    for(int i = 0; i < 24; i++)
+    {
+        if (occRow[i] > 7)
+        {
+            occRow[i] = occRow[i] - 16;
+        }
+    }
+    
+    for(int i = 0; i < 8; i++)
+    {
+        p = i * 4;
+        occColumn[p + 0] = (eeData[24 + i] & 0x000F);
+        occColumn[p + 1] = (eeData[24 + i] & 0x00F0) >> 4;
+        occColumn[p + 2] = (eeData[24 + i] & 0x0F00) >> 8;
+        occColumn[p + 3] = (eeData[24 + i] & 0xF000) >> 12;
+    }
+    
+    for(int i = 0; i < 32; i ++)
+    {
+        if (occColumn[i] > 7)
+        {
+            occColumn[i] = occColumn[i] - 16;
+        }
+    }
+
+    for(int i = 0; i < 24; i++)
+    {
+        for(int j = 0; j < 32; j ++)
+        {
+            p = 32 * i +j;
+            mlx90640->offset[p] = (eeData[64 + p] & 0xFC00) >> 10;
+            if (mlx90640->offset[p] > 31)
+            {
+                mlx90640->offset[p] = mlx90640->offset[p] - 64;
+            }
+            mlx90640->offset[p] = mlx90640->offset[p]*(1 << occRemScale);
+            mlx90640->offset[p] = (offsetRef + (occRow[i] << occRowScale) + (occColumn[j] << occColumnScale) + mlx90640->offset[p]);
+        }
+    }
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractKtaPixelParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int p = 0;
+    int8_t KtaRC[4];
+    int8_t KtaRoCo;
+    int8_t KtaRoCe;
+    int8_t KtaReCo;
+    int8_t KtaReCe;
+    uint8_t ktaScale1;
+    uint8_t ktaScale2;
+    uint8_t split;
+    float ktaTemp[768];
+    float temp;
+    
+    KtaRoCo = (eeData[54] & 0xFF00) >> 8;
+    if (KtaRoCo > 127)
+    {
+        KtaRoCo = KtaRoCo - 256;
+    }
+    KtaRC[0] = KtaRoCo;
+    
+    KtaReCo = (eeData[54] & 0x00FF);
+    if (KtaReCo > 127)
+    {
+        KtaReCo = KtaReCo - 256;
+    }
+    KtaRC[2] = KtaReCo;
+      
+    KtaRoCe = (eeData[55] & 0xFF00) >> 8;
+    if (KtaRoCe > 127)
+    {
+        KtaRoCe = KtaRoCe - 256;
+    }
+    KtaRC[1] = KtaRoCe;
+      
+    KtaReCe = (eeData[55] & 0x00FF);
+    if (KtaReCe > 127)
+    {
+        KtaReCe = KtaReCe - 256;
+    }
+    KtaRC[3] = KtaReCe;
+  
+    ktaScale1 = ((eeData[56] & 0x00F0) >> 4) + 8;
+    ktaScale2 = (eeData[56] & 0x000F);
+
+    for(int i = 0; i < 24; i++)
+    {
+        for(int j = 0; j < 32; j ++)
+        {
+            p = 32 * i +j;
+            split = 2*(p/32 - (p/64)*2) + p%2;
+            ktaTemp[p] = (eeData[64 + p] & 0x000E) >> 1;
+            if (ktaTemp[p] > 3)
+            {
+                ktaTemp[p] = ktaTemp[p] - 8;
+            }
+            ktaTemp[p] = ktaTemp[p] * (1 << ktaScale2);
+            ktaTemp[p] = KtaRC[split] + ktaTemp[p];
+            ktaTemp[p] = ktaTemp[p] / pow(2,(double)ktaScale1);
+            //ktaTemp[p] = ktaTemp[p] * mlx90640->offset[p];
+        }
+    }
+    
+    temp = fabs(ktaTemp[0]);
+    for(int i = 1; i < 768; i++)
+    {
+        if (fabs(ktaTemp[i]) > temp)
+        {
+            temp = fabs(ktaTemp[i]);
+        }
+    }
+    
+    ktaScale1 = 0;
+    while(temp < 63.4)
+    {
+        temp = temp*2;
+        ktaScale1 = ktaScale1 + 1;
+    }    
+     
+    for(int i = 0; i < 768; i++)
+    {
+        temp = ktaTemp[i] * pow(2,(double)ktaScale1);
+        if (temp < 0)
+        {
+            mlx90640->kta[i] = (temp - 0.5);
+        }
+        else
+        {
+            mlx90640->kta[i] = (temp + 0.5);
+        }        
+        
+    } 
+    
+    mlx90640->ktaScale = ktaScale1;           
+}
+
+
+//------------------------------------------------------------------------------
+
+void ExtractKvPixelParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    int p = 0;
+    int8_t KvT[4];
+    int8_t KvRoCo;
+    int8_t KvRoCe;
+    int8_t KvReCo;
+    int8_t KvReCe;
+    uint8_t kvScale;
+    uint8_t split;
+    float kvTemp[768];
+    float temp;
+
+    KvRoCo = (eeData[52] & 0xF000) >> 12;
+    if (KvRoCo > 7)
+    {
+        KvRoCo = KvRoCo - 16;
+    }
+    KvT[0] = KvRoCo;
+    
+    KvReCo = (eeData[52] & 0x0F00) >> 8;
+    if (KvReCo > 7)
+    {
+        KvReCo = KvReCo - 16;
+    }
+    KvT[2] = KvReCo;
+      
+    KvRoCe = (eeData[52] & 0x00F0) >> 4;
+    if (KvRoCe > 7)
+    {
+        KvRoCe = KvRoCe - 16;
+    }
+    KvT[1] = KvRoCe;
+      
+    KvReCe = (eeData[52] & 0x000F);
+    if (KvReCe > 7)
+    {
+        KvReCe = KvReCe - 16;
+    }
+    KvT[3] = KvReCe;
+  
+    kvScale = (eeData[56] & 0x0F00) >> 8;
+
+
+    for(int i = 0; i < 24; i++)
+    {
+        for(int j = 0; j < 32; j ++)
+        {
+            p = 32 * i +j;
+            split = 2*(p/32 - (p/64)*2) + p%2;
+            kvTemp[p] = KvT[split];
+            kvTemp[p] = kvTemp[p] / pow(2,(double)kvScale);
+            //kvTemp[p] = kvTemp[p] * mlx90640->offset[p];
+        }
+    }
+    
+    temp = fabs(kvTemp[0]);
+    for(int i = 1; i < 768; i++)
+    {
+        if (fabs(kvTemp[i]) > temp)
+        {
+            temp = fabs(kvTemp[i]);
+        }
+    }
+    
+    kvScale = 0;
+    while(temp < 63.4)
+    {
+        temp = temp*2;
+        kvScale = kvScale + 1;
+    }
+     
+    for(int i = 0; i < 768; i++)
+    {
+        temp = kvTemp[i] * pow(2,(double)kvScale);
+        if (temp < 0)
+        {
+            mlx90640->kv[i] = (temp - 0.5);
+        }
+        else
+        {
+            mlx90640->kv[i] = (temp + 0.5);
+        }        
+        
+    } 
+    
+    mlx90640->kvScale = kvScale;        
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractCPParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    float alphaSP[2];
+    int16_t offsetSP[2];
+    float cpKv;
+    float cpKta;
+    uint8_t alphaScale;
+    uint8_t ktaScale1;
+    uint8_t kvScale;
+
+    alphaScale = ((eeData[32] & 0xF000) >> 12) + 27;
+    
+    offsetSP[0] = (eeData[58] & 0x03FF);
+    if (offsetSP[0] > 511)
+    {
+        offsetSP[0] = offsetSP[0] - 1024;
+    }
+    
+    offsetSP[1] = (eeData[58] & 0xFC00) >> 10;
+    if (offsetSP[1] > 31)
+    {
+        offsetSP[1] = offsetSP[1] - 64;
+    }
+    offsetSP[1] = offsetSP[1] + offsetSP[0]; 
+    
+    alphaSP[0] = (eeData[57] & 0x03FF);
+    if (alphaSP[0] > 511)
+    {
+        alphaSP[0] = alphaSP[0] - 1024;
+    }
+    alphaSP[0] = alphaSP[0] /  pow(2,(double)alphaScale);
+    
+    alphaSP[1] = (eeData[57] & 0xFC00) >> 10;
+    if (alphaSP[1] > 31)
+    {
+        alphaSP[1] = alphaSP[1] - 64;
+    }
+    alphaSP[1] = (1 + alphaSP[1]/128) * alphaSP[0];
+    
+    cpKta = (eeData[59] & 0x00FF);
+    if (cpKta > 127)
+    {
+        cpKta = cpKta - 256;
+    }
+    ktaScale1 = ((eeData[56] & 0x00F0) >> 4) + 8;    
+    mlx90640->cpKta = cpKta / pow(2,(double)ktaScale1);
+    
+    cpKv = (eeData[59] & 0xFF00) >> 8;
+    if (cpKv > 127)
+    {
+        cpKv = cpKv - 256;
+    }
+    kvScale = (eeData[56] & 0x0F00) >> 8;
+    mlx90640->cpKv = cpKv / pow(2,(double)kvScale);
+       
+    mlx90640->cpAlpha[0] = alphaSP[0];
+    mlx90640->cpAlpha[1] = alphaSP[1];
+    mlx90640->cpOffset[0] = offsetSP[0];
+    mlx90640->cpOffset[1] = offsetSP[1];  
+}
+
+//------------------------------------------------------------------------------
+
+void ExtractCILCParameters(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    float ilChessC[3];
+    uint8_t calibrationModeEE;
+    
+    calibrationModeEE = (eeData[10] & 0x0800) >> 4;
+    calibrationModeEE = calibrationModeEE ^ 0x80;
+
+    ilChessC[0] = (eeData[53] & 0x003F);
+    if (ilChessC[0] > 31)
+    {
+        ilChessC[0] = ilChessC[0] - 64;
+    }
+    ilChessC[0] = ilChessC[0] / 16.0f;
+    
+    ilChessC[1] = (eeData[53] & 0x07C0) >> 6;
+    if (ilChessC[1] > 15)
+    {
+        ilChessC[1] = ilChessC[1] - 32;
+    }
+    ilChessC[1] = ilChessC[1] / 2.0f;
+    
+    ilChessC[2] = (eeData[53] & 0xF800) >> 11;
+    if (ilChessC[2] > 15)
+    {
+        ilChessC[2] = ilChessC[2] - 32;
+    }
+    ilChessC[2] = ilChessC[2] / 8.0f;
+    
+    mlx90640->calibrationModeEE = calibrationModeEE;
+    mlx90640->ilChessC[0] = ilChessC[0];
+    mlx90640->ilChessC[1] = ilChessC[1];
+    mlx90640->ilChessC[2] = ilChessC[2];
+}
+
+//------------------------------------------------------------------------------
+
+int ExtractDeviatingPixels(uint16_t *eeData, paramsMLX90640 *mlx90640)
+{
+    uint16_t pixCnt = 0;
+    uint16_t brokenPixCnt = 0;
+    uint16_t outlierPixCnt = 0;
+    int warn = 0;
+    int i;
+    
+    for(pixCnt = 0; pixCnt<5; pixCnt++)
+    {
+        mlx90640->brokenPixels[pixCnt] = 0xFFFF;
+        mlx90640->outlierPixels[pixCnt] = 0xFFFF;
+    }
+        
+    pixCnt = 0;    
+    while (pixCnt < 768 && brokenPixCnt < 5 && outlierPixCnt < 5)
+    {
+        if(eeData[pixCnt+64] == 0)
+        {
+            mlx90640->brokenPixels[brokenPixCnt] = pixCnt;
+            brokenPixCnt = brokenPixCnt + 1;
+        }    
+        else if((eeData[pixCnt+64] & 0x0001) != 0)
+        {
+            mlx90640->outlierPixels[outlierPixCnt] = pixCnt;
+            outlierPixCnt = outlierPixCnt + 1;
+        }    
+        
+        pixCnt = pixCnt + 1;
+        
+    } 
+    
+    if(brokenPixCnt > 4)  
+    {
+        warn = -3;
+    }         
+    else if(outlierPixCnt > 4)  
+    {
+        warn = -4;
+    }
+    else if((brokenPixCnt + outlierPixCnt) > 4)  
+    {
+        warn = -5;
+    } 
+    else
+    {
+        for(pixCnt=0; pixCnt<brokenPixCnt; pixCnt++)
+        {
+            for(i=pixCnt+1; i<brokenPixCnt; i++)
+            {
+                warn = CheckAdjacentPixels(mlx90640->brokenPixels[pixCnt],mlx90640->brokenPixels[i]);
+                if(warn != 0)
+                {
+                    return warn;
+                }    
+            }    
+        }
+        
+        for(pixCnt=0; pixCnt<outlierPixCnt; pixCnt++)
+        {
+            for(i=pixCnt+1; i<outlierPixCnt; i++)
+            {
+                warn = CheckAdjacentPixels(mlx90640->outlierPixels[pixCnt],mlx90640->outlierPixels[i]);
+                if(warn != 0)
+                {
+                    return warn;
+                }    
+            }    
+        } 
+        
+        for(pixCnt=0; pixCnt<brokenPixCnt; pixCnt++)
+        {
+            for(i=0; i<outlierPixCnt; i++)
+            {
+                warn = CheckAdjacentPixels(mlx90640->brokenPixels[pixCnt],mlx90640->outlierPixels[i]);
+                if(warn != 0)
+                {
+                    return warn;
+                }    
+            }    
+        }    
+        
+    }    
+    
+    
+    return warn;
+       
+}
+
+//------------------------------------------------------------------------------
+
+ int CheckAdjacentPixels(uint16_t pix1, uint16_t pix2)
+ {
+     int pixPosDif;
+     
+     pixPosDif = pix1 - pix2;
+     if(pixPosDif > -34 && pixPosDif < -30)
+     {
+         return -6;
+     } 
+     if(pixPosDif > -2 && pixPosDif < 2)
+     {
+         return -6;
+     } 
+     if(pixPosDif > 30 && pixPosDif < 34)
+     {
+         return -6;
+     }
+     
+     return 0;    
+ }
+ 
+//------------------------------------------------------------------------------
+ 
+float GetMedian(float *values, int n)
+ {
+    float temp;
+    
+    for(int i=0; i<n-1; i++)
+    {
+        for(int j=i+1; j<n; j++)
+        {
+            if(values[j] < values[i]) 
+            {                
+                temp = values[i];
+                values[i] = values[j];
+                values[j] = temp;
+            }
+        }
+    }
+    
+    if(n%2==0) 
+    {
+        return ((values[n/2] + values[n/2 - 1]) / 2.0);
+        
+    } 
+    else 
+    {
+        return values[n/2];
+    }
+    
+ }           
+
+//------------------------------------------------------------------------------
+
+int IsPixelBad(uint16_t pixel,paramsMLX90640 *params)
+{
+    for(int i=0; i<5; i++)
+    {
+        if(pixel == params->outlierPixels[i] || pixel == params->brokenPixels[i])
+        {
+            return 1;
+        }    
+    }   
+    
+    return 0;     
+}     
+
+//------------------------------------------------------------------------------
diff --git a/lib/mlx90640-library/MLX90640_API.h b/lib/mlx90640-library/MLX90640_API.h
new file mode 100644
index 000000000..efbcdff5b
--- /dev/null
+++ b/lib/mlx90640-library/MLX90640_API.h
@@ -0,0 +1,74 @@
+/**
+ * @copyright (C) 2017 Melexis N.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#ifndef _MLX90640_API_H_
+#define _MLX90640_API_H_
+
+#include <stdint.h>
+
+#define SCALEALPHA 0.000001
+    
+typedef struct
+    {
+        int16_t kVdd;
+        int16_t vdd25;
+        float KvPTAT;
+        float KtPTAT;
+        uint16_t vPTAT25;
+        float alphaPTAT;
+        int16_t gainEE;
+        float tgc;
+        float cpKv;
+        float cpKta;
+        uint8_t resolutionEE;
+        uint8_t calibrationModeEE;
+        float KsTa;
+        float ksTo[5];
+        int16_t ct[5];
+        uint16_t alpha[768];    
+        uint8_t alphaScale;
+        int16_t offset[768];    
+        int8_t kta[768];
+        uint8_t ktaScale;    
+        int8_t kv[768];
+        uint8_t kvScale;
+        float cpAlpha[2];
+        int16_t cpOffset[2];
+        float ilChessC[3]; 
+        uint16_t brokenPixels[5];
+        uint16_t outlierPixels[5];  
+    } paramsMLX90640;
+    
+    int MLX90640_DumpEE(uint8_t slaveAddr, uint16_t *eeData);
+    int MLX90640_SynchFrame(uint8_t slaveAddr);
+    // int MLX90640_TriggerMeasurement(uint8_t slaveAddr);
+    int MLX90640_GetFrameData(uint8_t slaveAddr, uint16_t *frameData);
+    int MLX90640_ExtractParameters(uint16_t *eeData, paramsMLX90640 *mlx90640,int _chunk);
+    float MLX90640_GetVdd(uint16_t *frameData, const paramsMLX90640 *params);
+    float MLX90640_GetTa(uint16_t *frameData, const paramsMLX90640 *params);
+    // void MLX90640_GetImage(uint16_t *frameData, const paramsMLX90640 *params, float *result);
+    void MLX90640_CalculateTo(uint16_t *frameData, const paramsMLX90640 *params, float emissivity, float tr, float *result, uint8_t _part);
+    int MLX90640_SetResolution(uint8_t slaveAddr, uint8_t resolution);
+    int MLX90640_GetCurResolution(uint8_t slaveAddr);
+    int MLX90640_SetRefreshRate(uint8_t slaveAddr, uint8_t refreshRate);   
+    int MLX90640_GetRefreshRate(uint8_t slaveAddr);  
+    int MLX90640_GetSubPageNumber(uint16_t *frameData);
+    int MLX90640_GetCurMode(uint8_t slaveAddr); 
+    int MLX90640_SetInterleavedMode(uint8_t slaveAddr);
+    int MLX90640_SetChessMode(uint8_t slaveAddr);
+    void MLX90640_BadPixelsCorrection(uint16_t *pixels, float *to, int mode, paramsMLX90640 *params);
+    
+#endif
diff --git a/tasmota/my_user_config.h b/tasmota/my_user_config.h
index 961a82e10..d74cecfe5 100644
--- a/tasmota/my_user_config.h
+++ b/tasmota/my_user_config.h
@@ -558,6 +558,7 @@
 //  #define USE_VEML7700                           // [I2cDriver50] Enable VEML7700 Ambient Light sensor (I2C addresses 0x10) (+4k5 code)
 //  #define USE_MCP9808                            // [I2cDriver51] Enable MCP9808 temperature sensor (I2C addresses 0x18 - 0x1F) (+0k9 code)
 //  #define USE_HP303B                             // [I2cDriver52] Enable HP303B temperature and pressure sensor (I2C address 0x76 or 0x77) (+6k2 code)
+//  #define USE_MLX90640                           // [I2cDriver53] Enable MLX90640 IR array temperature sensor (I2C address 0x33) (+4k9 code)
 
 //  #define USE_DISPLAY                            // Add I2C Display Support (+2k code)
     #define USE_DISPLAY_MODES1TO5                // Enable display mode 1 to 5 in addition to mode 0
diff --git a/tasmota/xdrv_84_MLX90640.ino b/tasmota/xdrv_84_MLX90640.ino
new file mode 100644
index 000000000..a1016c917
--- /dev/null
+++ b/tasmota/xdrv_84_MLX90640.ino
@@ -0,0 +1,626 @@
+/*
+  xdrv_84_MLX90640.ino - MLX90640 support for Tasmota
+
+  Copyright (C) 2020  Christian Baars and Theo Arends
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+  --------------------------------------------------------------------------------------------
+  Version yyyymmdd  Action    Description
+  --------------------------------------------------------------------------------------------
+  0.9.0.0 20200827  started - based on https://github.com/melexis/mlx90640-library
+*/
+
+#ifdef USE_I2C
+#ifdef USE_MLX90640
+
+#define MLX90640_ADDRESS        0x33
+#define MLX90640_POI_NUM        6       //some parts of the JS are hardcoded for 6!!
+
+/*********************************************************************************************\
+* MLX90640
+\*********************************************************************************************/
+
+#define XDRV_84             84
+#define XI2C_53             53 // See I2CDEVICES.md
+#include <MLX90640_API.h>
+
+const char MLX90640type[] PROGMEM = "MLX90640";
+
+#ifdef USE_WEBSERVER
+#define WEB_HANDLE_MLX90640 "mlx"
+const char HTTP_BTN_MENU_MLX90640[] PROGMEM = "<p><form action='" WEB_HANDLE_MLX90640 "' method='get'><button>MLX90640</button></form></p>";
+#endif // USE_WEBSERVER
+
+struct {
+  uint32_t type:1;
+  uint32_t ready:1;
+  uint32_t dumpedEE:1;
+  uint32_t extractedParams:1;
+  paramsMLX90640 *params;
+  float Ta;
+  uint16_t Frame[834];
+  float To[768];
+  uint8_t pois[2*MLX90640_POI_NUM] = {2,1, 30,1, 10,12, 22,12, 2,23, 30,23}; // {x1,y1,x2,y2,...,x6,y6}
+} MLX90640;
+
+/*********************************************************************************************\
+ * commands
+\*********************************************************************************************/
+
+#define D_CMND_MLX90640 "MLX"
+
+const char S_JSON_MLX90640_COMMAND_NVALUE[] PROGMEM = "{\"" D_CMND_MLX90640 "%s\":%d}";
+const char S_JSON_MLX90640_COMMAND[] PROGMEM        = "{\"" D_CMND_MLX90640 "%s\"}";
+const char kMLX90640_Commands[] PROGMEM             = "POI";
+
+enum MLX90640_Commands {                            // commands useable in console or rules
+  CMND_MLX90640_POI                                 // MLXPOIn xxyy - set POI number n to x,y
+  };
+
+/************************************************************************\
+ * Web GUI
+\************************************************************************/
+#ifdef USE_WEBSERVER
+
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_1_SNS_SIZE = 389;
+const char HTTP_MLX90640_1_SNS_COMPRESSED[] PROGMEM = "\x3D\x3C\x1F\xF4\x65\x2A\x2B\x32\x18\xCF\x87\xDD\x33\x65\x1D\x86\xBB\x33\xB0\x41"
+                             "\xA4\x7D\x9F\x81\xE7\x7A\x90\xDB\x18\x7C\x3B\xA6\x76\x10\xB6\x75\x1B\x0E\x43\xA8"
+                             "\x8C\x8E\x43\xA8\x8D\x87\x28\xEA\x23\x23\x94\x77\x8F\x87\xE1\x02\x0D\x13\xAC\xD8"
+                             "\x72\x1D\xE3\xD6\x77\x48\xC8\xE5\x1D\x64\x6C\x39\x47\x78\xEC\x3B\xA4\x64\x72\x1D"
+                             "\x64\x6C\x39\x0E\xF1\xDB\x23\x61\xCA\x3C\x10\x20\xE3\x3A\x36\xC7\x9A\x3E\x2E\x63"
+                             "\xE8\xB4\x6D\x8F\x33\xC1\x9D\xFD\x07\x7C\x67\x7E\x3A\x83\xA3\x61\xD4\x3D\xF1\x0F"
+                             "\x06\x77\xF4\x3C\x43\x0D\x87\x50\xCC\xD3\xE1\xEF\x1E\xF9\xE0\xCE\xFE\xBE\x56\x7C"
+                             "\x3D\xE3\xDF\x3C\x18\x17\xC1\xD6\xE7\x21\xE7\x44\x37\x05\xF9\x90\xCC\xF1\xDD\x04"
+                             "\x2C\x65\x33\x3A\x3B\xC8\xF6\x82\x0E\x87\xF6\x1D\x23\xE0\x21\x66\x87\x41\xE7\x44"
+                             "\x3B\x05\xF0\x9B\xC3\xC4\x18\x5A\xFA\x8B\xEC\x3A\x3B\xA7\x78\xF0\x67\x7F\x46\xC4"
+                             "\x7C\x4C\xCE\x8E\x81\x85\xAF\xA8\x8D\x87\x5F\xD8\x74\x74\x09\x98\xA3\xC6\x98\x3B"
+                             "\xA6\xC3\xF0\xE5\xD3\x3B\xC7\xB4\x8D\x87\xC3\x97\x11\xE0\xF7\x17\xDD\x0B\xFF\x23"
+                             "\xDA\x6C\x3C\xD1\x0D\xBA\x14\x74\x30\x16\x67\xCE\xE8\xDB\x18\x77\x4D\x87\x51\xC6"
+                             "\x75\x5D\x33\xA9\x9D\x57\x0E\x88\xEF\x1D\xE3\xA8\x8C\x81\x32\xF9\xDD\x04\x5D\x04"
+                             "\x8C\x91\xD6\xBE\xC3\xA3\xA5\x60\xC3\xBC\x75\x1C\x67\x55\x63\x3A\x99\xD5\x56\x74"
+                             "\x47\x78\xEF\x1E\xE3\xC1\xEE";
+#define  HTTP_MLX90640_1_SNS       Decompress(HTTP_MLX90640_1_SNS_COMPRESSED,HTTP_MLX90640_1_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_1_SNS[] PROGMEM =
+    "<script type='text/javascript'>"
+        "const map=(value,x1,y1,x2,y2)=>(value-x1)*(y2-x2)/(y1-x1)+x2;"
+        "const image = new Image;"
+        "var canvas,ctx,grd;"
+        "var gPx,poi=[];var rA=[];" //gradient pixel, POI's, rawArray
+    "function getMousePos(canvas, evt) {"
+        "const rect = canvas.getBoundingClientRect();"
+        "var x = evt.clientX-rect.left;"
+        "if(x>320){"
+          "x=319;"
+        "}"
+        "return {"
+          "x: Math.floor(map(x,0,320,0,31.9)),"
+          "y: Math.floor(map((evt.clientY - rect.top),0,240,0,23.9))};"
+        "}"
+  ;
+#endif //USE_UNISHOX_COMPRESSION
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_2a_SNS_SIZE = 632;
+const char HTTP_MLX90640_2a_SNS_COMPRESSED[] PROGMEM = "\x33\xBF\xA0\xB7\x9A\x3E\x23\x8C\xF0\x5E\x74\x5B\xD4\xFE\x67\x61\x1D\xD3\x02\xF8"
+                             "\x3A\xDC\xE3\xBA\x77\x91\xED\xF8\x47\x74\xFB\x16\x11\xF6\x75\x05\xBC\xCE\xF1\xE0"
+                             "\xF7\x1D\x47\x29\xB3\xBC\x78\x20\x43\xBA\xBE\x11\xDD\xF1\xD4\x66\x77\x8F\x69\x9D"
+                             "\xFD\x1B\x3E\x7C\xE6\x3E\x88\xD8\x43\x48\x22\x15\x54\x30\xBE\xCD\x42\xDF\xA8\xEE"
+                             "\x9D\xE3\xC1\xB3\xE7\x4C\xEF\xBB\x10\xCB\xD5\x74\xC3\x15\x7C\x3C\xCF\x80\x8B\xA0"
+                             "\x1E\xDD\x30\x77\x4D\x9F\x3A\x7D\xD8\x86\x45\xEA\xBA\x67\xC3\xE1\xCC\x3F\x47\xE8"
+                             "\x8D\x9F\x3A\x7A\xAE\x85\xF8\xF8\x7C\x39\x4D\x90\x20\xE7\xD6\x43\x91\xF1\x1B\x3E"
+                             "\x74\xFB\xF0\xCC\xEF\x33\xC1\x9D\xFD\x69\xE3\x4C\x23\xBB\x64\x38\xE8\x38\xCA\x99"
+                             "\x04\xF8\x7A\x85\x1F\x0F\x87\x2B\x99\xDE\x3B\x87\xB4\x8C\xEF\xE8\xC1\x5A\x3E\x2E"
+                             "\x63\xE8\x8C\x05\x97\x47\x2E\x88\xAF\xFF\xB3\x23\xBB\x64\x38\xEF\x1E\x02\xDE\x67"
+                             "\xC3\x05\x67\xBC\x71\x9E\xF9\xE0\xB4\xC1\xDD\x0B\x79\x9F\x87\x23\x6C\xEF\x1E\xD2"
+                             "\x0B\x79\x9F\x02\xDE\x67\x59\xC8\xDB\x3C\x13\x1C\x77\x4F\xBB\x39\x0F\xB3\xBC\x74"
+                             "\x2D\xEE\x7F\x21\x45\x44\x34\x82\x3E\x05\xBC\xCE\x95\x84\x63\x4D\x8C\x43\xBA\x72"
+                             "\x88\x10\xB2\x73\x8C\xF7\x11\x8C\xFA\x3B\xBA\x7C\x39\x0F\x07\x70\xB5\x1E\x88\xC1"
+                             "\x59\xD0\x27\xC3\xD4\x28\xF0\xB4\xED\x9D\xB3\xBC\x8F\x6A\xF9\x59\xEF\x69\xDB\x3B"
+                             "\xA1\x6F\x33\xD6\x73\xB0\xEF\x1D\x70\xF7\xCE\xE1\xF0\xEE\x11\x82\xB3\xDE\xD3\xDF"
+                             "\x3C\x1E\xE0\x42\xE3\x90\x2D\xE6\x76\xCE\x42\x04\x5D\xB0\xE4\x3B\xC7\x70\x81\x07"
+                             "\x6B\x38\xCF\x04\x37\x3C\x77\x4E\xF1\xE0\xF7\x1E\xE0\x4E\xE1\x28\xE4\xA2\x04\x1E"
+                             "\x1F\x0C\x8F\x9C\xC7\xD1\x0B\xDE\xA3\x9F\x20\x45\xE1\x0C\x10\xB7\x13\x8C\x81\x07"
+                             "\x71\x32\x04\x8D\xC0\xF6\x8C\xCD\x3D\xED\x3B\x0E\x51\xEF\x9F\x0F\x78\x8C\x8F\x7B"
+                             "\x4F\x7C\xEA\x46\x47\xBD\xA8\xED\xA3\x90\xF7\xCF\x7C\xF0\x77\x0E\xD9\xDB\x2D\x3C"
+                             "\x1E\xE3\xDC\x7B\x8F\x07\xB8\xF0\x08\xDC\x67\x15\x19\x0C\x68\xF8\x8F\xBB\xFF\xEC"
+                             "\xC8\x70\xB3\x06\x1F\xCF\xB3\xC1\xB3\xE7\x4C\x18\xF8\xEE\x9F\x64\x3C\x4C\xA8\xFB"
+                             "\x3A\x8F\xB3\xB0\x68\x46\xC3\xB4\x7D\x9D\xBF\x1D\xB3\xEC\xF8\x7D\x9D\xB3\x33\xAA"
+                             "\xBE\x2D\x9D\xE3\xC1\xB3\xE7\x4F\x3E\x10\xEE\x9D\xE3\xC1\xEE\x3C\x1B";
+#define  HTTP_MLX90640_2a_SNS       Decompress(HTTP_MLX90640_2a_SNS_COMPRESSED,HTTP_MLX90640_2a_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_2a_SNS[] PROGMEM =
+  "var line = 0;"
+  "setInterval(function() {"                
+  "rl('ul',line);"   // 0 = do NOT force refresh
+  "},200);"
+  "function rl(s,v){"         //source, value
+    "var xr=new XMLHttpRequest();"
+    "xr.onreadystatechange=function(){"
+      "if(xr.readyState==4&&xr.status==200){"
+            "var aB = xr.response;" // arrayBuffer
+            "var i;"
+            "if (aB.byteLength==260) {" // 2 lines of pixel data
+              "var fA = new Float32Array(aB);" //floatArray
+              "line=fA[0];"
+              "if(line>1000){line=line-1000;eb('a1').innerHTML=line.toFixed(2);line=0}" //ambient hack
+              "for (i=1; i < fA.length; i++) { "
+                "rA[i+(line*64)-1] = fA[i];"
+              "}"
+              "line = line+1;"
+              "if(line>11) {line=0;mos();"
+              //"console.log(rA);"
+              "}"
+            "}"
+            "if (aB.byteLength==12)"
+              "{var y=new Uint8Array(aB);"
+            	"for (i=0; i < y.length; i++){"
+                "poi[i/2]=[y[i], y[i + 1]]; ++i;"
+              "}"
+            "}"
+        "};"
+      "};"
+    "xr.responseType = 'arraybuffer';"
+    "xr.open('GET','/mlx?'+s+'='+v,true);"
+    "xr.send();"
+    "};"
+  ;
+#endif //USE_UNISHOX_COMPRESSION
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_2b_SNS_SIZE = 389;
+const char HTTP_MLX90640_2b_SNS_COMPRESSED[] PROGMEM = "\x30\x2F\x83\xAD\xCE\x43\x73\xC7\x74\xEF\x1E\xD3\x3B\xFA\xCF\x06\x8F\x88\x4C\x0C"
+                             "\x58\xD7\xD4\x74\x0F\xEE\xE9\x93\x09\x8D\x7D\x47\x74\xFB\x0E\xF8\xCE\xFC\x7D\x9D"
+                             "\xE3\xC6\x78\x33\xA0\xFE\x89\x42\x91\xF1\x1C\xBA\x3C\x16\x78\x33\xA0\xA7\xA3\xC2"
+                             "\xA9\x1F\x11\xCA\xC3\xC1\x19\xDF\xD6\x07\x46\xC4\x7C\x59\xE0\xCE\x83\xCE\x88\x3C"
+                             "\xEA\x66\xCA\x3B\xA7\xD9\xCA\x21\x0F\xB3\xBC\x78\x31\x9F\x47\x74\xCE\xFE\xB4\xF8"
+                             "\x71\x9E\x0B\x4F\x43\x95\x87\x82\xD3\xB6\x76\xCE\xF1\xED\x04\x4A\x66\xB3\xE1\xC6"
+                             "\x78\x23\x59\xE8\x72\xE8\xF0\x46\xB3\xB6\x76\xC1\x07\x74\x32\x47\xC4\x72\xAD\x1D"
+                             "\xC3\xAC\xEE\x11\x0D\xBA\x14\x74\x30\x16\x67\xCE\xE8\xDB\x18\x77\x7E\x56\x7B\xC7"
+                             "\x77\x4F\x59\xCB\xA3\xBC\x76\xC8\xD6\x7B\xE7\x51\xC6\x75\x63\x3A\x99\xD5\x56\x8E"
+                             "\xF1\xDE\x3C\x16\x07\x46\xC3\xA1\x8D\x08\x22\xF5\x19\x04\xD1\xF1\x1F\x7F\x1E\x1C"
+                             "\x77\x4F\xB4\x76\xD0\xF1\x0C\x36\x1D\x04\xBA\xB3\xDE\x3B\xA6\x47\xAC\xE6\x1D\xE3"
+                             "\xDF\x3B\x87\x6C\xEE\x1F\x67\x51\x02\x6D\x43\xB6\x72\x1E\xF9\xDC\x3B\x64\x0A\x15"
+                             "\x4E\x51\xEF\x9D\xC3\xB6\x77\x0F\xB3\xBC\x7D\x90\x22\xE7\xE5\xF6\x1D\x1D\xD3\x59"
+                             "\xEB\x39\x0E\xA2\xD3\xD6\x72\x1D\x50\xEA\x87\x78\xF0\x7B\x8F\x71\x68\xDB\x1E\x67"
+                             "\x4F\x7C\x34\x7C\xCF\x06\x74\xAC\x21\x2E\xAC\x85\x97\xC8\x23\xBA\x7D\xE8\xDB\x1E"
+                             "\x67\x60\xCE\x1E\x3E\xCE\xF1\xE0\xF7\x1B";
+#define  HTTP_MLX90640_2b_SNS       Decompress(HTTP_MLX90640_2b_SNS_COMPRESSED,HTTP_MLX90640_2b_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_2b_SNS[] PROGMEM =
+  "function mos(){" //map off screen"
+      "var osc = document.createElement('canvas');" //offscreen
+      "osc.width = 32;"
+      "osc.height = 24;"
+          "var octx = osc.getContext('2d');"
+          "for (var i=0;i<24;i++){"
+              "for (var j=0;j<32;j++){"
+                  "var y = 239 - Math.floor(map(rA[(i*32)+j],0,40,0,239));" // 40 is max. temp for heat map
+                  // console.log(gPx.data[y],gPx.data[y+1],gPx.data[y+2]);
+                  "octx.fillStyle = 'rgb(' + gPx.data[(y*4)] + ',' + gPx.data[(y*4)+1] +',' + gPx.data[(y*4)+2] + ')';"                  
+                  "octx.fillRect(j*1,i*1,1,1);"
+              "}"
+      "}"
+      "image.src =osc.toDataURL('image/png');"
+  "}"
+   ;
+#endif //USE_UNISHOX_COMPRESSION
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_3a_SNS_SIZE = 664;
+const char HTTP_MLX90640_3a_SNS_COMPRESSED[] PROGMEM = "\x30\x2F\x83\xAD\xCE\x43\x33\x48\x43\xBA\x77\x8F\x68\xF7\xC4\x21\x0E\xE9\xDE\x3C"
+                             "\x07\x46\xC3\xA0\xF0\x58\x3A\xC2\x20\xF0\x68\xCC\xF6\xD3\x2C\x18\xFF\x75\xB9\xC8"
+                             "\xF8\x8F\xBF\x60\xBF\x86\xCE\xBC\x33\x7F\x3E\xCF\x06\x77\xF5\xF2\xC4\x7C\x5C\xC7"
+                             "\xD1\x7E\xF8\x79\x9D\xD3\xBC\x78\xF9\x61\xD3\xCC\x26\x1D\x17\x60\x8C\x83\xCE\xA7"
+                             "\xD5\xE3\xBA\xC7\x1D\xD3\xEC\x69\xCA\x3E\xCE\xF1\xDE\x3C\x17\xCB\x0E\x82\x30\x9D"
+                             "\x02\x2D\x83\xBC\x78\x31\x9F\x3B\xA6\x77\xF4\x31\x6F\x21\x99\xA7\x78\xF6\x99\xDF"
+                             "\xD0\x67\xC3\x93\x59\xE0\xB4\xC1\xDD\x63\x8E\xE9\xF6\x33\x34\x82\x3E\xCE\xF1\xD0"
+                             "\xCE\xC2\x16\xCF\x87\xC1\x87\x78\xF6\x86\x7C\x39\x5B\xA7\x83\xDC\x41\xD1\xB0\xE8"
+                             "\x63\x42\x08\xBD\x46\x41\x34\x7C\x47\xDF\xC7\x87\x59\xDD\x3E\xCE\xD8\x67\x6C\xFB"
+                             "\x3A\x81\x06\x10\x20\xC2\x38\xCE\x9C\x77\x8F\xB3\xC1\x07\x46\xC3\xA0\xE6\x3D\xBC"
+                             "\x43\x2E\x85\x02\x17\x09\x77\xF0\xCE\xE8\xCC\xD3\xDE\x18\x7B\xE7\xBC\x71\x9E\xF9"
+                             "\xDB\x67\x4D\x3A\x8E\xE1\x02\x14\xB3\x90\x81\x06\x59\xC8\x75\x33\xAA\x8F\x59\x10"
+                             "\xDB\xA1\x47\x42\x18\x5A\x08\x38\x81\x8D\x08\x20\x42\xC6\xCC\x67\x52\x3E\x23\xEC"
+                             "\xE4\x3A\x69\x0C\x36\x22\x33\x7F\x12\xFA\xCF\xB3\xC1\xB0\xF8\x32\xFF\xE6\x5B\xD4"
+                             "\x77\x46\x1D\xE3\xB6\x72\x10\x22\x62\x45\x4C\xD9\x47\x74\xD8\x08\x99\xF9\xC6\x7B"
+                             "\xE7\x6E\x10\x24\xE9\xC7\x21\xD2\x8E\xF1\xE0\x8C\xEF\xEB\xB0\x46\x8F\x88\x4C\x0C"
+                             "\x58\xD7\xD4\x74\x0F\xEE\xE9\x93\x09\x8D\x7D\x47\x74\xFB\x20\x8B\x4F\xB0\x41\xC1"
+                             "\x29\x9B\x28\x14\x70\x82\xA6\x6C\xA2\xEC\x11\x9D\xD3\xEC\x86\x16\x16\x9D\x67\xDA"
+                             "\x3B\x68\xD8\x8E\xDA\x3E\xCF\x34\x8F\xB4\x76\xD2\x3B\xBF\x2B\x3D\xE0\x43\xE1\x58"
+                             "\xE4\x3D\xF3\xD7\x74\x77\x8E\xD9\x02\x26\xE4\x7B\xE7\x78\xE9\x58\x46\x34\xD8\xC4"
+                             "\x3B\xA7\x28\xEF\x1D\xC3\xB6\x77\x0F\xB3\xB8\x53\x1D\x99\x79\x06\xAE\x91\x0C\xCF"
+                             "\x1E\x68\xFB\x47\x6C\x11\x78\x1D\x47\x6D\x1F\x68\xEA\x04\x7A\x07\x21\xEF\x9D\xE3"
+                             "\xC1\x76\x08\xCE\x96\x30\x63\xE1\x08\x31\x5A\x10\x87\x74\x10\xF8\x03\x3B\xC7\x80"
+                             "\x43\xE5\xA0\x12\x2D\x82\x0D\x73\xDC\x7B\x8D";
+#define  HTTP_MLX90640_3a_SNS       Decompress(HTTP_MLX90640_3a_SNS_COMPRESSED,HTTP_MLX90640_3a_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_3a_SNS[] PROGMEM =
+  	"function poiD(){" //poi draw
+          "grdD();"
+          "ctx.globalCompositeOperation = 'source-over';"
+			    "var rO = new Range();" //rangeObject
+			    "rO.selectNodeContents(eb('m2'));"
+			    "rO.deleteContents();"
+  				"for(var p in poi){"
+  					//"console.log('poi:'+ poi[p][0]);"
+            "var c=150;" 
+            "if(eb('poiL').value==p){c=255;}"
+            // "console.log(c);"
+            "ctx.fillStyle = 'rgba('+c+','+c+','+c+',0.6)';"
+            "ctx.beginPath();"
+            "ctx.arc(poi[p][0]+0.5, poi[p][1]+0.5,1,0,2*Math.PI);"
+            "ctx.fill();"
+            "ctx.font = '1.5px Verdana';"
+            "x=parseInt(p)+1;"
+            "ctx.fillText(x, poi[p][0]+1.5, poi[p][1]+1.2);"
+            "var node = document.createElement('LI');"
+            "var textnode = document.createTextNode('POI-' + x + ':  ' +  (rA[(poi[p][1]*32)+poi[p][0]]).toFixed(2) + ' °C at Pos: ' + poi[p][0] + ' , ' + poi[p][1]);"
+            "node.appendChild(textnode);"
+            "eb('m2').appendChild(node);"
+  				"}"
+  			"}"
+    ;
+#endif //USE_UNISHOX_COMPRESSION
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_3b_SNS_SIZE = 477;
+const char HTTP_MLX90640_3b_SNS_COMPRESSED[] PROGMEM = "\x30\x2F\x83\xAD\xCE\x5E\x74\x2C\x61\xDD\x3B\xC7\xB7\xE1\x1D\xD3\xEC\x58\xC3\xEC"
+                             "\xEA\x38\xCE\xF1\xE0\x83\xBE\x33\xBF\x23\xE2\x63\x8E\xE9\xF6\x34\x23\x61\xF6\x77"
+                             "\x8F\x01\xD1\xB1\x1F\x10\x20\xD5\x3A\x0F\x3A\x20\xF3\xA9\x9B\x28\xEE\x9F\x67\x28"
+                             "\x84\x3E\xC1\x0F\x0D\x3A\x58\x82\x13\x33\x7D\x44\x16\xFA\x9F\x3F\x9D\xD3\xEC\x6E"
+                             "\x0B\xF3\x1B\x86\x6C\xFB\x3A\x90\x21\xE9\xC7\x75\x99\xD1\xDE\x47\xB4\xCE\xFE\x86"
+                             "\x90\xC4\x7C\x43\xCE\x88\x6E\x0B\xF3\x21\x99\xE3\xBA\x08\x39\x29\xD4\x99\x9D\x1D"
+                             "\xE3\xC3\x1C\x77\x4F\xB1\xA7\x21\xF6\x77\x8E\x85\xBD\xCF\xE4\x28\xA8\x86\x90\x48"
+                             "\xF8\x8F\xB2\xA6\x34\x63\xFD\xD0\xBF\xB3\xCD\x1F\x68\xED\xA3\xBB\xF2\xB3\xDE\x3B"
+                             "\xA3\x48\x61\xD0\xC8\xF5\x9C\xBA\x3B\xC7\x6C\x86\x90\xC3\xA1\xB0\xF7\xCE\x95\x84"
+                             "\x63\x4D\x8C\x43\xBA\x72\x8E\xF1\xDE\x3B\x87\x6C\xEE\x1F\x67\x70\xAE\x91\x0C\xCF"
+                             "\x02\x0E\x18\x34\x86\x1D\x0D\x88\xED\xA3\xED\x1D\x40\x87\x2C\xC8\xF0\x7B\x81\x6F"
+                             "\x82\x01\x30\x7F\x81\x4B\x82\x02\x10\x15\xF8\x20\x33\xBF\xAD\x10\xD8\x08\x5C\x54"
+                             "\x0C\xCD\x20\x8F\xB3\xBC\x74\x33\xB0\x85\xB3\xC0\xCC\xD3\xDE\xD1\x0D\x87\xBE\x7B"
+                             "\xC7\x19\xEF\x9F\x08\x69\x08\x74\x36\x02\x2C\xD3\x90\xF7\xCF\x84\x34\x84\x3A\x19"
+                             "\x1E\x06\xE7\x8E\xE9\xDE\x3C\x02\x1F\x1E\xA0\x97\x8E\x9E\xB3\x91\xB6\xCE\xD9\xDD"
+                             "\x21\xA4\x21\xD0\xD8\x7A\xCE\x46\xCE\xF1\xDB\x21\xA4\x21\xD0\xC8\xEF\x1E\x0F\x71"
+                             "\xDE\x3C\x1B";
+#define  HTTP_MLX90640_3b_SNS       Decompress(HTTP_MLX90640_3b_SNS_COMPRESSED,HTTP_MLX90640_3b_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_3b_SNS[] PROGMEM =
+      "function setup(){"
+        "rl('up',0);"
+        "canvas = eb('mlx');"
+		    "ctx = canvas.getContext('2d');"
+        "canvas.addEventListener('mousemove', function(evt) {"
+          "var mP = getMousePos(canvas, evt);"
+          // console.log((mP.y*32)+mP.x);
+          "eb('m1').innerHTML = 'Temperature: ' + (rA[(mP.y*32)+mP.x].toFixed(2)) + ' at Pos: ' + mP.x + ' , ' + mP.y;"
+        "});"
+        "canvas.addEventListener('mousedown', function(evt) {"
+          "var mD = getMousePos(canvas, evt);"
+          "var idx = eb('poiL').value;"
+          "poi[idx][0]=mD.x;"
+          "poi[idx][1]=mD.y;"
+		      //"console.log(poi);"
+		      "mos();"
+          "rl('up',eb('poiL').value*10000+(mD.x*100)+mD.y);" //poi-1: 2,14 -> 10214
+        "});"
+  ;
+#endif //USE_UNISHOX_COMPRESSION
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_4a_SNS_SIZE = 468;
+const char HTTP_MLX90640_4a_SNS_COMPRESSED[] PROGMEM = "\xD3\x08\xEE\x87\x7C\x67\x7E\x3A\x0F\x3A\x20\xF3\xA9\x9B\x28\xEF\x23\xDA\x1D\x1B"
+                             "\x0E\x9E\x0E\xC2\x67\x74\xE4\x67\x54\x67\x78\xF0\x41\xD1\xB0\xE9\xA3\x6C\x79\x97"
+                             "\x86\xE6\x50\xAD\xE1\xE2\x7D\x63\x82\x62\x23\xE2\xAF\x8B\x67\x81\xEF\x88\x8F\x88"
+                             "\x3A\x36\x1D\x03\xFB\xBA\x64\x16\xF3\xBF\x90\xF7\xEC\x4D\x7D\x47\x74\xE3\x3A\x8E"
+                             "\xE3\x3A\x8E\xE3\x3A\x8E\xE5\x61\xDE\x3C\x10\xF7\xC4\x3A\x58\x82\x10\x78\x16\x7C"
+                             "\xBD\x58\x30\xEE\x9C\x67\x51\xDC\x3E\xC8\xC9\x84\x16\x0F\x9F\x60\x9D\x68\xE8\x71"
+                             "\xFB\x4E\xA3\xB8\x7D\x96\x7E\xF8\x79\x82\x85\xD3\x95\xA7\x51\xDC\x3E\xC8\xCF\x70"
+                             "\x27\x40\xA1\x70\xE6\x69\xD4\x77\x0F\xB2\x12\xFE\x68\x38\x21\x60\xA1\x8F\x1C\x87"
+                             "\x51\xDC\x3E\xC8\x70\x56\x19\xA0\x20\xD9\x21\x0E\xE9\xDE\x3C\x0F\x10\xC3\x60\x21"
+                             "\x70\x5A\x3C\xE8\xB4\x6D\x8F\x32\x12\xEA\xCE\xE9\xCB\xAD\x3A\x8E\xE3\x3A\x8E\xE4"
+                             "\x3A\xAA\xD1\xDE\x3C\x10\xDC\xF1\xDD\x3B\xC7\x8D\x1B\x63\xCC\xE9\x9C\x16\x58\x88"
+                             "\xF8\x8C\x0B\xE0\xEB\x73\x91\xDD\x04\x2E\x29\xC4\xFD\x8F\x96\x8D\xB1\xE6\x77\x74"
+                             "\x6D\x8F\x33\xA8\xE3\x3A\x99\xD5\x74\x75\x56\x1D\xE3\xC1\x0C\xCD\x21\x0E\xE9\xDE"
+                             "\x3C\x1E\xE3\xDC\x7B\x81\x13\x12\x04\x1D\x74\xF6\x87\x46\xC3\xA1\x8D\x08\x22\xF5"
+                             "\x19\x04\xD1\xF1\x0F\x7C\x43\xC0\x21\xD0\x2F\xB0\xE8\xEE\x9C\xBA\x20\x41\xE2\xB8"
+                             "\xEA\x39\x58\x77\x8F\x07\xB8\xF4\x3B\x0B\xC1\xFF\x46\x51\xF8";
+#define  HTTP_MLX90640_4a_SNS       Decompress(HTTP_MLX90640_4a_SNS_COMPRESSED,HTTP_MLX90640_4a_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_4a_SNS[] PROGMEM =
+        "if (canvas.getContext) {"
+          "ctx.scale(10,10);"
+          "ctx.imageSmoothingEnabled = true;"
+          "grd = ctx.createLinearGradient(0, 0, 0, 24);" // gradient
+          "grd.addColorStop(0, 'yellow');"
+          "grd.addColorStop(.075, 'orange');"
+          "grd.addColorStop(.25, 'violet');"
+          "grd.addColorStop(.45, 'darkblue');"
+          "grd.addColorStop(1, 'black');"
+          "grdD();"
+          "gPx = ctx.getImageData(325, 0, 1,239);"
+          "mos();"
+            "image.onload = function () {"
+                "ctx.drawImage(image,0,0,32,24);"
+                "poiD();"
+            "}"
+        "}"
+      "}"
+    "function grdD(){"  //gradient draw()
+      "ctx.fillStyle = grd;"
+      "ctx.fillRect(32, 0, 2,24);}"
+    "</script>"
+;
+#endif //USE_UNISHOX_COMPRESSION
+#ifdef USE_UNISHOX_COMPRESSION
+const size_t HTTP_MLX90640_4b_SNS_SIZE = 418;
+const char HTTP_MLX90640_4b_SNS_COMPRESSED[] PROGMEM = "\x3D\x07\x60\x86\x4B\x38\x2C\xB1\x0F\x87\xDF\x9D\x0B\x18\x77\x4E\xF1\xE0\xFB\x3F"
+                             "\x0F\x40\xEF\x8C\xEF\xCB\x44\x3E\x1F\x63\x42\x36\x1F\x68\x7F\x44\xA1\x47\xC3\xEC"
+                             "\xE5\xE3\x3E\xCE\xE1\x0A\x7A\x3C\x2A\x2B\x8F\x87\xD9\xCA\xC6\x7D\x9F\x87\xA1\xD8"
+                             "\x40\x83\x83\x9F\x87\xA0\x9A\x66\x7E\x1E\x87\x60\x9A\x66\x7E\x1E\x9E\x61\x30\xE9"
+                             "\x68\x87\xC3\xEC\x66\x69\x04\x7D\xAC\xE0\xC5\x5F\x0F\x33\xE1\xF6\x37\x3C\x77\x4E"
+                             "\xF1\xF6\x7E\x1E\x98\x32\xB7\x39\x19\xD8\x42\xD9\xF0\xFB\x38\xCF\xB3\xF0\x88\x61"
+                             "\x61\x69\xD6\x72\x1E\x87\x61\x02\x0D\x40\x4B\xB8\x72\x10\x20\xDC\x39\x44\x0A\x77"
+                             "\x0E\x51\x02\x0D\xC3\x96\x40\xA7\x70\xE5\x90\x20\xDC\x39\x84\x0A\x77\x0E\x61\x02"
+                             "\x0D\xC3\x9A\x40\xA7\x70\xE6\x90\x20\xDC\x39\xC4\x08\xB7\x0E\xC0\x41\xE1\x2A\x01"
+                             "\xFC\x3D\x04\xD3\x30\x41\xE2\x0C\xE4\x3E\xC8\x10\xF8\x5B\x13\x4C\xCF\xC2\x18\x58"
+                             "\x5A\x75\x9C\x67\x99\xDC\x3D\x0B\xC3\x2F\x96\x88\x7C\x3E\xEC\xE4\x3E\xCF\xC3\xD0"
+                             "\xEC\x2F\x0C\xBE\x3F\x26\x3B\x32\xF2\x0D\x1D\xDF\x3E\xF6\x7C\xEF\x02\x2E\x1E\x08"
+                             "\x39\x11\xCA\x20\x44\xC8\x8E\xC1\xD8\x21\x91\xF8";
+#define  HTTP_MLX90640_4b_SNS       Decompress(HTTP_MLX90640_4b_SNS_COMPRESSED,HTTP_MLX90640_4b_SNS_SIZE).c_str()
+#else
+const char HTTP_MLX90640_4b_SNS[] PROGMEM =
+  "<body onload='setup();'>"
+  "<canvas id='mlx' width='340' height='240'></canvas>"
+  "<div></div>"
+  "<select id='poiL' onchange='mos()'>"
+	  "<option value='0'>POI-1</option>"
+	  "<option value='1'>POI-2</option>"
+	  "<option value='2'>POI-3</option>"
+	  "<option value='3'>POI-4</option>"
+	  "<option value='4'>POI-5</option>"
+	  "<option value='5'>POI-6</option>"
+	"</select>"
+    "<div id='m1'></div>"
+    "<div>POI-0: <span id='a1'></span>°C (sensor)</div>"
+    "<div id='m2'></div>"
+  "</body>"
+  ;
+#endif //USE_UNISHOX_COMPRESSION
+void MLX90640UpdateGUI(void){
+  WSContentStart_P("mlx");
+  WSContentSendStyle();
+  WSContentSend_P(HTTP_MLX90640_1_SNS);
+  WSContentSend_P(HTTP_MLX90640_2a_SNS);
+  WSContentSend_P(HTTP_MLX90640_2b_SNS);
+  WSContentSend_P(HTTP_MLX90640_3a_SNS);
+  WSContentSend_P(HTTP_MLX90640_3b_SNS);
+  WSContentSend_P(HTTP_MLX90640_4a_SNS);
+  WSContentSend_P(HTTP_MLX90640_4b_SNS);
+  WSContentSpaceButton(BUTTON_MAIN);
+  WSContentStop();
+}
+
+void MLX90640HandleWebGuiResponse(void){
+  char tmp[(MLX90640_POI_NUM*2)+4];
+  WebGetArg("ul", tmp, sizeof(tmp));                  // update line
+  if (strlen(tmp)) {           
+    uint8_t _line = atoi(tmp);
+    // AddLog_P2(LOG_LEVEL_DEBUG, "MLX90640: send line %u", _line);
+    float _buf[65];
+    if(_line==0){_buf[0]=1000+MLX90640.Ta;} //ambient temperature modulation hack 
+    else{_buf[0]=(float)_line;}
+    memcpy((char*)&_buf[1],(char*)&MLX90640.To[_line*64],64*4);
+    Webserver->send(200,PSTR("application/octet-stream"),(const char*)&_buf,65*4);
+    return;
+    }
+  WebGetArg("up", tmp, sizeof(tmp));                  // update POI to browser
+  if (strlen(tmp)==1) {           
+    Webserver->send(200,PSTR("application/octet-stream"),(const char*)&MLX90640.pois,MLX90640_POI_NUM*2);
+    return;
+    }
+  else if (strlen(tmp)>2) {                           // receive updated POI from browser
+    uint32_t _poi = atoi(tmp);
+    uint32_t _poiNum = (_poi-(_poi%10000))/10000;
+    MLX90640.pois[_poiNum*2] = (_poi%10000)/100;
+    MLX90640.pois[(_poiNum*2)+1] = _poi%100;
+    // AddLog_P2(LOG_LEVEL_DEBUG, PSTR("RAW: %u, POI-%u: x: %u, y: %u"),_poi,_poiNum,MLX90640.pois[_poiNum],MLX90640.pois[_poiNum+1]);
+    for(int i = 0;i<MLX90640_POI_NUM;i++){
+    AddLog_P2(LOG_LEVEL_DEBUG, PSTR("POI-%u: x: %u, y: %u"),i+1,MLX90640.pois[i*2],MLX90640.pois[(i*2)+1]);
+    }
+    return;
+  }
+}
+
+void MLX90640HandleWebGui(void){
+  if (!HttpCheckPriviledgedAccess()) { return; }
+  MLX90640HandleWebGuiResponse();
+  MLX90640UpdateGUI();
+}
+#endif // USE_WEBSERVER
+
+/************************************************************************\
+ * Command
+\************************************************************************/
+bool MLX90640Cmd(void){
+  char command[CMDSZ];
+  bool serviced = true;
+  uint8_t disp_len = strlen(D_CMND_MLX90640);
+
+  if (!strncasecmp_P(XdrvMailbox.topic, PSTR(D_CMND_MLX90640), disp_len)) {  // prefix
+    int command_code = GetCommandCode(command, sizeof(command), XdrvMailbox.topic + disp_len, kMLX90640_Commands);
+    uint32_t _idx;
+    switch (command_code) {
+      case CMND_MLX90640_POI:
+        if(XdrvMailbox.index>(MLX90640_POI_NUM-1)&&XdrvMailbox.index<1) return false;
+        _idx = (XdrvMailbox.index-1)*2;
+        if (XdrvMailbox.data_len > 0) {
+          uint32_t _coord = TextToInt(XdrvMailbox.data);
+          MLX90640.pois[_idx] = (_coord%10000)/100;
+          if(MLX90640.pois[_idx]>31) MLX90640.pois[_idx]=31;
+          MLX90640.pois[_idx+1] = _coord%100;
+          if(MLX90640.pois[_idx+1]>23) MLX90640.pois[_idx+1]=23;
+        }
+        AddLog_P2(LOG_LEVEL_INFO, PSTR("POI-%u = x:%u,y:%u"),XdrvMailbox.index,MLX90640.pois[_idx],MLX90640.pois[_idx+1]);
+        Response_P(S_JSON_MLX90640_COMMAND_NVALUE, command, XdrvMailbox.payload);
+        break;
+      default:
+    	  // else for Unknown command
+    	  serviced = false;
+    	break;
+    }
+  } else {
+    return false;
+  }
+  return serviced;
+}
+
+/************************************************************************\
+ * Init
+\************************************************************************/
+void MLX90640init()
+{
+  if (MLX90640.type || !I2cSetDevice(MLX90640_ADDRESS)) { return; }
+
+  Wire.setClock(400000);
+  int status = -1;
+  if(!MLX90640.dumpedEE){
+    status = MLX90640_DumpEE(MLX90640_ADDRESS, MLX90640.Frame);
+    if (status != 0){
+      AddLog_P2(LOG_LEVEL_INFO, PSTR("Failed to load system parameters"));
+    }
+    else {
+      AddLog_P2(LOG_LEVEL_INFO, PSTR("MLX90640: started"));
+      MLX90640.type = true;
+    }
+  MLX90640.params = new paramsMLX90640;
+  }
+}
+
+/************************************************************************\
+ * Run loop
+\************************************************************************/
+void MLX90640every100msec(){
+    static uint32_t _job = 0;
+    int status;
+    uint32_t _time;
+
+    if(!MLX90640.extractedParams){
+      static uint32_t _chunk = 0;
+      AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: will read chunk: %u"), _chunk);
+      _time = millis();
+      status = MLX90640_ExtractParameters(MLX90640.Frame, MLX90640.params, _chunk);
+      if (status == 0){
+        AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: parameter received after: %u msec, status: %u"), TimePassedSince(_time), status);
+      }
+      if (_chunk == 5) MLX90640.extractedParams = true;
+      _chunk++;
+      return;
+    }
+
+    switch(_job){
+        case 0:
+        if(MLX90640_SynchFrame(MLX90640_ADDRESS)!=0){
+            _job=-1;
+            AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: frame not ready"));
+            break;
+            }
+        // _time = millis();
+        status = MLX90640_GetFrameData(MLX90640_ADDRESS, MLX90640.Frame);
+        // AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: got frame 0 in %u msecs, status: %i"), TimePassedSince(_time), status);
+        break;
+        case 1:
+        MLX90640.Ta = MLX90640_GetTa(MLX90640.Frame, MLX90640.params);
+        break;
+        case 2:
+        // _time = millis();
+        MLX90640_CalculateTo(MLX90640.Frame, MLX90640.params, 0.95f, MLX90640.Ta - 8, MLX90640.To, 0);
+        // AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: calculated temperatures in %u msecs"), TimePassedSince(_time));
+        break;
+        case 5:
+        if(MLX90640_SynchFrame(MLX90640_ADDRESS)!=0){
+            _job=4;
+            break;
+        }
+        // _time = millis();
+        status = MLX90640_GetFrameData(MLX90640_ADDRESS, MLX90640.Frame);
+        // // AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: got frame 1 in %u msecs, status: %i"), TimePassedSince(_time), status);
+        break;
+        case 7:
+        // _time = millis();
+        MLX90640_CalculateTo(MLX90640.Frame, MLX90640.params, 0.95f, MLX90640.Ta - 8, MLX90640.To, 1);
+        // AddLog_P2(LOG_LEVEL_DEBUG, PSTR("MLX90640: calculated temperatures in %u msecs"), TimePassedSince(_time));
+        break;
+        default:
+        break;
+    }
+    _job++;
+    if(_job>10) _job=0;
+}
+
+
+/*********************************************************************************************\
+ * Interface
+\*********************************************************************************************/
+
+void MLX90640Show(uint8_t json)
+{
+  char amb_tstr[FLOATSZ];
+  dtostrfd(MLX90640.Ta, Settings.flag2.temperature_resolution, amb_tstr);
+  if (json) {
+    ResponseAppend_P(PSTR(",\"MLX90640\":{\"" D_JSON_TEMPERATURE "\":[%s"), amb_tstr);
+  for(int i = 0;i<MLX90640_POI_NUM;i++){
+    char obj_tstr[FLOATSZ];
+    dtostrfd(MLX90640.To[MLX90640.pois[i*2]+(MLX90640.pois[(i*2)+1]*32)], Settings.flag2.temperature_resolution, obj_tstr);
+    ResponseAppend_P(PSTR(",%s"),obj_tstr);
+    // AddLog_P2(LOG_LEVEL_DEBUG, PSTR("Array pos: %u"),MLX90640.pois[i*2]+(MLX90640.pois[(i*2)+1]*32));
+    AddLog_P2(LOG_LEVEL_DEBUG, PSTR("POI-%u: x: %u, y: %u"),i+1,MLX90640.pois[i*2],MLX90640.pois[(i*2)+1]);
+    }
+    ResponseAppend_P(PSTR("]}"));
+  }
+}
+
+/*********************************************************************************************\
+ * Interface
+\*********************************************************************************************/
+
+bool Xdrv84(uint8_t function)
+{
+  bool result = false;
+
+  if (FUNC_INIT == function) {
+    MLX90640init();
+  }
+  if(MLX90640.type){
+    switch (function) {
+      case FUNC_EVERY_100_MSECOND:
+      MLX90640every100msec();
+      break;
+      case FUNC_JSON_APPEND:
+        MLX90640Show(1);
+        break;
+#ifdef USE_WEBSERVER
+      case FUNC_WEB_ADD_MAIN_BUTTON:
+        WSContentSend_P(HTTP_BTN_MENU_MLX90640);
+        break;
+      case FUNC_WEB_ADD_HANDLER:
+        Webserver->on("/mlx", MLX90640HandleWebGui);
+        break;
+#endif  // USE_WEBSERVER
+      case FUNC_COMMAND:
+        result = MLX90640Cmd();
+        break;
+    }
+  }
+  return result;
+}
+
+#endif  // USE_MLX90640_SENSOR
+#endif // USE_I2C
diff --git a/tools/decode-status.py b/tools/decode-status.py
index 26f7fe900..cd32a5402 100755
--- a/tools/decode-status.py
+++ b/tools/decode-status.py
@@ -227,7 +227,7 @@ a_features = [[
     "USE_VEML7700","USE_MCP9808","USE_BL0940","USE_TELEGRAM",
     "USE_HP303B","USE_TCP_BRIDGE","USE_TELEINFO","USE_LMT01",
     "USE_PROMETHEUS","USE_IEM3000","USE_DYP","USE_I2S_AUDIO",
-    "","","","",
+    "USE_MLX90640","","","",
     "","USE_TTGO_WATCH","USE_ETHERNET","USE_WEBCAM"
     ],[
     "","","","",