Colorimètre portable

1. Objectif du projet

L'objectif n'était pas de réaliser un instrument de mesure professionnel, mais plutôt de concevoir un appareil simple permettant de relever une couleur et d'en obtenir une représentation numérique. Cette information peut ensuite être réutilisée dans différents contextes, par exemple pour retrouver sur un site internet une couleur observée sur une création.

Pour parvenir à un appareil réellement portable et agréable à utiliser, plusieurs contraintes se sont naturellement imposées :

• Format compact.
• Alimentation sur batterie rechargeable.
• Autonomie optimisée.
• Utilisation simple.

La réalisation de cet appareil a ainsi constitué un projet particulièrement intéressant, mêlant capteur de couleur, traitement des mesures, électronique embarquée et conception d'une interface utilisateur.

1.1 Alimentation

Plutôt qu'une pile bouton type CR2032, j'ai choisi un accumulateur Li-ion 2032 rechargeable, pour les raisons suivantes :

• Autonomie certes plus faible qu'une pile primaire.
• Résistance interne nettement plus faible.
• Capacité à délivrer un courant plus important (notamment pour les LED).

Un connecteur USB-C permet la recharge.

1.2 Affichage

Afin de minimiser la consommation, j'ai intégré un écran e-paper :

• Consommation quasi nulle en affichage statique.
• Énergie consommée uniquement lors du rafraîchissement.
• Excellente lisibilité.

2. Partie capteur

2.1 Capteur colorimétrique

Le capteur retenu est le TCS3400 (anciennement Osram / ams). Il fournit :

• Canaux R, G, B.
• Canal Clear (luminosité globale).
• Temps d'intégration configurable.
• Gain programmable.

Ce capteur permet des mesures colorimétriques de base, mais ne correspond pas directement à la réponse spectrale de l'œil humain.

2.2 Éclairage

Pour assurer une mesure stable :

• 6 LED blanches disposées en anneau.
• Température de couleur proche de D65 (~6500 K).
• Géométrie fixe (distance et angle constants).

Objectif : se rapprocher des conditions d'un illuminant standard D65.

2.3 Objectif fonctionnel

Le système :

• Mesure la couleur d'un échantillon.
• Convertit la mesure vers l'espace CIELAB.
• Compare avec une base de données RAL.
• Affiche la couleur RAL la plus proche.
• Reproduit visuellement la couleur via une LED RGB.

3. Limitations physiques

Points critiques à considérer :

• Réponse spectrale du capteur ≠ vision humaine.
• Sensibilité forte aux conditions d'éclairage.
• Influence possible de l'infrarouge.
• Bruit électronique et offset.
• Gamut limité de la LED RGB.

4. Traitement des mesures

4.1 Correction et normalisation

La première étape consiste à normaliser les valeurs. Plusieurs approches sont possibles :

• Division par la composante Clear (luminosité) : simple, mais peu précis.
• Division de chaque composante par la somme (R+G+B) : permet de réduire l'influence de la composante IR.
• Correction par les paramètres d'intégration (temps et gain configurés dans le capteur) : indispensable pour rendre les mesures comparables dans différentes conditions.

Correction par référence noir / blanc

Étape 1 : correction offset + gain via références noir/blanc. Mesures de référence :

• Blanc (PTFE diffus).
• Noir (capteur occulté).

Formule type (identique pour G et B) :

R_corr = R_mes − R_noir R_Blanc − R_Noir

Vérification impérative :

• Absence de saturation ADC.
• Linéarité en fonction du temps d'intégration.

4.2 Normalisation par la composante Clear

Pour les capteurs RGB filtrés (comme le TCS3400), une pratique robuste consiste à combiner la correction noir avec une normalisation par la composante Clear :

R_CORR = R_mes − R_noir C_mes − C_noir

G_CORR = G_mes − R_green C_mes − C_green

B_CORR = B_mes − R_blue C_mes − C_blue

5. Conversion vers un espace colorimétrique standard

5.1 Passage RGB capteur → XYZ

On cherche une matrice 3×3 de passage :

X Y Z = M · R_corr G_corr B_corr

La matrice M est déterminée par régression en moindres carrés à partir d'un jeu de patchs de référence, par exemple le ColorChecker Classic.

5.2 Construction matricielle

Soit :

• R : matrice 3×N des mesures corrigées, une colonne par patch.
• X : matrice 3×N des valeurs XYZ de référence.

