At 32x24 resolution, this is far from being the high-res thermal imaging you see in the movies, or even in the most budget FLIR devices, but this is also a heck of a lot less expensive than any of that and it works well for what it is. It's a great intro into thermal imaging, and can be useful for many sensing projects. I got it up and running easily with a Teensy 4.0.

A few key points to mentions:

1) Especially considering the low resolution, this 55 degree version is going to provide more detail and be better for thermal photography than the 110 degree version. The 110 version might be better for robotic vision and applications where you need a wider view.

2) This samples in a checkerboard pattern by default, and it effectively takes two samples to get one complete image. You'll notice artifacts of that upon fast movement of the sensor or the object in its view, which can be improved by setting a higher sampling rate (some rates may also need a higher I2C speed)

3) There can be a bit of noise in the image, which is worse at higher sampling rates, but objects significantly warmer or colder than the rest of the scene are still pretty distinct.

4) Take a look at the "Iron" and "Rainbow" palettes used by FLIR and their competitors... While other palettes may be better in specific circumstances, these are the best options I've found for distinguishing objects across many different scenes.

Here's some palette code that I quickly threw together for an Android app, taking the pixel temperature input as a 0.0 to 1.0 level:

static int levelToRgb(float level, int palette)
{
    // Hacked up HSV to RGB algo to create our thermal vision palette

    float hueStart, hueRange;
    float blendToWhiteRange;
    float baseIntensity;
    float baseSaturation;

    switch(palette)
    {
        case sThermalPaletteIron:
            // Similar to FLIR's "Iron" palette: dark blue/purple to bright yellow to white
            hueStart = 225.0f;
            hueRange = 180.0f;
            blendToWhiteRange = 0.35f;
            baseIntensity = 0.00f;
            baseSaturation = 1.0f;
            break;

        default:
        case sThermalPaletteRainbow:
            // Similar to FLIR's "Rainbow" palette: dark blue/purple to bright red to white
            hueStart = -75.0f;
            hueRange = -285.0f;
            blendToWhiteRange = 0.40f;
            baseIntensity = -0.10f;
            baseSaturation = 1.0f;
            break;

        case sThermalPaletteGreen:
            // Dark green to white
            hueStart = 150.0f;
            hueRange = 0.0f;
            blendToWhiteRange = 0.20f;
            baseIntensity = -0.20f;
            baseSaturation = 1.0f;
            break;

        case sThermalPaletteCyan:
            // Blue to bright cyan
            hueStart = 255.0f;
            hueRange = -90.0f;
            blendToWhiteRange = 0.30f;
            baseIntensity = 0.00f;
            baseSaturation = 1.0f;
            break;

        case sThermalPaletteWhite:
            // Grayscale; white hot
            hueStart = 0.0f;
            hueRange = 0.0f;
            blendToWhiteRange = 0.05f;
            baseIntensity = -0.10f;
            baseSaturation = 0.0f;
            break;

        case sThermalPaletteBlack:
        {
            // Inverted Grayscale; black hot
            int grayLevel = 0xFF - packU8(level * 255.0f);
            return 0xFF000000 | (grayLevel << 16) | (grayLevel << 8) | grayLevel;
        }
    }

    float blendToWhiteLevelStart = 1.0f - blendToWhiteRange;

    float hueLevel = (level / blendToWhiteLevelStart);
    if(hueLevel > 1.0f)
        hueLevel = 1.0f;

    float hue = hueStart + (hueLevel * hueRange);

    while(hue >= 360.0f)
        hue -= 360.0f;

    while(hue < 0.0f)
        hue += 360.0f;

    // Make the hottest temps white by reducing saturation
    float saturation = baseSaturation;
    if(level > blendToWhiteLevelStart)
    {
        saturation -= ((level - blendToWhiteLevelStart) / blendToWhiteRange);
        if(saturation < 0.0f)
            saturation = 0.0f;
    }

    float intensity = baseIntensity + (hueLevel * (1.0f - baseIntensity));


    float hh = hue / 60.0f;
    int i = (int)hh;
    float ff = hh - i;
    float p = intensity * (1.0f - saturation);
    float q = intensity * (1.0f - (saturation * ff));
    float t = intensity * (1.0f - (saturation * (1.0f - ff)));

    float r, g, b;

    switch(i)
    {
        case 0:
            r = intensity;
            g = t;
            b = p;
            break;

        case 1:
            r = q;
            g = intensity;
            b = p;
            break;

        case 2:
            r = p;
            g = intensity;
            b = t;
            break;

        case 3:
            r = p;
            g = q;
            b = intensity;
            break;

        case 4:
            r = t;
            g = p;
            b = intensity;
            break;

        case 5:
        default:
            r = intensity;
            g = p;
            b = q;
            break;
    }

    return 0xFF000000 | (packU8(r * 255.0f) << 16) | (packU8(g * 255.0f) << 8) | packU8(b * 255.0f);
}

static int packU8(float value)
{
    int valueI = (int)Math.round(value);
    if(valueI > 0xFF)
        valueI = 0xFF;
    else if(valueI < 0)
        valueI = 0;

    return valueI;
}

Very simple to setup with the examples provided. Will be able to test my concept using these examples

Driver code and examples provided by both Sparkfun and Melexis is super handy. I was able to port the code to a TI Tiva LaunchPad without too much pain. Really fun to play with once it's working.

Had many of these and all work flawlessly.