Wärmebildkamera mit dem MLX90640 und Arduino Due

    // create palette

    ColorPalette cpRainbow;

    cpRainbow.addItem(   0.0f,   0,   0, 255);      //   0 % blue

    cpRainbow.addItem(  33.0f,   0, 255,   0);      //  33 % green

    cpRainbow.addItem(  66.0f, 255, 255,   0);      //  66 % yellow

    cpRainbow.addItem( 100.0f, 255,   0,   0);      // 100 % red

    cpRainbow.setMinMax(20.0f, 35.0f);

    // create palette

    ColorPalette cpBlueRed;

    cpBlueRed.addItem(   0.0f,   0,   0, 255);      //   0 % blue

    cpBlueRed.addItem(  50.0f, 255, 255, 255);      //  50 % white

    cpBlueRed.addItem( 100.0f, 255,   0,   0);      // 100 % red

    cpBlueRed.setMinMax(20.0f, 35.0f);

    // get color from palette

    uint16_t color = cpBlueRed.getColor(temperature);

//GY_mlx90640 ARDUINO

//   GY_mlx90640                 arduino pro mini

/*

1.GY_mlx90640_uart arduino

2.GY_mlx90640 VCC  GND

3.arduino_TX---GY_mlx90640_RX   Rest arduino

4.arduino__RX---GY_mlx90640_TX

5.GYSerial，baud=9600

6.arduino_pin_11---FT232_RX

7.arduino_pin_10---FT232_TX

8.PCSerial ,baud=115200

*/

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// Ändere hier, welcher Hardware Serial für was verwendet wird.

#define PCSerial   Serial2

#define GYSerial   Serial1

uint16_t temp1=0;

int16_t temp2=0;

uint8_t Re_buf[10];

uint16_t re_count=0,rest_count=0;

uint16_t counter=0;

unsigned char sign=0;

int led = 13;

float myMap(float x, float in_min, float in_max, float out_min, float out_max);

float max_temp=0;

float min_temp=500;

//-----------------------------------------------------------

void setup()

   {

    GYSerial.begin(9600);  

    PCSerial.begin(115200);

    delay(1000);    

   }

//-------------------------------------------------------------

void loop()

   {

    if (GYSerial.available()>0) 

       {   

        Re_buf[counter]=(unsigned char)GYSerial.read();

        if(counter==0&&Re_buf[0]!=0x5A) return;    

        else  if(counter==1&&Re_buf[1]!=0x5A)

           {

            counter=0;

            return;

           };       

        if(counter<6)    

           counter++;       

        if(counter==4)               

           {    

            if(Re_buf[2]==0x02&&Re_buf[3]==0x06)

               sign=1;

            else

               counter=0;

           }     

        if(counter>5)

           {

            float temp=(float)(Re_buf[4]+Re_buf[5]*256)/100;

            if(temp>max_temp)

               max_temp=temp;

            if(temp<min_temp)

               min_temp=temp;

            counter=4;

            re_count++;

        if(rest_count>20)

           {

            min_temp=500;

            max_temp=0;

            rest_count=0;

           }

        //PCSerial.print(temp); 

        // PCSerial.print(","); 

        float inv= myMap(temp,min_temp,max_temp,0.5,1);

        if(inv>0.75)

           PCSerial.print("**"); 

        else

           PCSerial.print("--"); 

        if((re_count%32)==0)

           PCSerial.println(); 

        if(re_count%768==0)

           PCSerial.print("TA:"); 

        if(re_count==769)

           { 

            rest_count++;

            counter=0;

            PCSerial.print(temp); 

            PCSerial.println(); 

            re_count=0;

           }

       }

     }

   } 

//---------------------------------------------------------------

float myMap(float x, float in_min, float in_max, float out_min, float out_max)

   {

    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;

   }

//GY_mlx90640 ARDUINO

//   GY_mlx90640                 arduino pro mini

/*

1.GY_mlx90640_uart arduino

2.GY_mlx90640 VCC  GND

3.arduino_TX---GY_mlx90640_RX   Rest arduino

4.arduino__RX---GY_mlx90640_TX

5.GYSerial，baud=9600

6.arduino_pin_11---FT232_RX

7.arduino_pin_10---FT232_TX

8.PCSerial ,baud=115200

*/

#define PCSerial Serial

