Discussion :

[boijea]

Bonjour les vacanciers,

Sur mes Raspberry Pi 3, j'utilise un capteur de lumière avec une photorésistance.
Je n'utilise pas de convertisseur analogique-numérique, mais une simple capacité de 1 μF.
Je charge avec GPIO.OUT, fait une pause de 100ms et passe ensuite en GPIO.IN pour compter en Python:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
   while (GPIO.input(pin_to_circuit) == GPIO.LOW):
        count += 1

Les valeurs retournées sont tout à fait utilisables, comme 2000 en haute lumière, 20'000 en fin de journée et 140'000 lorsque le soleil se couche.

J'ai un script Python qui lit 8 fois la valeur, ignore les deux plus grandes et petites, et fait une moyenne des 4 valeurs triées restantes.
Ce mécanisme marche parfaitement et est suffisamment rapide.
Mon application Java, qui utilise cette valeur, peut réagir tout à fait correctement au passage d'une personne devant mon capteur de présence, et si l'intensité de la lumière n'est pas trop élevée, pour allumer une lampe installée sur mon armoire au rez.

Où la chose se gâte: au milieu de la nuit, j'obtiens des valeurs de count dépassant le million, et c'est normal.

Mon script Python détermine si la valeur retournée devient trop grande et je lis alors moins de valeurs en réduisant les lectures par exemple de 8 à 4.
Mais cela ne suffit pas. Avec des valeurs de count élevées, la réaction est beaucoup trop lente, aussi pour ignorer les changements d'intensité, dans le script Python, lorsque mon ampoule s'allume ou s'éteint (c'est un processus parallèle). Ces dernières valeurs doivent être ignorées comme lorsque le relais est actif.

La nuit je désactive le contrôle de lumière et n'utilise que le capteur de présence pour éclairer l'escalier qui descend au rez.
Ce logiciel fait partie d'un simulateur de présence qui active des lampes tôt le matin et en soirée, avec de courtes périodes éteintes, des valeurs légèrement aléatoires et évidemment saisonnières en calculant le lever et le coucher du soleil.
L'extension que j'écris à présent permet d'activer le relais en pleine journée si la lumière est faible. C'est le même cas de figure, que je vais tester ces prochains jours, lors des couchers ou levers de soleil en périodes nuageuses.
Je teste cette application Java sous Eclipse, où le GPIO et les capteurs sont simulés avec des valeurs fixes ou alléatoires et avec des printouts supplémentaires dans la console Eclipse. Le Debug mode d'Eclipse est essentiel.

Donc ma question: y a-t-il un moyen d'imaginer un circuit, un peu plus élaboré que ma capacité et ma photorésistance, sans convertisseur analogique-numérique, pour détecter ces cas de très basses lumières ... comme la nuit totale!?

Merci d'avance pour de nouvelles idées

[Auteur]

Bonsoir,

tout d'abord une question :

Je charge avec GPIO.OUT, fait une pause de 100ms et passe ensuite en GPIO.IN pour compter en Python:

Que veux-tu dire ? Ta voie est tantôt une entrée tantôt une sortie ?

As-tu la référence de la photorésistance ?

Pour ton projet, je pense que d'abord tu devrais amplifier la tension aux bornes de ta photorésistance, avec un AOP ou un simple transistor. Tu auras une plus grande sensibilité. Ensuite, puisque tu ne veux pas utiliser de convertisseur analogique numérique, tu peux brancher un convertisseur tension / fréquence à la sortie de ton amplificateur (un exemple ici : https://www.sonelec-musique.com/elec..._freq_001.html). Ton script Python aura ensuite à compter les tops du convertisseur pour allumer ou éteindre la lumière.

Je ne vois pas plus simple

[f-leb]

Sur mes Raspberry Pi 3, j'utilise un capteur de lumière avec une photorésistance.
Je n'utilise pas de convertisseur analogique-numérique, mais une simple capacité de 1 μF.
Je charge avec GPIO.OUT, fait une pause de 100ms et passe ensuite en GPIO.IN pour compter en Python:

Curieux cette façon de faire, je ne sais pas trop quoi en penser, mais si ça fonctionne

Sinon, tu connais peut-être ce genre de modules tout prêt :