R = [r₁ ... r_N] avec r_i = [R_corr, G_corr, B_corr]^T

On minimise :

‖X − MR‖_F

Solution analytique (moindres carrés) :

M = X · R⁺

où R⁺ est la pseudo-inverse de Moore-Penrose de R. De façon équivalente, lorsque R·R^T est inversible :

M = XR^T(RR^T)⁻¹

En pratique, ce calcul se fait simplement avec numpy :

M = X @ np.linalg.pinv(R)

5.3 Conversion XYZ → CIELAB

Utilisation du modèle CIE 1931 (observateur 2°, illuminant D65). L'espace CIELAB (L*, a*, b*) est conçu pour correspondre à la perception visuelle :

• L* : luminosité (0 = noir, 100 = blanc).
• a* : axe vert ↔ rouge.
• b* : axe bleu ↔ jaune.

Formules (simplifiées) :

L^* = 116 · f(Y / Y_n) − 16

a^* = 500 · [f(X / X_n) − f(Y / Y_n)]

b^* = 200 · [f(Y / Y_n) − f(Z / Z_n)]

où X_n, Y_n, Z_n sont les coordonnées du blanc de référence (illuminant D65).

6. Recherche de la couleur RAL la plus proche

Une fois la couleur exprimée en CIELAB, il suffit de comparer la valeur mesurée avec une base de données des couleurs RAL (dont les valeurs CIELAB sont disponibles publiquement). La proximité entre deux couleurs est évaluée par une distance ΔE.

Deux méthodes :

• ΔE76 (euclidienne simple).
• ΔE2000 (plus fidèle perceptuellement, mais plus complexe à calculer).

Distance colorimétrique ΔE76

ΔE₇₆ = (L^*₁ − L^*₂)² + (a^*₁ − a^*₂)² + (b^*₁ − b^*₂)²

La couleur RAL retenue est celle qui minimise ΔE avec la mesure.

Reproduction avec la LED RGB

Une fois la couleur mesurée :

• On prend les coordonnées XYZ ou sRGB correspondantes.
• On applique une correction gamma pour la LED RGB.
• On module l'intensité des 3 canaux de la LED.

⚠️ Limitation : une LED RGB standard ne peut pas reproduire toutes les couleurs (gamut limité). Certaines teintes sortiront donc approximatives.

7. Mesures et calibration — étapes détaillées

7.1 Préparer les mesures

• Un jeu de patchs colorés bien répartis dans l'espace chromatique (comme le ColorChecker 24 — idéalement plus de 24 patchs).
  
• Chaque échantillon est mesuré avec la même géométrie d'éclairage/mesure (distance, angle).
• Les LEDs proches de la température 6500 K, comme pour la mesure de référence X-Rite.
• Pour chaque patch je prends:
• lecture brute du capteur (R_mes, G_mes, B_mes, Clear)
• temps d'intégration et gain identiques (728 ms / 1x).
• la lecture X-Rite (X_ref, Y_ref, Z_ref). ou RGB référencés en XYZ fournis par le logiciel X-Rite)
• les références noir et blanc relevées pour la correction du capteur.
• Correction des offsets et normalisation, avec vérification de l'absence de saturation (valeurs = max ADC).

7.2 Tableau de mesures des 24 patchs — références noir / blanc

7.3 Tableau de référence — ColorChecker Classic (D65 / 2°)

7.4 Construction des matrices pour la régression

Pour construire la matrice M, j'ai utilisé un script Python (nécessite la librairie numpy) :

• Soit R la matrice 3×N contenant les mesures corrigées, une colonne par patch.
• Soit X la matrice 3×N contenant les XYZ de référence pour chaque patch, une colonne par patch.
• On cherche M (3×3) minimisant ‖X − MR‖_F (norme de Frobenius).
• Solution analytique (moindres carrés), si R a un rang suffisant : M = X·R⁺, où R⁺ est la pseudo-inverse de Moore-Penrose de R (calculée simplement avec np.linalg.pinv).

Exemple de résultat obtenu pour M :

M = 1.72431563 0.27218649 0.18021445 −0.5794922 1.26611686 −1.1258736 0.53206025 0.21724840 2.68620501

7.5 Validation

• Appliquer M aux mesures d'un jeu de validation indépendant.
• Convertir les XYZ estimés en CIELAB (avec le blanc de référence approprié) et calculer ΔE (ΔE2000 pour plus de précision perceptuelle).
• Vérifier l'erreur moyenne et maximale (ex. ΔE moyen < 2–3 : bon pour un usage grand public ; < 1 : excellent).