#define GYSerial Serial1

uint8_t Re_buf[10];

uint16_t re_count = 0;

uint16_t counter = 0;

unsigned char sign = 0;

int led = 13;

//-----------------------------------------------------------

void setup()

   {

    GYSerial.begin(115200);  

    PCSerial.begin(115200);

    delay(1000);    

   }

//-------------------------------------------------------------

void loop()

   {

    if (GYSerial.available() > 0) 

       {   

        Re_buf[counter]=(unsigned char)GYSerial.read();

        if(counter == 0 && Re_buf[0] != 0x5A) return;

        else if(counter == 1 && Re_buf[1]!= 0x5A)

           {

            counter = 0;

            return;

           };      

        if(counter < 6)    

           counter++;       

        if(counter == 4)             

           {    

            if(Re_buf[2] == 0x02 && Re_buf[3] == 0x06)

               sign = 1;

            else

               counter = 0;

           }     

        if(counter > 5)

           {

            float temp = (float)(Re_buf[4] + Re_buf[5] * 256) / 100;

            counter = 4;

            re_count++;

            PCSerial.print(temp); 

            PCSerial.print(","); 

            if((re_count%32) == 0)

               PCSerial.println(); 

            if(re_count == 769)

               { 

                counter = 0;

                PCSerial.println(); 

                re_count=0;

               }

           }

      }

   }

#include <Wire.h>

#define I2C_EEPROM_ADRESSE 0x33

#define EEPROM_SPEICHER_ADR 0x8000

const uint16_t Anzahl_Rezepte = 16;  // anzahl Rezepte

uint16_t Zaehler[Anzahl_Rezepte] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

bool oneshot = true;

void setup()

   {

    Wire.begin();

    Serial.begin(9600);

    Serial.println("Programmanfang");

    Serial.print("Zaehlerfeld vor dem Lesen: \t");

    for (uint16_t j = 0; j < (sizeof(Zaehler) / sizeof(Zaehler[0])); j++)

       {

        Serial.print(Zaehler[j]);

        Serial.print(" ");

       }

    Serial.println();

    bool zaehlerzuruecksetzen = false;  // auf true zum Loeschen, auch zur Speicherinitialisierung auf 0

    if (zaehlerzuruecksetzen)

       {

        i2c_eeprom_updateUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0]));  // Zaehler zuruecksetzen

       }

    else

       {

        i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0]));

       }

    Serial.print("Zaehlerfeld nach dem Lesen: \t");

    for (uint16_t j = 0; j < (sizeof(Zaehler) / sizeof(Zaehler[0])); j++)

       {

        Serial.print(Zaehler[j]);

        Serial.print(" ");

       }

    Serial.println();

   }

void loop()

   {

    if (oneshot)

       {

        Zaehler[0] = 9;

        Zaehler[1] = AB;

        Zaehler[2] = 499B;

        Zaehler[3] = 0;

        Zaehler[4] = 2061;

        Zaehler[5] = 5;

        Zaehler[6] = 320;

        Zaehler[7] = 3E0;

        Zaehler[8] = 1A26;

        Zaehler[9] = A228;

        Zaehler[10] = 185;

        Zaehler[11] = 499;

        Zaehler[12] = 0;

        Zaehler[13] = 1901;

        Zaehler[14] = 0;

        Zaehler[15] = 0;

        i2c_eeprom_updateUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0]));

        Serial.print("Zaehlerfeld nach dem Schreiben: \t");

        for (uint16_t j = 0; j < (sizeof(Zaehler) / sizeof(Zaehler[0])); j++)

           {

            Serial.print(Zaehler[j]);

            Serial.print(" ");

           }

        Serial.println();

        oneshot = false;

       }

   }

