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 […]
 

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.

Arduino

Arduino est une plateforme de prototypage qui permet aux utilisateurs de créer des objets électroniques interactifs à partir de cartes électroniques sur lesquelles se trouve un microcontrô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.

Le capteur BH1750

Le composant BH1750 est un capteur d’intensité de lumière avec un convertisseur analogique-numérique 16 bits intégré qui émet un signal numérique en lux (Lx) à l’aide du protocole I2C. La plage couverte par le BH1750 est de 0 à 100 000 Lx (1-65535 lx).

https://abra-electronics.com/sensors/sensors-light-imaging-en/sens-bh1750-l.html?sl=fr

Unités de mesure et calculs

Le capteur BH1750 délivre une information en lux sur le bus I2C.

Lux (unité)

Le lux est une unité de mesure de l’éclairement lumineux (symbole : lx). Il caractérise l’intensité lumineuse reçue par unité de surface

Quelques valeurs d’éclairement de la vie courante :

  • Nuit de pleine lune 0,5 lux
  • Rue de nuit bien éclairée 20 à 70 lux
  • Local de vie100 à 200 lux
  • Appartement bien éclairé 200 à 400 lux
  • Local de travail 200 à 3 000 lux
  • Extérieur par ciel couvert 500 à 25 000 lux
  • Extérieur en plein soleil 50 000 à 100 000 lux

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.

APEX (Système additif d’exposition de photographie)

APEX (acronyme de « Additive system of Photography EXposure ») est une méthode de calcul du temps d’exposition basée sur une mesure en Ev (Exposure value) adoptée par la plupart des posemètres.

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

Indice de lumination

En photographie, l’indice de lumination (abrégé en IL ou EV d’après l’anglais exposure value) – parfois appelé indice de luminance – est un nombre qui caractérise un couple ouverture / temps de pose. Pour une scène donnée, deux couples caractérisés par le même indice de lumination produiront la même exposition sur le film ou capteur.

La formule pour passer des lux à un indice de lumination est la suivante : IL = ( log lx -log 2.5 ) / log 2. 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 Log2. En C++ il n’existe que des log10, mais la conversion est facile.

log2(x) = log10(x) / log10(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. luxISO = 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

J’ai maintenant un fichier d’outils pour mon programme avec des conversions et calculs testés.

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.