C'est une LDR avec un comparateur LM393. La tension aux bornes de la LDR est comparée à celle prise sur le curseur d'un potentiomètre. Le potentiomètre est réglable avec un petit tournevis. Donc quand la luminosité franchit un seuil réglable, tu as une sortie numérique D0 qui change d'état.

[boijea]

Bonsoir,

tout d'abord une question :

Que veux-tu dire ? Ta voie est tantôt une entrée tantôt une sortie ?

As-tu la référence de la photorésistance ?

Pour ton projet, je pense que d'abord tu devrais amplifier la tension aux bornes de ta photorésistance, avec un AOP ou un simple transistor. Tu auras une plus grande sensibilité. Ensuite, puisque tu ne veux pas utiliser de convertisseur analogique numérique ....

Oui, on charge la capacité et ensuite on la mesure:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def rc_time (pin_to_circuit):
    count = 0
 
    #Configuration en sortie
    GPIO.setup(pin_to_circuit, GPIO.OUT)
    GPIO.output(pin_to_circuit, GPIO.LOW)
    time.sleep(0.1)  #pause de charge
 
    #Configuration en entrée
    GPIO.setup(pin_to_circuit, GPIO.IN)
 
    #Comptage
    while (GPIO.input(pin_to_circuit) == GPIO.LOW):
        count += 1
 
    return count

Photorésistance classique, j'en ai un paquet. De la série GL55xx. Lequel exactement, pas sûr que cela a une grosse importance.
C'est une solution simple, rapide et bon marché.
En changeant par exemple le 0.1 ci-dessus en 1.0, cela ne change pratiquement pas le résultat.

Si si, j'ai des convertisseur analogique numérique ... mais ici je voudrais faire sans ... car cela marche assez bien.
J'ai déjà beaucoup de choses sur mes breadboards, comme des Dallas.

L'ampli me plaît ... mais je suis plus informaticien ... mais cela m'intéresse ... quoique le circuit que tu donnes est complexe.
Un traitement par logiciel semble possible.
Merci

[Auteur]

Si j'ai bien compris ton script : tu configures la voie en sortie pour charger le condensateur pendant un temps de 0,1s environ. Ensuite, tu configures ta voie en entrée. Ta boucle while compte le temps qu'il faut pour que ton entrée soit à 0V. Si ta résistance est grande ton condensateur se déchargera lentement, si ta résistance est faible il se déchargera rapidement (T=RC à la louche). La valeur de count te dira si tu es en plein jour ou en pleine nuit.

Visiblement en plein lumière (100 lux) la résistance ne passe pas en dessous de 5kohm donc a priori pas de risque de court-circuit de la voie choisie.

Peut-être que placer la photo-résistance dans un pont de Wheastone et mesurer la tension pourrait être une idée aussi : mais il faut bien déterminer la position d'équilibre.

[boijea]

Si j'ai bien compris ton script : tu configures la voie en sortie pour charger le condensateur pendant un temps de 0,1s environ. Ensuite, tu configures ta voie en entrée. Ta boucle while compte le temps qu'il faut pour que ton entrée soit à 0V. Si ta résistance est grande ton condensateur se déchargera lentement, si ta résistance est faible il se déchargera rapidement (T=RC à la louche). La valeur de count te dira si tu es en plein jour ou en pleine nuit.

Visiblement en plein lumière (100 lux) la résistance ne passe pas en dessous de 5kohm donc a priori pas de risque de court-circuit de la voie choisie.

Peut-être que placer la photo-résistance dans un pont de Wheastone et mesurer la tension pourrait être une idée aussi : mais il faut bien déterminer la position d'équilibre.

En Fritzing:


Oh là là ... merci ... il y a du potentiel!
Sur https://fr.wikipedia.org/wiki/Pont_de_Wheatstone la photorésistance serait la R2.

Même que ce pont me rappelle quelque chose avant ou juste après le bac!
Il semble qu'il me suffirait de remplacer simplement ma photorésistance par ce circuit, en choisissant les bonnes valeurs des R, et de jouer avec des valeurs différentes de 0.1 (time.sleep(0.1) #pause de charge).

Photorésistance classique, j'en ai un paquet. De la série GL55xx. Lequel exactement, pas sûr que cela a une grosse importance.