void i2c_eeprom_updateUIntArray(int16_t deviceaddress, uint16_t eeaddress, uint16_t *ptr, uint16_t anzahlElemente)

   {

    uint16_t buf[anzahlElemente];

    i2c_eeprom_readUIntArray(deviceaddress, eeaddress, buf, sizeof(buf) / sizeof(buf[0]));

    uint16_t eadr=eeaddress;

    for (uint16_t j = 0; j < anzahlElemente; j++)

       {

        if ((ptr[j] >> 8) != (buf[j] >> 8))

           {

            Wire.beginTransmission(deviceaddress);

            Wire.write((int)(eadr >> 8)); // MSB

            Wire.write((int)(eadr & 0xFF)); // LSB

            Wire.write(ptr[j] >> 8);

            Wire.endTransmission();

            delay(10);

           }

        eadr++;

        if ((ptr[j] & 0xFF) != (buf[j] & 0xFF))

           {

            Wire.beginTransmission(deviceaddress);

            Wire.write((int)(eadr >> 8)); // MSB

            Wire.write((int)(eadr & 0xFF)); // LSB

            Wire.write(ptr[j] & 0xFF);

            Wire.endTransmission();

            delay(10);

           }

        eadr++;

       }

   }

void i2c_eeprom_readUIntArray(int16_t deviceaddress, uint16_t eeaddress, uint16_t *ptr, uint16_t anzahlElemente)

   {

    uint16_t data = 0xFF;

    delay(2);

    Wire.beginTransmission(deviceaddress);

    Wire.write((int)(eeaddress >> 8)); // MSB

    Wire.write((int)(eeaddress & 0xFF)); // LSB

    Wire.endTransmission();

    Wire.requestFrom(deviceaddress, anzahlElemente << 1);

    for (uint16_t j = 0; j < anzahlElemente; j++)

       {

        delay(5);

        data = Wire.read() << 8;

        delay(5);

        data = data | Wire.read();

        ptr[j] = data;

       }

   }

#include <Wire.h>

#define I2C_EEPROM_ADRESSE 0x33

#define EEPROM_SPEICHER_ADR 0x8000

const uint16_t Anzahl_Rezepte = 16;  // anzahl Rezepte

uint16_t Zaehler[Anzahl_Rezepte] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

bool oneshot = true;

void setup()

   {

    Wire.begin();

    Serial.begin(9600);

    Serial.println("Programmanfang");

    i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0]));

    Serial.print("Zaehlerfeld vor dem Schreiben: \t");

    for (uint16_t j = 0; j < (sizeof(Zaehler) / sizeof(Zaehler[0])); j++)

       {

        Serial.print(Zaehler[j]);

        Serial.print(" ");

       }

    Serial.println();

   }

void loop()

   {

    //oneshot = false;

    if (oneshot)

       {

        Zaehler[0] = 9;

        Zaehler[1] = 171;      // = HEX AB

        Zaehler[2] = 18843;    // = HEX 499B

        Zaehler[3] = 0;

        Zaehler[4] = 8289;     // = HEX 2061

        Zaehler[5] = 5;

        Zaehler[6] = 800;      // = HEX 320

        Zaehler[7] = 992;      // = HEX 3E0

        Zaehler[8] = 6694;     // = HEX 1A26

        Zaehler[9] = 41512;    // = HEX A228

        Zaehler[10] = 389;     // = HEX 185

        Zaehler[11] = 1177;    // = HEX 499

        Zaehler[12] = 0;

        Zaehler[13] = 6401;    // = HEX 1901

        Zaehler[14] = 0;

        Zaehler[15] = 0;

        Serial.print("neu zu schreibende Werte: \t");

        for (uint16_t j = 0; j < (sizeof(Zaehler) / sizeof(Zaehler[0])); j++)

           {

            Serial.print(Zaehler[j]);

            Serial.print(" ");

           }

        i2c_eeprom_updateUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0]));

        i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0]));

        Serial.println();

        Serial.print("Zaehlerfeld nach dem Schreiben: \t");

        for (uint16_t j = 0; j < (sizeof(Zaehler) / sizeof(Zaehler[0])); j++)

           {

            Serial.print(Zaehler[j]);

            Serial.print(" ");

           }

        Serial.println();

        oneshot = false;

       }

   }