7.6 Pistes d'amélioration

• Si l'erreur est trop grande : augmenter le nombre de patchs, utiliser des patchs spectralement variés, vérifier la linéarité du capteur (temps d'intégration), retirer les patchs saturés, ou envisager une transformation non linéaire (ex. termes quadratiques ou LUT).
• Si l'illuminant du prototype (LED) diffère de l'illuminant du X-Rite : appliquer une adaptation chromatique (Bradford) entre illuminants avant comparaison en Lab.

8. Implémentation embarquée du produit matriciel

Rappel : soit une matrice 3×3 M et un vecteur colonne v :

M = a b c d e f g h i    v = x y z

Le produit M·v donne un nouveau vecteur v' :

v' = M · v = a·x + b·y + c·z d·x + e·y + f·z g·x + h·y + i·z

		// Multiplie une matrice 3x3 par un vecteur colonne 3x1
				
		void mat3x3_vec3_mult(const float mat[3][3], const float vec[3], float result[3]) 
			{
			for (uint8_t i = 0; i < 3; ++i) 
				{
					result[i] = 0.0f;
					for (uint8_t j = 0; j < 3; ++j) 
						{
							result[i] += mat[i][j] * vec[j];
						}
					}
            }
		

Conception hardware

L’alimentation du module est assurée par un accumulateur rechargeable LIR2032, une pile bouton lithium-ion de 3,6 V et d’une capacité typique de l’ordre de 40 mAh. Sa faible taille permet de conserver un format compact tout en offrant une alimentation autonome pour le module.

La recharge de l’accumulateur est assurée par le MCP73831-2-OT, un circuit intégré spécialement conçu pour la gestion de la charge des accumulateurs lithium-ion et lithium-polymère à cellule unique. Il fonctionne selon un profil de charge courant constant / tension constante (CC/CV) et intègre la régulation de la tension de charge ainsi que la limitation du courant.

Dans cette application, le MCP73831-2 est configuré pour une tension de charge adaptée à l’accumulateur LIR2032. Le courant de charge est défini par une résistance externe, ce qui permet d'adapter la recharge aux caractéristiques de l’accumulateur. Le circuit fournit également une sortie d’état permettant d’indiquer le déroulement de la charge et sa fin.

Cette solution présente l’avantage de regrouper la gestion complète de la recharge dans un composant très compact, tout en nécessitant peu de composants externes.

Deux transistors MOSFET Q3 et Q4, commandés par le microcontrôleur, permettent de couper complètement l’alimentation du circuit lorsque celui-ci passe en veille profonde. Cette fonction permet couper la consommation de l’accumulateur pendant les périodes d’inactivité.

Un petit bouton-poussoir permet de réveiller le système lorsqu’il est en veille et, lorsque celui-ci est actif, de déclencher une nouvelle mesure.

La tension fournie par l’accumulateur est ensuite régulée à 3,3 V par un régulateur linéaire LDK130, afin d’assurer une alimentation stable aux différents composants du module.

Microcontrôleur

Le microcontrôleur STM32L432KCUx, choisi pour sa très faible consommation, assure la gestion de l'ensemble du système. Il pilote notamment l'afficheur e-paper E2154 ainsi que le capteur de couleur TCS34003FNM. Il permet également de reproduire la couleur mesurée à l'aide d'une LED RGB APTF1616LSEKJ3ZGKQBC.

L'afficheur e-paper E2154 a été retenu principalement pour sa très faible consommation et sa bonne lisibilité. Contrairement à un écran traditionnel, l'image reste visible sans que l'afficheur ait besoin d'être alimenté en permanence. Une fois l'information affichée, la consommation devient pratiquement nulle.

L'écran permet ainsi d'afficher les différentes informations de mesure, notamment les valeurs des composantes de couleur.

L'éclairage de la zone de mesure est assuré par six LED CSL1101WBBW1, dont les caractéristiques spectrales sont particulièrement proches de celles de l'illuminant standard D65.

Conception du boîtier sous FreeCAD

Le boîtier a été entièrement modélisé sous FreeCAD à partir des dimensions du circuit imprimé. J'ai conçu les différentes parties du boîtier afin qu'elles s'adaptent précisément à la carte et aux composants. Le modèle a ensuite été exporté et imprimé en 3D pour réaliser le boîtier final.