Oui, je suis un peu null! C'est assez normal pour un informaticien qui oublie ses connaissances en électronique et qui sort une photorésistance, n'importe laquelle, d'un paquet qui contient 5 autres petits paquets!
Des 5516, 5537, 5528, 5539 et 5541 (le premier 7 et le 4 presque effacés).
Il faudra que je les teste et choisisse la meilleure.

J'ai déjà modifié le design de mon application pour qu'il ne considère pas un niveau de lumière trop basse.
Cela donne de bon résultat.
Cependant, en choisissant la 55xx la plus proche de mes besoins, je devrais obtenir de meilleurs résultats et une boucle Python qui termine un peu plus rapidement.
La dernière ligne de mon code Python:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

r = requests.post("http://127.0.0.1:8000/set", data={'light': average})

Mon application Java possède un serveur Web en Thread qui reçoit la lumière.
Il suffirait de modifier 127.0.0.1:8000 pour l'envoyer ailleurs comme sur un ESP8266!

Quand j'aurai quelque chose de solide, j'essaierai avec un de mes MCP3008.

C'est vraisemblable qu'on pourrait trouver des cas d'application où il est nécessaire d'identifier de très basses intensités de lumière et de ne pas attendre parfois 1 minute ou plus!?!
J'ai déjà essayé avec le Pi4J, mais c'est moins réactif (même code que Python) et c'est la cata à minuit. Je dois encore essayer avec un ChangeListener (Pi4J).

[Auteur]

Tiens, je n'avais vu les choses comme ça : pour moi ton condo et ta résistance étaient en parallèle. Je pense à un montage mais je vais devoir faire des tests avant pour vérifier quelques éléments.

[boijea]

Curieux cette façon de faire, je ne sais pas trop quoi en penser, mais si ça fonctionne

Sinon, tu connais peut-être ce genre de modules tout prêt :


C'est une LDR avec un comparateur LM393. La tension aux bornes de la LDR est comparée à celle prise sur le curseur d'un potentiomètre. Le potentiomètre est réglable avec un petit tournevis. Donc quand la luminosité franchit un seuil réglable, tu as une sortie numérique D0 qui change d'état.

Je pense que ma manière de faire est correcte et je suis content ... lorsqu'il y a de la lumière, disons raisonnable.
De plus ces photorésistances ne coûtent rien. A l'occasion je pourrais commander ce module que j'ai déjà vu.

Dans mon cas je fais le réglage par une interface Web où je définis la limite de déclenchement.
Elle se trouve actuellement vers les 90'000 pour mon installation au rez.

Si je pouvais, avec un circuit simple, pour disons faire descendre cette valeur à 10 ou 100 fois moins, cela aiderait.

Je m'explique un peu mieux pour un des cas de figure:

• un mouvement est détecté;
• si la valeur retournée par mon script Python est en dessus de 90'000 (peu de lumière) j'enclenche le relais de ma lampe pour 92 secs (temps d'aller aux toilettes pour une petite commission);
• le 90'000 vient d'une moyenne (après retrait des extrêmes) d'une série de 8, voire de 4 mesures, de mon script Python qui tourne en // (lancé au démarrage du Pi) et qui recommence indéfiniment;
• après 92 secs, mon script m'a déjà retourné de nouvelles valeurs plus basses (vers les 5000), car ma lampe éclaire;
• j'ai codé une série d'astuces pour "essayer" d'identifier que la valeur reçue provient du cas de la lampe allumée et que je dois l'ignorer (cela marche assez bien);
• le gros soucis est le suivant avec un petit exemple: le script Python démarre et reçois très vite deux valeurs (vers les 5000) qui viennent très vite (dans le script, pas dans l'application), mais le script en a besoin de quelques-unes de plus pour évaluer la moyenne. Si ces dernières viennent du cas où c'est presque la nuit complète, le script va devoir les attendre trop longtemps avant de sortir de sa boucle et donner une valeur plus ou moins correct (j'ignore une partie des extrêmes). Le logiciel n'est pas facile;
• J'ai le même cas de situation, sans mouvement, lorsque subitement de gros nuages passent et disparaissent rapidement, lorsque je dois réactiver mon simulateur de présence avec la lampe qui s'allume et s'éteint de manière aléatoire;
• Cette dernière n'a pas besoin de précision, mais le capteur de mouvement DOIT réagir vite dans tous les cas.
• C'est une jolie application.

Ce qui est intéressant, c'est qu'en écrivant ces messages (et en recevant de belles réponses, merci), on pense autrement que d'essayer d'ajouter du code pour traiter ces cas devant son écran.

Et j'ai peut-être une solution dans le script:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    #Comptage
    while (GPIO.input(pin_to_circuit) == GPIO.LOW):
        count += 1

A minuit, j'obtiens vers le 2'000'000.
Si ma limite est vers les 90'000, je pourrais stopper la boucle et mon script réagirait plus vite.
Et beaucoup mieux: mon application Java utilise un fichier de configuration où cette limite est définie (comme par exemple aussi les broches GPIO utilisée).
Je pourrais la lire et y mettre une valeur un peu plus haute comme 100'000 pour identifier ce cas.
Si la moyenne est 100'000 c'est vraiment la nuit, et pas d'autres lumières venant du relais voire d'autres luminaires dans la maison.

[f-leb]

Si j'ai bien compris ton script : tu configures la voie en sortie pour charger le condensateur pendant un temps de 0,1s environ. Ensuite, tu configures ta voie en entrée. Ta boucle while compte le temps qu'il faut pour que ton entrée soit à 0V. Si ta résistance est grande ton condensateur se déchargera lentement, si ta résistance est faible il se déchargera rapidement (T=RC à la louche). La valeur de count te dira si tu es en plein jour ou en pleine nuit.

J'ai l'impression que c'est l'inverse. On décharge pendant 0,1s, et on attend que le condensateur se charge suffisamment pour basculer l'entrée à HIGH, non ?

Et moins il y a de luminosité, plus le condensateur met du temps à se charger.

Le dispositif est astucieux, mais je ne vois pas comment rendre le dispositif "réactif" alors qu'il est basé sur la mesure d'un temps qui augmente quand ça devient intéressant

[Auteur]

J'ai l'impression que c'est l'inverse. On décharge pendant 0,1s, et on attend que le condensateur se charge suffisamment pour basculer l'entrée à HIGH, non ?
Et moins il y a de luminosité, plus le condensateur met du temps à se charger.

Effectivement la sortie dans la 1ère étape est à l'état bas et non à l'état haut.

Le dispositif est astucieux, mais je ne vois pas comment rendre le dispositif "réactif" alors qu'il est basé sur la mesure d'un temps qui augmente quand ça devient intéressant

J'avais pensé au circuit RC avec R la photorésistance. Le circuit RC serait alimenté par une sortie PWM et on attend que la tension aux bornes du condensateur atteigne 5V (T=2*Pi*RC), ou plutôt que l'entrée du Raspberry passe à l'état haut. La durée de charge est un indicateur de la luminosité. Je me disais que dans les conditions du circuit dérivateur on pourrait répondre à la problématique. Il faut toutefois régler le rapport cyclique et la valeur de C pour que le condensateur se charge et se décharge convenablement. On a l'intervalle de R et la fréquence du PWM, les calculs ne devraient pas poser trop de problème.
Après, n'ayant pas réalisé de test, je ne peux pas dire si le montage est une solution ou une absurdité

[Vincent PETIT]

Auteur et f-leb ont déjà tout dit mais je me permet de faire un petit résumé de la manipulation pour que tous les lecteurs comprennent de quoi nous parlons.

Le montage est un circuit RC série où R est une photorésistance et C un condensateur. Le condensateur se charge de façon exponentielle au rythme de la constante de temps R₁ * C₁. Si on prend le condensateur initialement déchargé.

V_C1 = 3.3V * (1 - e(-t / (R₁*C₁)))
avec -t = le temps qui passe

A titre d'exemple, si R₁ = 10kΩ, C₁ = 1µF et considéré à 0V au départ. On aura aux bornes de C₁, aux instants -t, les tensions :
-t = 0.001s 3.3V * (1 - e(-0.001s / (10 000Ω * 0.000001F))) = 0.314V
-t = 0.002s 3.3V * (1 - e(-0.002s / (10 000Ω * 0.000001F))) = 0.598V
-t = 0.005s 3.3V * (1 - e(-0.005s / (10 000Ω * 0.000001F))) = 1.298V
-t = 0.010s 3.3V * (1 - e(-0.010s / (10 000Ω * 0.000001F))) = 2.085V
-t = 0.020s 3.3V * (1 - e(-0.020s / (10 000Ω * 0.000001F))) = 2.853V
-t = 0.050s 3.3V * (1 - e(-0.050s / (10 000Ω * 0.000001F))) = 3.277V
-t = 0.100s 3.3V * (1 - e(-0.100s / (10 000Ω * 0.000001F))) = 3.299V

boijea, en faisant

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#Configuration en sortie
    GPIO.setup(pin_to_circuit, GPIO.OUT)
    GPIO.output(pin_to_circuit, GPIO.LOW)
    time.sleep(0.1)  #pause de charge

réalise la condition de départ ; le condensateur initialement à 0V.

Puis il configure la broche numérique du RPI en entrée ce qui va créer un seuil de déclenchement, initialement à LOW vers HIGH. Reste qu'a compter le temps qui passe jusqu'à ce qu'une des courbes ne dépasse le seuil.



Toutefois, la mise au point va être compliqué si on veut obtenir de la précision de mesure. Si on regarde la datasheet du RPI ci dessous on voit que, pour un micro alimenté en +3.3V, un LOW c'est une tension en dessous de 0.9V et qu'un HIGH c'est une valeur au dessus de 1.6V mais entre 0.9V et 1.6V le constructeur ne dit rien. Souvent c'est source de jitter (un coup LOW, un coup HIGH ainsi de suite jusqu'à être fixé par les tensions de la datasheet)



C'est donc une source d'incertitude qu'il faudrait lever par exemple en faisant un étalonnage, on envoie une tension connue dans le RPI pour savoir à partir de quelles valeurs ont est à LOW ou HIGH et ce qui se passe entre les deux. Une autre source d'incertitude c'est la tolérance de R et de C ainsi que de la non linéarité du système. Là aussi il faudrait un étalonnage pour savoir qu'elle est la valeur exacte de la photorésistance pour un lux donnée.

Ceci rend donc complexe la finesse du système et la répétabilité sur un autre RPI.

Ensuite, comme le dit f-leb la rapidité de ce montage est lié à la constante de temps et plus il fera sombre plus la détection prendra de temps. Je dirai qu'il faut un montage plus élaboré pour gagner en finesse d'ajustement et en rapidité.

[boijea]

Merci à tous, les électroniciens, j'ai du travail.
Il y a du potentiel et je vais essayer tout cela.

Entre temps mon logiciel d'application marche beaucoup mieux et je ne vais plus le toucher.
Je vais donc modifier mon circuit (aussi avec d'autres photorésistances).
Actuellement j'ai vers 2 secs maximum de réaction pour une basse lumière.

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def rc_time (pin_to_circuit):
    count = 0
 
    #Configuration en sortie
    GPIO.setup(pin_to_circuit, GPIO.OUT)
    GPIO.output(pin_to_circuit, GPIO.LOW)
    time.sleep(0.1)  #pause de charge
 
    #Configuration en entrée
    GPIO.setup(pin_to_circuit, GPIO.IN)
 
    #Comptage
    while (GPIO.input(pin_to_circuit) == GPIO.LOW):
        count += 1
        if (count > 150000):
           return 150000
    return count

Je stoppe à 150000.
Il retourne plus vite, mais je ne connaitrai pas la valeur de la basse lumière (pas important pour mon application).
Cette boucle est appelée plusieurs fois pour mon calcul de moyenne (éliminer un flash de lumière par exemple).

J'ai déjà utilisé les sorties PWM pour un buzzer.

Je posterai mon ou mes scripts Python avec les schémas Fritzing.
Pour commencer, pour comparer, je vais rajouter une seconde photorésistance sur le breadboard de mon second système, un Pi 3 A+.
A+

[boijea]

Merci à tous, les électroniciens, j'ai du travail.
.....

Merci vraiment et c'est une leçon pour moi.
Bien sûr qu'on peut maîtriser presque parfaitement la programmation et les outils Linux, mais cela ne suffit pas, pour les bricoleurs GPIO du Raspberry Pi.

D'abord j'aurais dû commencer par donner mon schéma Fritzing avec une meilleure explication de ce que j’essayais de faire.

Oui, je suis un peu null! C'est assez normal pour un informaticien qui oublie ses connaissances en électronique et qui sort une photorésistance, n'importe laquelle, d'un paquet qui contient 5 autres petits paquets!
Des 5516, 5537, 5528, 5539 et 5541 (le premier 7 et le 4 presque effacés).
Il faudra que je les teste et choisisse la meilleure.

Sortir n'importe quel photorésistance de n'importe quel paquet ... alors que d'habitude je vérifie au multi-mètre chaque résistance utilisée et le bon sens d'un condensateur! A pleurer!

C'est clair qu'il faut consulter les datasheets (par exemple https://reference.digilentinc.com/_m...esistor_ds.pdf)!
Avec mon multimètre, j'ai vérifié la résistance de ma photorésistance (sortie de n'importe quel paquet ) et je l'ai remplacée par une GL5549.

Cette dernière est nettement plus sensible, donc mon script Python réagit nettement plus rapidement (environ 6 fois en lumière normale (il pleut aujourd'hui)) et surtout beaucoup plus vite (vers les 50 fois) à très très basse lumière.

Je n'ai pas utilisé de sortie PWM (par exemple broche physique 32) car envoyer des pulses me semblerait diminuer la charge de la capacité, ce qui n'est pas intéressant en très basse lumière.
Je me suis même demandé ce qui se passerait si je mettais une résistance calculée juste en parallèle de la photorésistance pour accélérer la charge en basse lumière.
Les électroniciens feront sans doute des commentaires.

Pour la calibration, ce n'est pas un souci. Je n'utilise pas les Lux mais la détermine en fonction de la position de chaque système.
Je n'ai pas besoin de précision, juste une limite chiffrée.
Je vais devoir aussi adapter mon script Python pour qu'il stoppe la boucle (ancienne valeur de 150000) beaucoup plus vite (en dessous de 10'000 il me semble).
Pour l'instant mon script Python envoie trop souvent des valeurs à mon application .... il va trop bien et trop vite!

Je viens de reprendre ma classe Java (Pi4J) qui à présent, avec la GL5549, réagit 10 fois plus vite que ma version Python.
Je vais donc remplacer mon script Python qui tourne en arrière-plan par cette classe (inutilisable auparavant à cause du temps de réaction).

Sans multimètre, sans électroniciens éclairés sur developpez.net ... t'oublies!

Merci encore.

[Vincent PETIT]

Je me suis même demandé ce qui se passerait si je mettais une résistance calculée juste en parallèle de la photorésistance pour accélérer la charge en basse lumière.

C'est une possibilité ou bien on peut aussi réduire la valeur du condensateur, ce qui produira le même effet. Une charge encore plus rapide.

A+

[boijea]

... ou bien on peut aussi réduire la valeur du condensateur, ce qui produira le même effet. Une charge encore plus rapide.
A+

J'y avais pensé.
Mais c'était le minimum que j'avais trouvé dans mon gros paquet de capacités, un kit de 120 capacités commandé pour mes bricolages Arduino/ESP/Raspberry Pi

Ce qui est pratique, c'est ma toute grosse loupe pour lire les inscriptions sur ces petits composants.
Cette loupe a plus de 100 ans et appartenait à mon grand-père né dans les années 1880!
A l'époque on avait souvent des enfants à 40 ans!

Tiens je me demande s'il serait possible de mesurer une capacité avec un multimètre?
J'ai un UNI-T UT61A.

Merci
A+

[boijea]

Bonjour,

Je pense que je vais pouvoir fermer cette discussion rapidement. Mes conclusions principales sont:

• Il ne faut pas prendre n'importe quelle photorésistance et il faut consulter les datasheets
  
• Suivant l'application qui nécessite cette mesure, il faut vraiment s'accrocher pour que le design de son logiciel soit correct et pour que ce dernier soit fonctionnel.

Le plus important au niveau logiciel est de stopper la boucle de lecture:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def rc_time (pin_to_circuit):
    count = 0
 
    #Configuration en sortie
    GPIO.setup(pin_to_circuit, GPIO.OUT)
    GPIO.output(pin_to_circuit, GPIO.LOW)
    time.sleep(0.1)  #pause de charge
 
    #Configuration en entrée
    GPIO.setup(pin_to_circuit, GPIO.IN)
 
    #Comptage
    while (GPIO.input(pin_to_circuit) == GPIO.LOW):
        count += 1
        if (count > 6000):
           return 6000
    return count

Ici, si on ne stoppe pas à 6000, il faudra attendre plusieurs minutes au milieu de la nuit pour obtenir une réponse.
Même si la réponse venait dans les 10 secondes, ce n'est pas suffisant pour réagir pour une application nécessitant par exemple cette mesure à la suite d'un mouvement détecté par un capteur.

Ensuite au niveau design, on pourrait mettre cette lecture dans un thread.

Cependant, si on choisit correctement son langage de programmation (C++, Java), on aura de bonnes surprises: pas besoin de thread ou de processus parallèle!

J'ai obtenu une réaction de 140ms avec une GL5549 en Java pour une intensité de lumière presque 3 fois plus faible que celle que j'ai besoin pour enclencher ou déclencher mon luminaire.
Dans ces 140ms, il y a 8 mesures dont je calcule la moyenne de 4 valeurs avec les extrêmes ignorées. En Python, on est vite 50 fois plus lent en basse lumière.

S'il y a des personnes intéressées, je peux poster le code de ma classe Java ReadLight (200 lignes environ) qui contient une entrée main() de test que j'utilise pour la calibration de la valeur de déclenchement de mon application. Cette classe utilise le même mécanisme que ma solution Python. Elle est développée et testée sous Eclipse et Windows en utilisant les librairies du Pi4J. Je peux donner un peu plus d'explications (il suffit ou suffira de me poser des questions spécifiques).

A+

[f-leb]

Salut,

C'est une possibilité ou bien on peut aussi réduire la valeur du condensateur, ce qui produira le même effet. Une charge encore plus rapide.

J'y avais pensé.
Mais c'était le minimum que j'avais trouvé dans mon gros paquet de capacités, un kit de 120 capacités commandé pour mes bricolages Arduino/ESP/Raspberry Pi [

S'il t'en reste une deuxième identique, tu la mets en série avec la première : C_equivalent = C/2

Je pense que je vais pouvoir fermer cette discussion rapidement. Mes conclusions principales sont:

• Il ne faut pas prendre n'importe quelle photorésistance et il faut consulter les datasheets
  
  ...

Je n'ai pas regardé mais il faudrait dégager ses caractéristiques intéressantes. Et ne pas associer n'importe quel couple R,C non plus !

S'il y a des personnes intéressées, je peux poster le code de ma classe Java ReadLight (200 lignes environ) qui contient une entrée main() de test que j'utilise pour la calibration de la valeur de déclenchement de mon application. Cette classe utilise le même mécanisme que ma solution Python. Elle est développée et testée sous Eclipse et Windows en utilisant les librairies du Pi4J. Je peux donner un peu plus d'explications (il suffit ou suffira de me poser des questions spécifiques).

Intéressant ! Un article, un billet de blog... avec un lien que tu posterais ici, il y a matière

[boijea]

Salut,
S'il t'en reste une deuxième identique, tu la mets en série avec la première : C_equivalent = C/2
Je n'ai pas regardé mais il faudrait dégager ses caractéristiques intéressantes. Et ne pas associer n'importe quel couple R,C non plus !
Intéressant ! Un article, un billet de blog... avec un lien que tu posterais ici, il y a matière

Merci de tous ces retours.
Ce post a commencé il y a 6 jours, et c'est incroyable le temps que j'y ai passé ... et je continue.
Je vais donc faire une pause et reviendrai ici sur cette même discussion que je laisse ouverte.
Mon code Java ne marche pas suffisamment bien pour que je le dépose ici trop vite. Je n'ai pas envie de me faire massacrer pour mon domaine de connaissance principal.

Oui, il y a de la matière pour un article ou un billet, beaucoup.
J'ai aussi envie d'essayer avec Wiring Pi pour voir comment vient le retour d'intensité.
J'ai aussi une idée derrière la tête, pas trop derrière: de la même manière qu'un capteur Dallas de température, j'aimerais écrire un driver pour piquer l'intensité depuis un répertoire style /sys/bus/w1/devices/....
Oh que ce serait joli de programmer et décrire le modeprobe (j'ai déjà fait ce genre de choses).

Pour l'instant mon code Java, et aussi Python, ne me retourne pas des valeurs suffisamment stables. Je dois encore essayer avec un ChangeListener (Pi4J).
Il y a trop de variations (moins en Python), même si j'ignore les extrêmes. En codant un processus en C/C++ j'aurai peu être d'autres idées et revenir sur une photorésistance un peu moins grande que ma GL5549, mais supérieur à l'original.
C'est pareil pour la capacité.
Il faut vraiment que lors de mes mesures, et pour la valeur limite d'enclenchement ou déclenchement de ma lampe suite à une détection de mouvement, j'aie pour ce point de mesure, le meilleur circuit et des valeurs stables.

Donc, à la fin, il y aura peut-être qu'une seule conclusion: l'utilisation d'un convertisseur analogique/digital, avec un MCP3008 ou équivalent.
Si je mets aussi cette partie dans un article (où j'aurais besoin d'aide des électroniciens) ... ce pourrait être un gros sujet.
A+

[Auteur]

Bonjour,

un point m'intrigue dans ton projet : pourquoi utiliser Java ? Car cela t'oblige à utiliser la bibliothèque Pi4J pour accéder aux ports GPIO (sans doute en utilisant la JNI). Est-ce que tu utilises Java simplement pour réaliser une interface utilisateur ?

[boijea]

Oh, quelle bonne question!
Je réponds depuis la fin!

Non, je n'utilise pas d'interface graphique (Swing ou autres). Toutes mes applications sont pour des Raspberry Pi considérés comme des objets connectés accessibles avec un serveur Web.

La partie Web, c'est un classe Java d'environ 400 lignes de code avec plein d'outils.
La partie de simulation de présence utilise deux classes, une pour déterminer les lever et coucher du soleil, suivant la saison, mais aussi la latitude pas exemple, et une autre pour savoir dans quelle période de la journée je suis, vers les 450 lignes.

Java, c'est très facile, productif, objet orienté, ludique, un des langages les plus utilisés aujourd'hui, etc (comme pour son CV).
Tout est testé sous Windows, sous Eclipse (important aussi dans un CV), même le tri des mesures de lumière.
Toute la partie GPIO est simulée, comme des simulations aléatoires de mouvements.

Non, il n'y a pas de JNI. J'utilise ProcessBuilder et j'ai par exemple écrit une classe ProcessBuilderPython qui pourrait très bien exécuter un script Python facile à faire pour un cas spécifique utilisant le GPIO et me retournant la valeur.

La classe Java ConfigParam est conséquente et lira des paramètres dans un fichier de configuration config.txt, qui contiendra par exemple la broche GPIO utilisée par ma classe Relay ou encore "w1_slave=/sys/bus/w1/devices/28-021318cb3baa/w1_slave; Dallas temperature file", que ma classe Java DS18x20read pourra retirer la température accessible par une application ou visible par un utilisateur Web.

Donc un Java maker plus que convaincu!
Écrire tout cela en Python, tu vois la galère! J'ai fait du C++ pendant plus de 15 ans et Java est tellement facile et productif ... pour moi!
Rien n'est déposé sur mes Raspberry Pi avant d'être testé sur un PC Windows sous Eclipse. Ensuite je passe au Pi avec WinScp et Putty.
Et cela marche très très bien.

Le point cependant essentiel: tous mes circuits sur breadboards, modifiés ou nouveaux, sont testés en Python.
Parfois c'est compliqué. Comme le capteur à ultrasons où j'ai eu des difficultés en Python. Je l'ai alors mis et testé sur un Arduino, pour enfin comprendre tous les détails et régler les paramètres.

La librairie Pi4J marche bien!
Dès qu'on a besoin d'autres choses, comme d'une base de données ou d'envoyer des emails, tout est facile!
Merci pour ta question.
A+