void i2c_eeprom_updateUIntArray(int16_t deviceaddress, uint16_t eeaddress, uint16_t *ptr, uint16_t anzahlElemente)

   {

    uint16_t buf[anzahlElemente];

    i2c_eeprom_readUIntArray(deviceaddress, eeaddress, buf, sizeof(buf) / sizeof(buf[0]));

    uint16_t eadr=eeaddress;

    for (uint16_t j = 0; j < anzahlElemente; j++)

       {

        if ((ptr[j] >> 8) != (buf[j] >> 8))

           {

            Wire.beginTransmission(deviceaddress);

            Wire.write((int)(eadr >> 8)); // MSB

            Wire.write((int)(eadr & 0xFF)); // LSB

            Wire.write(ptr[j] >> 8);

            Wire.endTransmission();

            delay(10);

           }

        eadr++;

        if ((ptr[j] & 0xFF) != (buf[j] & 0xFF))

           {

            Wire.beginTransmission(deviceaddress);

            Wire.write((int)(eadr >> 8)); // MSB

            Wire.write((int)(eadr & 0xFF)); // LSB

            Wire.write(ptr[j] & 0xFF);

            Wire.endTransmission();

            delay(10);

           }

        eadr++;

       }

   }

void i2c_eeprom_readUIntArray(int16_t deviceaddress, uint16_t eeaddress, uint16_t *ptr, uint16_t anzahlElemente)

   {

    uint16_t data = 0xFF;

    delay(2);

    Wire.beginTransmission(deviceaddress);

    Wire.write((int)(eeaddress >> 8)); // MSB

    Wire.write((int)(eeaddress & 0xFF)); // LSB

    Wire.endTransmission();

    Wire.requestFrom(deviceaddress, anzahlElemente << 1);

    for (uint16_t j = 0; j < anzahlElemente; j++)

       {

        delay(5);

        data = Wire.read() << 8;

        delay(5);

        data = data | Wire.read();

        ptr[j] = data;

       }

   }

const uint16_t len = 16;

uint16_t adr = 0x8000;

uint16_t Buffer[len];

#include <Wire.h>

#include "MLX90640_API.h"

#include "MLX90640_I2C_Driver.h"

void setup() {

  // put your setup code here, to run once:

    Wire.begin();

    Wire.setClock(400000); //Increase I2C clock speed to 400kHz

    Serial.begin(9600);

    MLX90640_I2CRead(0x33, adr, len, Buffer);

    for (int n = 0; n < len; n++)

    {

      Serial.print(n); Serial.print(": "); Serial.println(Buffer[n], HEX);

    }

    MLX90640_I2CWrite(0x33, 0x800D, 6401);    // HEX 1901

    //MLX90640_I2CWrite(0x33, 0x800D, 6657);    // HEX 1A01

    delay(4000);

    MLX90640_I2CRead(0x33, adr, len, Buffer);

    for (int n = 0; n < len; n++)

    {

      Serial.print(n); Serial.print(": "); Serial.println(Buffer[n], HEX);

    }

}

void loop() {

  // put your main code here, to run repeatedly:

}

#include <Wire.h>

#include "MLX90640_API.h"

#include "MLX90640_I2C_Driver.h"

#include "SPI.h"

#include "Adafruit_GFX.h"

#include "Adafruit_ILI9341.h"

// For the ESP-WROVER_KIT, these are the default.

#define TFT_CS   15 

#define TFT_DC    2

#define TFT_MOSI 13

#define TFT_CLK  14

#define TFT_RST  26

#define TFT_MISO 12

#define TFT_LED  27

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);

const byte MLX90640_address = 0x33; //Default 7-bit unshifted address of the MLX90640

#define TA_SHIFT 8 //Default shift for MLX90640 in open air

static float mlx90640To[768];

paramsMLX90640 mlx90640;

int xPos, yPos;                                // Abtastposition

int R_colour, G_colour, B_colour;              // RGB-Farbwert

int i, j;                                      // Zählvariable

float T_max, T_min;                            // maximale bzw. minimale gemessene Temperatur

float T_center;                                // Temperatur in der Bildschirmmitte

// ***************************************

// **************** SETUP ****************

// ***************************************

