Leçons · Leçon S3 · Les capteurs · 40 min
Capteurs intelligents, distance et caméra
Mesure une distance avec un capteur à temps de vol, puis lis où se trouve une cible colorée dans la vue d’un module caméra. Environ 40 minutes, avec un cône de distance et un cadre de caméra que tu peux déplacer.
Deux façons de voir pour une machine
Imagine que tu cries dans une grotte sombre et que tu chronomètres l’écho. Plus l’attente est longue, plus le mur est loin. Les chauves-souris sont célèbres pour se repérer ainsi avec le son. Une caméra fait autre chose : elle capte de la lumière, comme tes yeux, et il faut ensuite que quelque chose décide ce que contient l’image.
Les deux idées existent dans un petit module que tu peux relier à un ESP32. Dans cette leçon, tu vas utiliser :
- un capteur de distance qui chronomètre un éclair de lumière pour te dire à quelle distance se trouve quelque chose,
- un module caméra qui repère une couleur que tu lui as apprise et te dit où elle se trouve dans sa vue.
Aucun des deux ne te donne des données brutes à trier. Ils font le plus dur à l’intérieur et envoient une réponse courte sur les deux fils I2C de la leçon K5 : un nombre de millimètres, ou la position d’un rectangle.
Distance : le temps de vol
Un capteur à temps de vol (ToF, pour time of flight) envoie de la lumière, détecte le temps qu’elle met à revenir, puis transforme ce temps en distance [1]. Le VL53L0X en est un. Sa lumière est invisible et son faisceau est étroit : il lit la surface juste devant lui [1]. Un sonar, qui fait rebondir du son à la place, couvre un cône plus large [1].
Trois choses à savoir :
- La portée. Le guide d’Adafruit annonce environ 50 à 1 200 mm [1]. Retiens « de quelques centimètres jusqu’à environ un mètre ». Attends-toi à ce que le nombre bouge un peu : selon la lumière et la distance, il est juste à environ 3 à 12 % près [1].
- Hors de portée. Quand rien ne peut être mesuré, la lecture n’est pas fiable, et le programme d’exemple affiche « out of range » [3][4].
- Son adresse. Sur les fils I2C, le capteur répond par défaut à
0x29[2][3]. Ton scanner de K5 le trouvera là.
Et le capteur à ultrasons bon marché ? Le HC-SR04 est très répandu, mais sa sortie d’écho est en 5 V, et elle ne peut pas aller directement sur une carte comme la tienne [6]. Il lui faut d’abord un pont diviseur ou un adaptateur de niveau. Cette leçon le laisse de côté et utilise le capteur I2C, qui n’a besoin ni de l’un ni de l’autre.
Branche-le et lis-le
Alimente-le en 3V3, même si la carte accepte jusqu’à 5 V [2]. Même raison que dans K5 : sa broche d’alimentation fixe le niveau des signaux I2C, et les broches de l’ESP32 sont faites pour 3,3 V.
| Carte distance | ESP32 DevKitC |
|---|---|
| Vin | 3V3 |
| GND | GND |
| SDA | GPIO 21 |
| SCL | GPIO 22 |
Les GPIO 21 et 22 sont les broches I2C par défaut de l’ESP32 générique [7]. Ajoute une DEL sur la GPIO 16 à travers une résistance de 220 Ω, comme dans la leçon K2, pour montrer « quelque chose est près ».
Installe la bibliothèque Adafruit VL53L0X depuis le gestionnaire de bibliothèques, comme dans K5 [3]. S’il propose d’installer d’autres bibliothèques avec, clique sur « Install all ». Retire d’abord le petit capuchon de plastique de protection du capteur [3]. Puis téléverse :
// Tinker Mission, leçon S3 : distance avec un capteur à temps de vol (carte VL53L0X)
// Câblage (alimente la carte en 3V3, voir leçon K5) :
// Vin -> 3V3 GND -> GND SDA -> GPIO 21 SCL -> GPIO 22
// DEL : GPIO 16 -> résistance de 220 ohms -> longue patte de la DEL ; courte patte -> GND
// Ouvre le moniteur série à 115200 baud. La DEL s'allume quand quelque chose est plus près que NEAR_MM.
// Il faut la bibliothèque « Adafruit VL53L0X » (gestionnaire de bibliothèques).
#include <Wire.h>
#include "Adafruit_VL53L0X.h"
const int SDA_PIN = 21; // la broche de données I2C habituelle de l'ESP32 DevKitC
const int SCL_PIN = 22; // la broche d'horloge I2C habituelle de l'ESP32 DevKitC
const int LED_PIN = 16; // DEL qui montre « quelque chose est près »
const int NEAR_MM = 200; // plus près que ça = « près » (200 mm = 20 cm)
const unsigned long READ_INTERVAL = 100; // une mesure toutes les 100 ms
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
unsigned long lastRead = 0;
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Wire.begin(SDA_PIN, SCL_PIN); // démarre le bus I2C sur ces deux broches
if (!lox.begin()) { // cherche le capteur à son adresse (0x29 par défaut)
Serial.println("Sensor not found. Check power, SDA and SCL wires.");
while (true) {
delay(1000); // rien d'autre à faire : on s'arrête ici
}
}
Serial.println("Sensor ready. Move your hand in front of it.");
}
void loop() {
unsigned long now = millis();
if (now - lastRead >= READ_INTERVAL) {
lastRead = now;
VL53L0X_RangingMeasurementData_t measure;
lox.rangingTest(&measure, false); // demande une mesure
if (measure.RangeStatus != 4) { // le statut 4 veut dire que la mesure n'est pas fiable
int distance = measure.RangeMilliMeter;
Serial.print("Distance (mm): ");
Serial.println(distance);
digitalWrite(LED_PIN, distance < NEAR_MM ? HIGH : LOW);
} else {
Serial.println("Out of range");
digitalWrite(LED_PIN, LOW);
}
}
}
Télécharger le dossier du croquis (.zip)
Ouvre le moniteur série à 115200 baud. Fais aller et venir ta main. Tu devrais voir quelque chose comme ceci :
Sensor ready. Move your hand in front of it.
Distance (mm): 412
Distance (mm): 188
Distance (mm): 87
Out of range
Comment ça marche : lox.rangingTest(&measure, false) prend une mesure, et le résultat se lit dans measure.RangeMilliMeter [4]. Un RangeStatus égal à 4 signale une mauvaise mesure, donc le programme ne fait confiance qu’aux autres [4]. La DEL s’allume sous 200 mm (20 cm).
Caméra : où est la couleur ?
Un module de vision comme le HuskyLens contient une petite caméra et un processeur. Tu lui apprends quelque chose (un visage, une ligne, une couleur). Ensuite, il te dit où il le voit. En mode reconnaissance de couleur, il dessine un rectangle autour de la couleur que tu lui as apprise [10].
Ton ESP32 demande et reçoit un bloc avec ces nombres [5] :
xCenteretyCenter: le milieu du rectangle,widthetheight: sa taille,ID: quelle couleur apprise c’est. La première que tu apprends a l’ID 1 [5].
Un ID de 0 veut dire « quelque chose est détecté, mais pas appris » [5].
L’erreur par rapport au centre. L’écran de la caméra fait 320 sur 240 pixels [8] : le milieu en largeur est donc vers 160. Soustrais-le :
error = xCenter - 160 (l’erreur)
Une erreur négative veut dire que le x de la cible est plus petit que 160, une erreur positive qu’il est plus grand, et zéro qu’elle est centrée. Déplace ta cible et regarde dans quel sens x grandit sur ta propre caméra. C’est ce nombre qu’un robot utilise pour se tourner vers une cible : tu as vu l’autre moitié dans A2, où un nombre devient un angle de servo.
Essaie ci-dessous, avec le cône sur un onglet et le cadre de la caméra sur l’autre.
Simulation du croquis distance, pas un vrai capteur.
Une vraie lecture bouge un peu, de quelques pour cent. Portée : environ 50 à 1200 mm.
Simulation de l’image de la caméra, pas la vraie caméra.
x plus grand que le milieu
error = xCenter − 160
Dans quel sens x augmente sur ta caméra : déplace la cible et regarde.
Voici l’état de départ : les commandes ont besoin de JavaScript.
Branche la caméra et lis-la
Deux choses à régler avant de brancher la caméra.
L’alimentation. Le HuskyLens accepte de 3,3 à 5 V. Son courant typique est de 320 mA à 3,3 V, ou de 230 mA à 5 V, mesuré en reconnaissance de visage, lumière d’appoint éteinte [8]. C’est bien plus qu’une DEL ou qu’un petit capteur, donc ne l’alimente pas depuis la broche 3V3 de la carte. Le fabricant dit qu’on peut l’alimenter par son port USB ou par son connecteur à 4 broches, et qu’il utilise l’USB en priorité si les deux sont branchés [11]. Le plus simple est de lui donner son propre câble USB, relié à un chargeur ou à une batterie externe, avec seulement GND et les deux fils de signal (à travers l’adaptateur de niveau, voir plus bas) vers l’ESP32. Vérifie que l’alimentation est assez puissante, sinon la caméra se comporte mal [11].
Les signaux : toujours par un adaptateur de niveau. Les broches I2C de la caméra sont marquées T (SDA) et R (SCL) sur son connecteur à 4 broches [8]. La caméra est faite pour marcher aussi avec des cartes en 5 V, et le fabricant ne dit pas à quelle tension ces deux fils se trouvent quand elle fonctionne en 5 V par l’USB. Les broches de ton ESP32 sont faites pour 3,3 V : ne prends pas le risque. Mets entre les deux un petit adaptateur de niveau I2C, avec un côté basse tension (LV) et un côté haute tension (HV), comme dans la leçon K5. Une carte à 4 canaux de type BSS138 est la plus courante ; prends-la avec ses broches déjà soudées. Câble-le ainsi :
| Adaptateur de niveau | Relier à |
|---|---|
| LV | 3V3 de l’ESP32 |
| HV | 5V de l’ESP32 |
| GND (des deux côtés) | GND de l’ESP32 et - de la caméra |
| Côté HV, canal 1 | T (SDA) de la caméra |
| Côté HV, canal 2 | R (SCL) de la caméra |
| Côté LV, canal 1 | GPIO 21 |
| Côté LV, canal 2 | GPIO 22 |
Laisse le fil + (VCC) de la caméra non branché : entoure son bout de ruban adhésif pour qu’il ne touche rien. La caméra est alimentée par son propre câble USB.
Sur la caméra elle-même, règle le protocole : General Settings > Protocol Type > I2C, puis tourne la molette jusqu’à « Save & Return » et confirme « Yes », sinon le réglage n’est pas gardé [9]. La détection automatique est la valeur par défaut [9], et l’exemple I2C du fabricant choisit I2C [12].
Aucune bibliothèque à installer. La bibliothèque du fabricant [5][12] s’arrête sur une erreur avec les versions récentes du paquet de cartes ESP32 : ce programme est donc livré avec une copie corrigée, dans un dossier appelé src. Télécharge tout le dossier du programme depuis cette leçon (s’il arrive en ZIP, décompresse-le d’abord), garde le nom de dossier l-s3-color-track, garde src à côté du fichier .ino, et ouvre l-s3-color-track.ino depuis là. Copier seulement le code ci-dessous ne marchera pas.
Apprends-lui une couleur. Tourne la molette de fonction jusqu’à ce que « Color Recognition » s’affiche en haut. Pointe le « + » sur un objet uni, de couleur vive, jusqu’à ce qu’un cadre blanc le sélectionne. Fais un appui long sur le bouton d’apprentissage en t’approchant et en t’éloignant, puis relâche [10]. Si un message te demande s’il faut continuer, attends simplement la fin du compte à rebours [10]. La première couleur apprise reçoit l’ID 1 [10]. La reconnaissance de couleur dépend beaucoup de la lumière de la pièce : garde-la identique [10]. Puis téléverse :
// Tinker Mission, leçon S3 : où est la cible colorée ? (HuskyLens, reconnaissance de couleur, I2C)
// Câblage : à travers un adaptateur de niveau I2C (LV = côté 3V3, HV = côté 5V) : SDA/SCL de la caméra -> HV, LV -> GPIO 21 (SDA) / 22 (SCL), toutes les GND reliées.
// Alimentation : la caméra demande environ 230-320 mA, alimente-la à part (voir la leçon).
// Sur la caméra : General Settings > Protocol Type > I2C, passe en reconnaissance de couleur, apprends-lui une couleur.
// Ouvre le moniteur série à 115200 baud.
// Le code du HuskyLens est dans le dossier src/ du programme (copie corrigée de la bibliothèque de DFRobot) : aucun ZIP à installer.
#include <Wire.h>
#include "src/HUSKYLENS/HUSKYLENS.h"
const int SDA_PIN = 21; // la broche de données I2C habituelle de l'ESP32 DevKitC
const int SCL_PIN = 22; // la broche d'horloge I2C habituelle de l'ESP32 DevKitC
const int TARGET_ID = 1; // la première couleur apprise à la caméra
const int CENTER_X = 160; // l'écran fait 320 de large, donc le milieu est à 160
const int DEAD_BAND = 20; // plus près que ça du milieu = « centré »
const unsigned long LOOK_INTERVAL = 100; // on regarde toutes les 100 ms
HUSKYLENS huskylens;
unsigned long lastLook = 0;
void setup() {
Serial.begin(115200);
Wire.begin(SDA_PIN, SCL_PIN); // démarre le bus I2C sur ces deux broches
while (!huskylens.begin(Wire)) { // essaie de parler à la caméra
Serial.println("Camera not found. Check wires and Protocol Type = I2C.");
delay(1000); // rien d'autre à faire pour l'instant : on réessaie
}
huskylens.writeAlgorithm(ALGORITHM_COLOR_RECOGNITION); // mode couleur
Serial.println("Camera ready.");
}
void loop() {
unsigned long now = millis();
if (now - lastLook >= LOOK_INTERVAL) {
lastLook = now;
if (!huskylens.requestBlocks(TARGET_ID)) {
Serial.println("No answer from the camera.");
} else if (huskylens.available() == 0) {
Serial.println("Target not seen.");
} else {
HUSKYLENSResult block = huskylens.read(); // le premier rectangle trouvé
int error = block.xCenter - CENTER_X; // négatif = x plus petit que le milieu
Serial.print("x=");
Serial.print(block.xCenter);
Serial.print(" y=");
Serial.print(block.yCenter);
Serial.print(" error=");
Serial.print(error);
if (error < -DEAD_BAND) {
Serial.println(" x smaller than the middle");
} else if (error > DEAD_BAND) {
Serial.println(" x bigger than the middle");
} else {
Serial.println(" centred");
}
}
}
}
Télécharger le dossier du croquis (.zip)
Moniteur série à 115200 baud. Déplace l’objet dans la vue de la caméra :
x=142 y=118 error=-18 centred
x=250 y=120 error=90 x bigger than the middle
Target not seen.
Comment ça marche : huskylens.begin(Wire) essaie de se connecter et dit si ça a réussi [5]. writeAlgorithm(ALGORITHM_COLOR_RECOGNITION) change de mode [5]. requestBlocks(1) ne demande que les rectangles d’ID 1, available() les compte, et read() en donne un [5].
Fais tes propres modifications
Change une seule chose, puis observe.
- Déplace la ligne « près ». Dans le programme de distance, mets
NEAR_MMà 100, puis à 400. À quelle distance ta DEL se met-elle à vaciller ? - Élargis la zone morte. Dans le programme de la caméra, passe
DEAD_BANDde 20 à 60. Que devient le mot « centred » ? - Oriente un servo. Avec A2, ajoute un servo sur sa propre alimentation et ajuste son angle de
error / 20chaque fois que tu vois la cible. De quel côté tourne-t-il ? S’il poursuit la cible dans le mauvais sens, inverse le signe. Que se passe-t-il si tu divises par 5 ? (Attention : un nombre trop grand le fait dépasser la cible et osciller.)
Quand ça ne marche pas
- « Sensor not found ». Vérifie
3V3,GND, SDA à la GPIO 21 et SCL à la GPIO 22. Lance le scanner de K5 : tu dois voir0x29[2][3]. Retire le capuchon de plastique du capteur [3]. - Toujours « Out of range ». Quelque chose est trop loin ou trop près du capteur. Essaie ta main à environ 20 cm [1][4].
- « Camera not found ». Vérifie les fils et l’adaptateur de niveau (LV sur 3V3, HV sur 5V, caméra côté HV), que Protocol Type est sur I2C et a bien été enregistré [9][12], et son alimentation [11]. Le scanner de K5 doit trouver la caméra à
0x32[13].beginrenvoie faux quand il ne peut pas se connecter [5]. - « No answer from the camera ». La caméra n’a pas répondu à temps. L’attente a une limite, 100 ms par défaut [5]. Vérifie les fils.
- « Target not seen ». La caméra n’a pas appris de couleur (voir « Apprends-lui une couleur »), ou la couleur n’est pas dans sa vue. L’ID 0 veut dire « détecté, pas appris », et le programme ne demande que l’ID 1 [5].
- Deux appareils à 0x29. Deux appareils ne peuvent pas partager une adresse. Regarde K5 et le guide d’Adafruit pour savoir comment en changer une [3].
- Rien dans le moniteur série. Règle-le sur 115200 baud.
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Un capteur de distance à temps de vol calcule la distance en mesurant quoi ?
- La luminosité de la pièce
- Le temps qu’une impulsion de lumière met à rebondir et revenir au capteur
- La chaleur de l’objet
Voir la réponse
Le temps qu’une impulsion de lumière met à rebondir et revenir au capteur. Le capteur envoie de la lumière et détecte le temps qu’elle met à revenir : le « temps de vol » [1]. Un trajet plus long veut dire un objet plus éloigné.
Un module caméra signale une cible colorée à x = 250, sur un écran qui va de 0 à 320. Avec le milieu à 160, quelle est l’erreur par rapport au centre (x moins le milieu) ?
- -90, car le milieu moins x est négatif
- 250, comme x
- +90, car 250 moins 160 font 90, un nombre positif
Voir la réponse
+90, car 250 moins 160 font 90, un nombre positif. Erreur = x moins le milieu : 250 - 160 = +90. L’écran de la caméra fait 320 pixels de large [8], donc le milieu est à 160. Une erreur positive veut dire que x est plus grand que le milieu (160).
Quelle broche de l’ESP32 doit alimenter la carte du capteur de distance, et pourquoi ?
- 3V3, car la carte doit recevoir la même alimentation que le niveau logique du microcontrôleur, soit 3,3 V sur l’ESP32
- 5V, car plus de tension donne une plus grande portée
- N’importe quelle GPIO, car une carte n’a presque pas besoin de courant
Voir la réponse
3V3, car la carte doit recevoir la même alimentation que le niveau logique du microcontrôleur, soit 3,3 V sur l’ESP32. La carte accepte de 3 à 5 V et son régulateur interne la ramène plus bas ; Adafruit conseille de lui donner la même alimentation que le niveau logique du microcontrôleur [2]. Ainsi SDA et SCL restent à 3,3 V (leçon K5).
En bref
- Un capteur à temps de vol chronomètre la lumière qui rebondit et la transforme en distance [1]. Son faisceau est étroit [1].
- Alimente la carte VL53L0X en
3V3, SDA sur la GPIO 21 et SCL sur la GPIO 22. Elle répond par défaut à0x29[2][3]. - Les mesures dont le
RangeStatusvaut 4 ne sont pas fiables [4]. - Un module caméra signale un rectangle :
xCenter,yCenter,width,heightet unID[5]. - L’écran fait 320 pixels de large [8], donc
error = xCenter - 160te dit où est la cible par rapport au milieu. - Le HuskyLens accepte de 3,3 à 5 V et demande environ 230 à 320 mA [8] : alimente-le à part, pas depuis la broche 3V3, et relie ses SDA et SCL par un adaptateur de niveau. Mets Protocol Type sur I2C [9].
Prochaines étapes : les projets avec servos (A2), ou la mission de la tourelle à cible colorée.
Sources
Voir les 13 sources
- Adafruit, « Adafruit VL53L0X Time of Flight Micro-LIDAR Distance Sensor Breakout : Overview » (temps de vol ; source laser invisible ; cône étroit contrairement au sonar ; portée d’environ 50 à 1 200 mm ; précision de 3 à 12 % selon la lumière et la distance) — https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/overview
- Adafruit, « Adafruit VL53L0X Time of Flight Micro-LIDAR Distance Sensor Breakout : Pinouts » (Vin accepte de 3 à 5 V grâce à un régulateur sur la carte ; lui donner la même alimentation que le niveau logique du microcontrôleur ; adresse I2C par défaut 0x29) — https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/pinouts
- Adafruit, « Adafruit VL53L0X Time of Flight Micro-LIDAR Distance Sensor Breakout : Arduino Code » (installer « Adafruit VL53L0X » depuis Manage Libraries ; exemple sous File > Examples ; moniteur série à 115200 ; « out of range » ; retirer le capuchon de plastique de protection ; adresse par défaut 0x29 et comment la changer) — https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/arduino-code
- Adafruit, bibliothèque Adafruit_VL53L0X, exemple « vl53l0x.ino » (rangingTest, RangeMilliMeter, RangeStatus 4 traité comme hors de portée) — https://raw.githubusercontent.com/adafruit/Adafruit_VL53L0X/master/examples/vl53l0x/vl53l0x.ino
- HuskyLens, dépôt HUSKYLENSArduino, README « HUSKYLENS Arduino API » (HUSKYLENSResult avec xCenter, yCenter, width, height, ID ; ID 1 = premier élément appris, 0 = détecté mais pas appris ;
begin(Wire);writeAlgorithmetALGORITHM_COLOR_RECOGNITION;requestBlocks(ID),available(),read(); délai d’attente par défaut 100 ms) — https://raw.githubusercontent.com/HuskyLens/HUSKYLENSArduino/master/README.md - Adafruit, « Distance Measurement with Ultrasound » (la sortie d’écho en 5 V du HC-SR04 ne peut pas être reliée directement à une carte en 3,3 V ; une électronique simple règle le problème) — https://learn.adafruit.com/distance-measurement-ultrasound-hcsr04
- Espressif, documentation Arduino-ESP32, « I2C » (sur l’ESP32 générique, les broches I2C par défaut sont la GPIO21 pour SDA et la GPIO22 pour SCL) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2c.html
- DFRobot, wiki HuskyLens K210 AI Vision Sensor (SEN0305), page principale (tension d’alimentation de 3,3 à 5,0 V ; courant typique de 320 mA à 3,3 V et de 230 mA à 5,0 V en reconnaissance de visage, lumière d’appoint éteinte ; interfaces UART et I2C ; écran IPS de 2,0 pouces, 320 sur 240 ; broches I2C T = SDA et R = SCL sur le connecteur à 4 broches) — https://wiki.dfrobot.com/HUSKYLENS_V1.0_SKU_SEN0305_SEN0336
- DFRobot, wiki HuskyLens, « General Settings » (Protocol Type : UART à trois vitesses, I2C ou détection automatique, valeur par défaut détection automatique) — https://wiki.dfrobot.com/sen0305/docs/22610
- DFRobot, wiki HuskyLens, « Function Introduction-Color Recognition » (choisir le mode avec le bouton de fonction ; pointer le « + » sur la couleur ; appui long sur le bouton d’apprentissage puis relâcher ; les ID suivent l’ordre d’apprentissage ; la reconnaissance de couleur dépend beaucoup de la lumière ambiante) — https://wiki.dfrobot.com/sen0305/docs/22645
- DFRobot, wiki HuskyLens, « Board Overview » (alimentation par le port USB ou le connecteur à 4 broches, l’USB passe en premier si les deux sont branchés ; s’assurer que la tension et le débit d’alimentation suffisent ; boutons de fonction et d’apprentissage) — https://wiki.dfrobot.com/sen0305/docs/22602
- DFRobot, wiki HuskyLens, « Example Code for Arduino-Read Position Data(I2C) » (décompresser la bibliothèque HUSKYLENS dans le dossier libraries d’Arduino, dossier nommé HUSKYLENS ; régler Protocol Type sur I2C ou utiliser la détection automatique ; exemple begin(Wire)) — https://wiki.dfrobot.com/sen0305/docs/22766
- HuskyLens, dépôt HUSKYLENSArduino, « HUSKYLENS/HUSKYLENS.h » (la bibliothèque parle à la caméra à l’adresse I2C 0x32) — https://raw.githubusercontent.com/HuskyLens/HUSKYLENSArduino/master/HUSKYLENS/HUSKYLENS.h