Boite à outils

Maintenant que mon projet prend forme dans ma tête, il est temps de coucher des éléments sur papier avant de les transformer en programme. Il faudra passer de l’information en Lux délivré par le capteur BH1750, à une exposition en EV, puis a un triangle d’exposition a une inconnue : Temps d’exposition, Ouverture du diaphragme et sensibilité ISO. Sans oublier mon intension de calculer la puissance du flash. Je vais avoir besoin d’une boite à outils. Les différents calculs sont dépendants du matériel d’une part pour le langage, d’autre part des unités de mesure du ou des capteurs.

Le matériel

Le principal composant de mon projet est un capteur d’intensité lumineuse. Une carte Arduino est chargé des calculs et de l’affichage des informations sur un écran LCD. On ajoutera quelques boutons pour dialoguer avec le micro contrôleur.

Les micro contrôleurs Arduino se programme avec un IDE en C++. J’ai un peu oublier ce langage mais c’était mon chouchou en version Windows dans les années 2000.

Unités de mesure et calculs

Le capteur BH1750 délivre une information en lux sur le bus I²C.

Ce n’est pas tout d’avoir des Lux mais il faut en faire quelque chose.. A force de chercher sur internet le calcul de l’exposition, de l’ouverture ou de la vitesse, Wikipédia m’a fournit une réponse : l’APEX.

L’APEX a pour base des EV ou Indice de lumination en français.

La formule pour passer des lux à un indice de lumination est la suivante : IL = ( log ^lx -log ^2.5 ) / log ². En C++ cela donne : IL ou Ev = round( log10( lux ) - log10( 2.5 )) / log10( 2 )); Les Ev et les lux sont des entiers, le calcul est arrondie pour supprimer les erreurs de conversion.

Si vous avez regardé les pages sur l’APEX vous avez vue que toutes les formules comportes des Log₂. En C++ il n’existe que des log₁₀, mais la conversion est facile.

log₂(x) = log₁₀(x) / log₁₀(2)

Il est maintenant temps de calculer le paramètre manquant de notre triangle d’exposition en fonction des 2 autres. J’ai donc testé 3 fonctions sur Arduino (C++). 1 fonctions pour le calcul de la durée d’exposition en mode priorité à l’ouverture. 1 fonction en mode priorité à la vitesse pour l’ouverture. Les premiers essais se font sur un émulateur Arduino : Tinkercad. On appliquera une division par la sensibilité ISO directement sur les lux pour tenir compte du troisième coté du triangle d’exposition. lux_ISO = lux / (sensibilité / 100).

Durée d’exposition en secondes = pow( 2, -( Ev - round( 2 * log2( ouverture ) ) ) ) En dessous de 1s on utilisera la formule 1/ Durée pour obtenir des fractions.

Ouverture en fraction de f = pow( 2, ( ( Ev - (- log2( secondes ) ) ) / 2) )

La troisième fonction est le calcul des Ev pour un duo Ouverture / Secondes.

Ev = round( ( 2 * log2( ouverture ) ) + ( - log2( secondes ) ) )

Admettons que le calcul donne pour un couple Ouverture – Secondes réglé sur notre APN donne 7 Ev. Le Flash lui délivre 10 Ev. 7 – 10 = -3 Ev. On passera par Example de 1/4 de puissance à 1/32

A ce stade j’ai toutes les fonctions utiles aux calculs de mon flashmètre. Sauf que j’obtiens des chiffres brutes qui ne correspondent pas exactement aux réglage des APN. J’ai besoin d’une fonction pour transformer 3.6458 en f/3.5.

Les tables et standardisation des valeurs

J’ai créé trois tables (array) contenant les valeurs standards des ouvertures et vitesses de mon APN. Il faudra peut-être les adapter pour d’autres matériels. Je n’ai pas d’objectif en dessous de f/1.8 et au dessus de f/22. De même mon APN à une plage de temps de pose de 1/4000s à 30s au delà c’est du BULB et on est loin des applications d’un flashmètre. La troisième table concerne la puissance des flashes, il me faudra peut être une fonction particulière pour la gérer.

// Array des valeurs possible d’ouverture pas de 1/3 f/1 -> f/22
float APERTURE_TABLE[] { 1, 1.1, 1.2, 1.4, 1.6, 1.8, 2, 2.2, 2.5, 2.8, 3.2, 3.5, 4, 4.5, 5, 5.6, 6.4, 7.1, 8, 9, 10, 11, 13, 14, 16, 18, 20, 22 };
float APERTURE_MIN = 1.00;
float APERTURE_MAX = 22.00;

// Array des valeurs possible de vitesse pas de 1/3 1/4000 -> 30s
float SHUTTERSPEED_TABLE[] { 0.00025, 0.0003125, 0.0004, 0.0005, 0.000625, 0.0008, 0.001, 0.00125, 0.0015625, 0.002, 0.0025, 0.003125, 0.004, 0.005, 0.00625, 0.008, 0.01, 0.0125, 0.01666666666, 0.02, 0.025, 0.03333333333, 0.04, 0.05, 0.06666666666, 0.07692307692, 0.1, 0.125, 0.16666666666, 0.2, 0.25, 0.3, 0.4, 0.5, 0.6, 0.8, 1, 1.3, 1.6, 2, 2.5, 3.2, 4, 5, 6, 8, 10, 13, 15, 20, 25, 30 };
float SHUTTERSPEED_MIN = 0.00025;
float SHUTTERSPEED_MAX = 30.00;

// Array des valeurs possible de puissance de flash pas de 1/3 1/256 -> 1
float POWER_TABLE[] { 0.00390625, 0.00520833333, 0.00651041666, 0.0078125, 0.01041666666, 0.01302083333, 0.015625, 0.02083333333, 0.02604166666, 0.03125, 0.04166666666, 0.05208333333, 0.0625, 0.08333333333, 0.10416666666, 0.125, 0.16666666666, 0.20833333333, 0.25, 0.33333333333, 0.41666666666, 0.5, 0.66666666666, 0.83333333333, 1 };
float POWER_MIN = 0.00390625; // 1/256
float POWER_MAX = 1;

Je ne voulais pas créer du code pour les ouvertures et les vitesses et alourdir mon programme, les micro contrôleurs sont limités en mémoire. J’ai écrit une fonction générique qui standardise une valeur en fonction d’une table.

float standardize( float valeur, float table[], float min, float max )
{
float retour = valeur; if( valeur < min ) { retour = -min; } else if( valeur == min ) { retour = min; } else if( valeur == max ) { retour = max; } else if( valeur > max ) {
retour = -max;
}
else
{
retour = valeur;
for( int i = 0; valeur > table[i]; i++ )
{
float moyenne = table[i] + ( ( table[i + 1] - table[i]) / 2 );
if( ( table[i] <= valeur ) && ( valeur < moyenne))
{
retour = table[i];
break;
}
else if( ( moyenne <= valeur ) && ( valeur < table[i + 1]))
{
retour = table[i + 1];
break;
}
}
}
return retour;
}

Un premier fichier pour Arduino : les outils

Mon projet avance bien et je pense avoir les outils nécessaires pour traiter des lux et les convertir en ouverture, temps de pose ou puissance de flash. La prochaine étape va consister a construire une interface pour fixer les priorités et les options.