void setup()

   {

    Serial.begin(115200);    

    Wire.begin();

    Wire.setClock(400000); //Increase I2C clock speed to 400kHz

    while (!Serial); //Wait for user to open terminal

    Serial.println("MLX90640 IR Array Example");

    if (isConnected() == false)

       {

        Serial.println("MLX90640 not detected at default I2C address. Please check wiring. Freezing.");

        while (1);

       }

    Serial.println("MLX90640 online!");

    //Get device parameters - We only have to do this once

    int status;

    uint16_t eeMLX90640[832];

    status = MLX90640_DumpEE(MLX90640_address, eeMLX90640);

    if (status != 0)

       Serial.println("Failed to load system parameters");

    status = MLX90640_ExtractParameters(eeMLX90640, &mlx90640);

    if (status != 0)

       {

        Serial.println("Parameter extraction failed");

        Serial.print(" status = ");

        Serial.println(status);

       }

    //Once params are extracted, we can release eeMLX90640 array

    MLX90640_I2CWrite(0x33, 0x800D, 6401);    // Schreibt den Wert 1901 (HEX) = 6401 (DEC) ins Register an die Stelle 0x800D, damit der Sensor ausgelesen werden kann!!!

                                              // =======================================================================================================================

    //MLX90640_SetRefreshRate(MLX90640_address, 0x00); //Set rate to 0.25Hz effective - Works

    //MLX90640_SetRefreshRate(MLX90640_address, 0x01); //Set rate to 0.5Hz effective - Works

    //MLX90640_SetRefreshRate(MLX90640_address, 0x02); //Set rate to 1Hz effective - Works

    //MLX90640_SetRefreshRate(MLX90640_address, 0x03); //Set rate to 2Hz effective - Works

    MLX90640_SetRefreshRate(MLX90640_address, 0x04); //Set rate to 4Hz effective - Works

    //MLX90640_SetRefreshRate(MLX90640_address, 0x05); //Set rate to 8Hz effective - Works at 800kHz

    //MLX90640_SetRefreshRate(MLX90640_address, 0x06); //Set rate to 16Hz effective - Works at 800kHz

    //MLX90640_SetRefreshRate(MLX90640_address, 0x07); //Set rate to 32Hz effective - fails

    pinMode(TFT_LED, OUTPUT);

    digitalWrite(TFT_LED, HIGH);

    tft.begin();

    tft.setRotation(1);

    tft.fillScreen(ILI9341_BLACK);

    tft.fillRect(0, 0, 319, 13, tft.color565(255, 0, 10));

    tft.setCursor(100, 3);

    tft.setTextSize(1);

    tft.setTextColor(ILI9341_YELLOW, tft.color565(255, 0, 10));

    tft.print("Thermographie - stoppi");    

    tft.drawLine(250, 210 - 0, 258, 210 - 0, tft.color565(255, 255, 255));

    tft.drawLine(250, 210 - 30, 258, 210 - 30, tft.color565(255, 255, 255));

    tft.drawLine(250, 210 - 60, 258, 210 - 60, tft.color565(255, 255, 255));

    tft.drawLine(250, 210 - 90, 258, 210 - 90, tft.color565(255, 255, 255));

    tft.drawLine(250, 210 - 120, 258, 210 - 120, tft.color565(255, 255, 255));

    tft.drawLine(250, 210 - 150, 258, 210 - 150, tft.color565(255, 255, 255));

    tft.drawLine(250, 210 - 180, 258, 210 - 180, tft.color565(255, 255, 255));

    tft.setCursor(80, 220);

    tft.setTextColor(ILI9341_WHITE, tft.color565(0, 0, 0));

    tft.print("T+ = ");    

    // Zeichnen der seitlichen Farbskala

    // =================================

    for (i = 0; i < 181; i++)

       {

        //value = random(180);

        getColour(i);

        tft.drawLine(240, 210 - i, 250, 210 - i, tft.color565(R_colour, G_colour, B_colour));

       } 

   } 

// *******************************************

// ************** HAUPTSCHLEIFE **************

// *******************************************

