introduction

Cet article est un enregistrement de l'utilisation du capteur à matrice infrarouge 8x8 "AMG8833" d'Arduino, l'envoi des données à un PC en temps réel et leur visualisation avec Python (PyQt5, PyQtGraph).

Il est visualisé en temps réel comme l'image ci-dessous.

Arduino Arduino acquiert des données de thermographie et les envoie à un PC (Python) via une communication série. AMG8833 Cette fois, j'utilise Switch Science Conta ™ Thermography AMG8833 installé.

Selon Switch Science

La plage de mesure de température pour chaque élément est de 0 ° C à 80 ° C. La zone de mesure est une pyramide carrée devant le capteur (environ 60 degrés verticalement et horizontalement), et une image bidimensionnelle obtenue en divisant cette zone en 8x8 pixels peut être obtenue.

Nous utilisons également Conta ™ Base Shield pour rendre l'AMG8833 facile à utiliser.

Acquisition et transmission de données

La page Switch Science répertorie certaines bibliothèques AMG8833, mais ici j'utilise la [SparkFun_GridEYE_Arduino_Library] de SparkFun (https://github.com/sparkfun/SparkFun_GridEYE_Arduino_Library). Le programme suivant n'est qu'une légère modification du Exemple de programme.

Dans la communication série, les données de température 8x8 = 64 sont transmises sous forme de chaînes de caractères séparées par ",".

`amg8833-serial.ino`


#include <SparkFun_GridEYE_Arduino_Library.h>
#include <Wire.h>

float pixelTable[64];

GridEYE grideye;

void setup() {
  Wire.begin();
  //L'adresse AMG8833 du switch science est définie sur 0x68 par défaut.
  grideye.begin(0x68);
  Serial.begin(115200);
}

void loop() {
  // 8x8=Obtenez la température pour 64 pixels et stockez-la dans Grideye.
  for(unsigned char i = 0; i < 64; i++){
    pixelTable[i] = grideye.getPixelTemperature(i);
  }
  //La température de tous les pixels","Séparé et organisé sur une seule ligne et transmis par communication série.
  for(unsigned char i = 0; i < 64; i++){
    Serial.print(pixelTable[i]);
    if(i != 63){
      Serial.print(",");
    }
  }
  Serial.println();
  delay(50);
}

Python La carte thermique est affichée en temps réel sur la base des données de température reçues d'Arduino.

Bibliothèque

--pyserial --communication série

numpy
pyqt5 --pyqtgraph --Dessin en temps réel
(matplotlib) --Carte des couleurs

La visualisation des données en Python est matplotlib, mais elle a l'inconvénient d'être trop lourde pour mettre à jour l'écran en temps réel avec matplotlib. Par conséquent, au lieu de matplotlib, nous utilisons une bibliothèque légère appelée pyqtgraph.

Cependant, cette fois, j'utilise une partie de matpotlib pour convertir les données de température en couleur (RGBA). Il semble que pyqtgraph puisse être similaire, mais dans ce cas, il semble que vous deviez spécifier la couleur à utiliser pour la carte des couleurs. Ici, nous utilisons matplotlib, qui fournit une carte de couleurs par défaut.

Réception des données et affichage de la carte thermique

`heatmap.py`


from pyqtgraph.Qt import QtGui, QtCore
import matplotlib.cm as cm
import matplotlib as mpl
import pyqtgraph as pg
import numpy as np
import serial

#TEMP pour rendre la carte thermique plus facile à voir_MAX=40.Mettre à 0
TEMP_MIN = 0.0
TEMP_MAX = 40.0

app = QtGui.QApplication([])

win = pg.GraphicsLayoutWidget(show=True, title="AMG8833")
win.resize(600,600)
win.setWindowTitle('AMG8833')
pg.setConfigOptions(antialias=True)

view = win.addViewBox()
view.setAspectLocked(True)

img = pg.ImageItem(border='w')
view.addItem(img)

#Carte des couleurs pour convertir la température en couleur
norm = mpl.colors.Normalize(vmin=TEMP_MIN, vmax=TEMP_MAX)
cmap = cm.jet
m = cm.ScalarMappable(norm=norm, cmap=cmap)

#Communication série
ser = serial.Serial("COM13", 115200, timeout=1)

#Données de température 8x8
data = np.zeros((8, 8))

def get_data():
    global data, ser
    if ser.in_waiting:
        #Recevoir des données d'Arduino
        #La gestion des exceptions est facile car une erreur se produit lors de l'acquisition de données
        try:
            line = ser.readline().decode().strip()
            temps = [float(t) for t in line.split(",")]
            data = np.array(temps).reshape((8, 8))
        except:
            pass

def update_plot():
    global img, data
    img.setImage(m.to_rgba(data))

#Réception de données toutes les 50 ms
timer1 = QtCore.QTimer()
timer1.timeout.connect(get_data)
timer1.setInterval(50)
timer1.start()

#Mise à jour de la carte thermique toutes les 100 ms
timer2 = QtCore.QTimer()
timer2.timeout.connect(update_plot)
timer2.setInterval(100)
timer2.start()

if __name__ == '__main__':
    import sys
    if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
        QtGui.QApplication.instance().exec_()

Dans le programme ci-dessus, la réception des données et la mise à jour de la carte thermique sont séparées en QTimers séparés. Si la carte thermique est mise à jour chaque fois que des données sont reçues, la carte thermique peut ne pas être mise à jour à temps. Pour éviter cela, la réception des données et la mise à jour de la carte thermique peuvent être effectuées séparément.

Lien de référence

Visualisez les données AMG8833 avec un simple navigateur de type thermographie (Partie 1)

Visualisation en temps réel des données thermographiques AMG8833 en Python