void loop()

   {

    for (byte x = 0 ; x < 2 ; x++) //Read both subpages

       {

        uint16_t mlx90640Frame[834];

        int status = MLX90640_GetFrameData(MLX90640_address, mlx90640Frame);

        if (status < 0)

           {

            Serial.print("GetFrame Error: ");

            Serial.println(status);

           }

        float vdd = MLX90640_GetVdd(mlx90640Frame, &mlx90640);

        float Ta = MLX90640_GetTa(mlx90640Frame, &mlx90640);

        float tr = Ta - TA_SHIFT; //Reflected temperature based on the sensor ambient temperature

        float emissivity = 0.95;

        MLX90640_CalculateTo(mlx90640Frame, &mlx90640, emissivity, tr, mlx90640To);

       }

    // determine of T_min and T_max and find out error pixel

    // =====================================================

    mlx90640To[1*32 + 21] = 0.5 * (mlx90640To[1*32 + 20] + mlx90640To[1*32 + 22]);    // elininate the error-pixels

    mlx90640To[4*32 + 30] = 0.5 * (mlx90640To[4*32 + 29] + mlx90640To[4*32 + 31]);    // elininate the error-pixels

    T_min = mlx90640To[0];

    T_max = mlx90640To[0];

    for (i = 1; i < 768; i++)

       {

        if((mlx90640To[i] > -41) && (mlx90640To[i] < 301))

           {

            if(mlx90640To[i] < T_min)

               {

                T_min = mlx90640To[i];

               }

            if(mlx90640To[i] > T_max)

               {

                T_max = mlx90640To[i];

               }

           }

        else if(i > 0)

           {

            mlx90640To[i] = mlx90640To[i-1];

           }

        else

           {

            mlx90640To[i] = mlx90640To[i+1];

           }

       }

    // determine of T_center

    // =====================

    T_center = mlx90640To[11* 32 + 15];    

    // drawing the picture

    // ===================

    for (i = 0 ; i < 24 ; i++)

       {

        for (j = 0; j < 32; j++)

           {

            mlx90640To[i*32 + j] = 180.0 * (mlx90640To[i*32 + j] - T_min) / (T_max - T_min);

            getColour(mlx90640To[i*32 + j]);

            tft.fillRect(217 - j * 7, 35 + i * 7, 7, 7, tft.color565(R_colour, G_colour, B_colour));

           }

       }

    tft.fillRect(260, 25, 47, 10, tft.color565(0, 0, 0));

    tft.fillRect(260, 205, 47, 10, tft.color565(0, 0, 0));    

    tft.fillRect(115, 220, 47, 10, tft.color565(0, 0, 0));    

    tft.setTextColor(ILI9341_WHITE, tft.color565(0, 0, 0));

    tft.setCursor(265, 25);

    tft.print(T_max, 1);

    tft.setCursor(265, 205);

    tft.print(T_min, 1);

    tft.setCursor(120, 220);

    tft.print(T_center, 1);

    tft.setCursor(310, 25);

    tft.print("C");

    tft.setCursor(310, 205);

    tft.print("C");

    tft.setCursor(165, 220);

    tft.print("C");

    tft.drawLine(217 - 15*7 + 3.5 - 5, 11*7 + 35 + 3.5, 217 - 15*7 + 3.5 + 5, 11*7 + 35 + 3.5, tft.color565(255, 255, 255));

    tft.drawLine(217 - 15*7 + 3.5, 11*7 + 35 + 3.5 - 5, 217 - 15*7 + 3.5, 11*7 + 35 + 3.5 + 5,  tft.color565(255, 255, 255));

    delay(20);

   }

// =========================

// ===== Farbbestimmung ====

// =========================

void getColour(int j)

   {

    if (j >= 0 && j < 30)

       {

        R_colour = 0;

        G_colour = 0;

        B_colour = 20 + (120.0/30.0) * j;

       }

    if (j >= 30 && j < 60)

       {

        R_colour = (120.0 / 30) * (j - 30.0);

        G_colour = 0;

        B_colour = 140 - (60.0/30.0) * (j - 30.0);

       }

    if (j >= 60 && j < 90)

       {

        R_colour = 120 + (135.0/30.0) * (j - 60.0);

        G_colour = 0;

        B_colour = 80 - (70.0/30.0) * (j - 60.0);

       }

    if (j >= 90 && j < 120)

       {

        R_colour = 255;

        G_colour = 0 + (60.0/30.0) * (j - 90.0);

        B_colour = 10 - (10.0/30.0) * (j - 90.0);

       }

    if (j >= 120 && j < 150)

       {

        R_colour = 255;

        G_colour = 60 + (175.0/30.0) * (j - 120.0);

        B_colour = 0;

       }

    if (j >= 150 && j <= 180)

       {

        R_colour = 255;

        G_colour = 235 + (20.0/30.0) * (j - 150.0);

        B_colour = 0 + 255.0/30.0 * (j - 150.0);

       }

   }

//Returns true if the MLX90640 is detected on the I2C bus

boolean isConnected()

   {

    Wire.beginTransmission((uint8_t)MLX90640_address);

    if (Wire.endTransmission() != 0)

       return (false); //Sensor did not ACK

    return (true);

   }