🎮 Électronique

Redressement de tensions alternatifs

L'objectif est de redresser des tensions alternatifs en tensions continues. Notre étude se restreindra à l'application d'un pont redresseur de tensions en monophasé. Nous verrons deux types principaux de redresseurs : 

- le redresseur simple alternance

-le redresseur double alternance

Nous lisserons ensuite les tensions obtenues par un condensateur. 

Schéma du montage : redresseur simple alternance

(sans lissage)                                                                                                             (avec lissage via condensateur)

image-1674711803826.pngimage-1674712095064.png

 

Schéma du montage : redresseur double alternance

(sans filtrage)                                                                  (avec filtrage)

image-1674712716236.pngimage-1674712860535.png

 

 

 

 


 


 

robot qui saute à 30 m


https://www.nature.com/articles/s41586-022-04606-3.epdf?sharing_token=iwOWfzCrg84fVTvPnzS6k9RgN0jAjWel9jnR3ZoTv0NoCvlhBLYcl3v5dmxMf_KV4fMB6StwnBM7o-Iccw29Ng5B50g02eXLxhfTQhAiolhV_TBnJLGKC0YfSS8TRmKCfqfqRa5EgTBkFBoWUbTd-BUujlkDe9M0ai02nX1zdA8%3D

https://www.youtube.com/redirect?event=video_description&redir_token=QUFFLUhqazlRcy1pRTV6bFZBYm5KSm1LcWtlaWc2Um1ad3xBQ3Jtc0tsSkViN3diSnRMWkhBTElPMk1qZkN3dktlbFlVN0hQSGVxbDN6Mkd5QUI2RURPQURYYk01WU9rdVZMOGZpV2lZWm1iRldrRlJiLS00QUlXVUMzRzJuTkVnbkdlR1RzYS1ldmJrZVZjeHpwU2NIdzdpNA&q=https%3A%2F%2Frdcu.be%2FcMePc&v=daaDuC1kbds

J'ai déjà fait quelques courses... je négocie de l'aide de la part de ISIR, et sinon je ferais entièrement avec le fablab.

J'ai les élastiques!

Régulateur solaire MPTT

Schemas et PCB: https://github.com/mbouyer/canbus_solar_mppt

test de la carte de puissance

Pour les tests de la partie puissance sans la carte de contrôle j'ai utilisé les matériels suivants:

IMG_2404_1024.jpg

IMG_2407_1024.jpg

Il est ainsi possible de faire varier les différent paramètres (tension d'entrée, rapport de cycle, courant de sortie) et mesurer l'efficacité du convertisseur (c'est a dire le rapport puissance de sortie/puissance d'entrée).

Lors des premier tests plusieurs disfonctionnement sont apparus, qui ont fini par griller plusieurs composants, rendant la carte non-fonctionelle. Je pense que la cause principale est la sur-oscillation qui se produit au noeud SW, en particulier lorsque le mosfet haut devient passant, causant un pic transitoire de surtension (visible sur le grahe violet ci dessous) que j'ai sous-estimé.

IMG_2408_1024.jpg

Pour atténuer cette sur-oscillation, plusieurs modifications ont été apportées:

Les valeurs de ces composants seront à déterminer par mesure sur le circuit

D'autre part les drivers DGD0215 ont eu un comportement problématique (qui peut apparaitre à la mise sous tension), ou ils peuvent réinjecter leur tension d'alimentation sur leur entrée IN (qui qui a conduit à une surtention de l'alimentation 5V et la destruction du PAC1953). Pour tenter de limiter cela, j'ai ajouté un transistor MOS entre les DGD0215 et les commandes.

Lors du test de la seconde carte, il apparait que lors de la mise sous tension des DGD0215 les transistors Q3 à Q6 sont brièvement passants (voir restent bloqués dans l'état passant). Il semble donc que ces drivers ne soient pas adaptés à cette application. Je les ai donc supprimés et pilote les grilles des mosfet P directement avec les transistors BSS123. Du fait de la résistance de pullup (rédite à 10K) les comutations seront plus lentes, mais cela peut être géré en logiciel au niveau de la carte de contrôle.

simulateur de panneau solaire

La courbe tension/courant d'un paneau solaire est celle ci:

ps-tension-courant.jpg

Un panneau solaire se comporte comme un générateur de courant constant, avec une zone de transition pour les courants faibles due aux diodes en série. Plus de détails sur cette page: https://solarpost.in/basics/i-v-curve-solar-pv/

Pour le projet Régulateur solaire MPTT j'ai besoin d'une alimentation simulant un panneau solaire pour mettre au point l'agorithme MPTT. Une simple alimentation de laboratoire en courant constant a un comportement trop «carré» pour cela; de plus les alimentation à découpage présentent des impulsions lors de la limitation de courant qui, lorsque l'on travaille sous courant élevé, peuvent être destructeur. L'idée est donc de réaliser une source de courant constant qui réponde au besoin.

emulateur-panneau-solaire.svg

Le courant est limité par le transistor de puissance Q2, monté en darlington avec Q1. Le courant est mesuré aux bornes de la résistance R3. R1, D1 et RV1 fournissent une référence de tension ajustable. L'amplificateur operationel U1 compare la tension aux bornes de R3 avec la référence sur son entrée «+» et sa sortie pilote le transistor de puissance. Pour les courants faibles, Q2 devrait être passant mais le montage darlington impose une chute de tension minimale pour saturer Q2, donnant a l'ensemble un comportement plus linéaire.

Pour R3 nous n'avons pas en stock de résistance de puissance de si faible valeur. Mais nous avons une bobine de fil de cuivre pour lequel le fournisseur donne les caractéristiques; en particulier sa résistance: 183 ohms par Km. 1 mètre de ce cable donnera donc une résistance d'environ 183 mOhms (nous n'avont pas besoin d'une valeur très précise ici; RV1 nous permettra d'ajuster le courant).

Le montage est réalisé sur une breadboard; le transistor de puissance Q2 est monté sur un radiateur pour évacuer la chaleur.

IMG_2438-1024.JPG

Pour caractériser le montage nous utilisons une alimentation de laboratoire pouvant founir plusieurs ampères sous 25V, et une charge fictive Charge électronique TENMA 72-13210. Cette dernière sera utilisée en tension constante (ce qui veut dire qu'elle consome le courant nécessaire pour atteindre la tension de consigne), en faisant varier le réglage de la tension et en mesurant le courant nous obtenons la courbe I/V du montage.

Cet appareil peut être connecté à un ordinateur par USB, qui pourra alors le piloter et récupŕer les valeur mesurées. L'appareil est vu comme un pont USB/série sur le PC. il envoie ses commandes sous forme de chaine de caractère, et obtient les réponses sous forme de chaine de caractère également (se reporter aux documentations sur la page Charge électronique TENMA 72-13210). Nous allons donc utiliser un script (en perl) pour réaliser les mesures:

#!/usr/pkg/bin/perl use Device::SerialPort; use Time::HiRes qw( usleep ); my $line; my $port = Device::SerialPort->new($ARGV[0]) or die "failed to open serial port"; $port->databits(8); $port->baudrate(115200); $port->parity("none"); $port->stopbits(1); $port->write("*IDN?\n"); $line = getportln($port); print ("IDN: $line\n"); my $setvolt=24; $port->write(":FUNC CV\n"); setvolt($port, $setvolt); $port->write(":INP ON\n"); while ($setvolt >= 10) { setvolt($port, $setvolt); $setvolt = $setvolt - 0.1; } $port->write(":INP OFF\n"); exit(0); sub setvolt { my ($p, $v) = @_; $p->write(":VOLT " . $v . "V\n"); $p->write(":VOLT?\n"); my $l = getportln($p); print("set $l"); usleep(500000); $p->write(":MEAS:CURR?\n"); $l = getportln($p); print(" $l "); $p->write(":MEAS:VOLT?\n"); $l = getportln($p); print(" $l\n"); } sub getportln { my ($p) = @_; my $l = ""; while(1) { my $byte = $port->read(1); if ($byte eq "\n") { $p->lookclear; return $l; } $l = $l . $byte; } }

La commande *IDN? permet de vérifier la communication avec l'appareil. Ensuite nous réglons la consigne à 24V puis activons la charge fictive. ensuite, pour chaque valeur de 24V à 10V (par pas de 0,1V) la consigne est envoyée à l'appareil, et après une attente de 500ms les valeurs mesurées de tension et intensité sont récupérées (cela se passe dans la routine setvolt). Enfin l'appareil est désactivé avant la fin du programme.

L'exécution donne: IDN: TENMA 72-13210 V2.10 S50011730 set 24.000V 0.0000A 24.407V set 24.000V 0.0000A 23.998V set 23.900V 0.0000A 23.896V set 23.800V 0.0000A 23.796V set 23.700V 0.0047A 23.698V set 23.600V 0.0160A 23.598V set 23.500V 0.0382A 23.496V set 23.400V 0.0699A 23.397V set 23.300V 0.1103A 23.296V set 23.200V 0.1546A 23.198V set 23.100V 0.2049A 23.096V set 23.000V 0.2572A 22.996V set 22.900V 0.3104A 22.895V set 22.800V 0.3645A 22.796V set 22.700V 0.4185A 22.698V set 22.600V 0.4733A 22.598V set 22.500V 0.5278A 22.499V set 22.400V 0.5821A 22.398V set 22.300V 0.6363A 22.299V set 22.200V 0.6915A 22.197V set 22.100V 0.7435A 22.099V set 22.000V 0.7974A 21.998V set 21.900V 0.8490A 21.900V set 21.800V 0.9019A 21.797V set 21.700V 0.9536A 21.697V set 21.600V 1.0035A 21.599V set 21.500V 1.0540A 21.499V set 21.400V 1.1048A 21.397V set 21.300V 1.1538A 21.297V set 21.200V 1.2032A 21.196V set 21.100V 1.2502A 21.099V set 21.000V 1.2986A 20.998V set 20.900V 1.3457A 20.898V set 20.800V 1.3929A 20.797V set 20.700V 1.4395A 20.698V set 20.600V 1.4864A 20.596V set 20.500V 1.5310A 20.498V set 20.399V 1.5769A 20.397V set 20.299V 1.6215A 20.298V set 20.199V 1.6672A 20.195V set 20.099V 1.7112A 20.095V set 19.999V 1.7546A 19.996V set 19.899V 1.7979A 19.896V set 19.799V 1.8412A 19.797V set 19.699V 1.8841A 19.696V set 19.599V 1.9263A 19.596V set 19.499V 1.9680A 19.498V set 19.399V 2.0100A 19.397V set 19.299V 2.0521A 19.297V set 19.199V 2.0936A 19.196V set 19.099V 2.1345A 19.096V set 18.999V 2.1762A 18.996V set 18.899V 2.2157A 18.897V set 18.799V 2.2565A 18.796V set 18.699V 2.2964A 18.698V set 18.599V 2.3367A 18.595V set 18.499V 2.3766A 18.495V set 18.399V 2.4148A 18.396V set 18.299V 2.4543A 18.296V set 18.199V 2.4935A 18.197V set 18.099V 2.5313A 18.097V set 17.999V 2.5704A 17.996V set 17.899V 2.6074A 17.899V set 17.799V 2.6465A 17.796V set 17.699V 2.6846A 17.696V set 17.599V 2.7219A 17.595V set 17.499V 2.7594A 17.496V set 17.399V 2.7967A 17.394V set 17.299V 2.8319A 17.297V set 17.199V 2.8357A 17.196V set 17.099V 2.8391A 17.097V set 16.999V 2.8410A 16.994V set 16.899V 2.8443A 16.895V set 16.799V 2.8479A 16.795V set 16.699V 2.8502A 16.696V set 16.599V 2.8547A 16.597V set 16.499V 2.8580A 16.496V set 16.399V 2.8623A 16.397V set 16.299V 2.8651A 16.302V set 16.199V 2.8688A 16.201V set 16.099V 2.8732A 16.099V set 15.999V 2.8777A 16.001V set 15.899V 2.8828A 15.899V set 15.799V 2.8869A 15.802V set 15.699V 2.8913A 15.700V set 15.599V 2.8966A 15.600V set 15.499V 2.9011A 15.500V set 15.399V 2.9062A 15.399V set 15.299V 2.9112A 15.298V set 15.199V 2.9154A 15.201V set 15.099V 2.9199A 15.099V set 14.999V 2.9236A 15.000V set 14.899V 2.9277A 14.899V set 14.799V 2.9312A 14.799V set 14.699V 2.9345A 14.701V set 14.599V 2.9385A 14.600V set 14.499V 2.9426A 14.498V set 14.399V 2.9466A 14.398V set 14.299V 2.9499A 14.298V set 14.199V 2.9532A 14.200V set 14.099V 2.9572A 14.099V set 13.999V 2.9606A 13.999V set 13.899V 2.9642A 13.899V set 13.799V 2.9661A 13.798V set 13.699V 2.9683A 13.698V set 13.599V 2.9723A 13.599V set 13.499V 2.9769A 13.499V set 13.399V 2.9820A 13.400V set 13.299V 2.9866A 13.299V set 13.199V 2.9903A 13.199V set 13.099V 2.9940A 13.101V set 12.999V 2.9972A 13.000V set 12.899V 3.0006A 12.899V set 12.799V 3.0025A 12.798V set 12.699V 3.0055A 12.698V set 12.599V 3.0090A 12.600V set 12.499V 3.0120A 12.498V set 12.399V 3.0176A 12.398V set 12.299V 3.0203A 12.299V set 12.199V 3.0236A 12.198V set 12.099V 3.0270A 12.098V set 11.999V 3.0301A 11.999V set 11.899V 3.0339A 11.899V set 11.799V 3.0392A 11.800V set 11.699V 3.0455A 11.697V set 11.599V 3.0495A 11.598V set 11.499V 3.0538A 11.500V set 11.399V 3.0584A 11.399V set 11.299V 3.0622A 11.298V set 11.199V 3.0652A 11.198V set 11.099V 3.0684A 11.097V set 10.999V 3.0710A 11.000V set 10.899V 3.0740A 10.897V set 10.799V 3.0765A 10.797V set 10.699V 3.0783A 10.698V set 10.599V 3.0806A 10.598V set 10.499V 3.0826A 10.499V set 10.399V 3.0850A 10.399V set 10.299V 3.0871A 10.300V set 10.199V 3.0892A 10.200V set 10.099V 3.0918A 10.100V

Ce fichier pemet de tracer la courbe V/I, par exemple avec gnuplot:

emulsp-2n3716+SS9014.svg

L'ensemble des fichiers sont disponibles dans emulsp.zip

Projet Ventilateur Grow Box

Dans ce projet on cherche a répondre a un problème qui est la surchauffe de panneau LED dans un Grow Box à l'espace Greenlab. Pour y remédier, le but est de créer un programme sur un Arduino UNO qui va permettre d'activer un ventilateur lorsque la température est trop élevé. Pour l'instant j'ai un schéma de montage avec une carte Arduino UNO branché à un capteur de température qui, en fonction de la température, vas ouvrir ou fermer un relai ce qui aura pour effet d'ouvrir ou de fermer le circuit du ventilateur. Le code que j'ai utilisé est le suivant :

#include <Adafruit_Sensor.h>
#include <DHT.h>
#define DHTpin 2             // pin2 devient le pin du DHT11
#define Relai 3                // pin3 devient le pin du relai
#define DHTTYPE DHT22          // on règle le modèle de capteur
DHT dht(DHTpin, DHTTYPE);


void setup() {
  pinMode(DHTpin, INPUT);       // règle le pin 2 en input
  pinMode(Relai, OUTPUT);      // règle le pin 3 en output
  Serial.begin(9600);          // initialise la comm.
  dht.begin();                 // allume le capteur
}




void loop() {


  delay(2000);                       //attend un peu entre chaque mesures
  float t = dht.readTemperature();   // lit la température exterieur et l'associe à la variable t=température


  if ( t >= 25 ) {                    // si la temérature est au dessus de 35°C
    digitalWrite(Relai, HIGH);      // le relai se ferme => le ventilateur s'allume
    Serial.println("closed");
  }
  else {                            // la température est a 35°C ou moins
    digitalWrite(Relai, LOW);       // le relai s'ouvre => le ventilateur s'arrête
    Serial.println("open");
  }
  if (isnan(t)) {
    Serial.println("x(");           // verifie le bon fonctionnement du capteur
  }
  Serial.println(t);
}


Maintenant, il ne reste plus qu'a rajouter des fonctionnalités tels qu'un écran LCD avec possibilité de régler la température de déclenchement, mais aussi des moyens de régler l'hygrométrie !!

J'ai ajouté ci-joint les librairies utilisé dans ce code.

Paul SPIRCKEL : J'ai ajouté un LCD (https://learn.adafruit.com/character-lcds/wiring-a-character-lcd). A chaque déclenchement du relais, il est parasité par de nombreux de caractères mais le circuit fonctionne toujours en arrière-plan.

A noter qu'il faudrait ajouter un petit delta de température de façon à ce que le ventilateur ne s'active/désactive pas sans arrêt autour de 25°C (typiquement ventiler jusqu'à 22°C avant de se désactiver).

Voici le code mis à jour : 

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2             // pin2 devient le pin du DHT11

#define Relai 3                // pin3 devient le pin du relai

#define DHTTYPE DHT22          // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

void setup() {

  pinMode(DHTpin, INPUT);       // règle le pin 2 en input

  pinMode(Relai, OUTPUT);      // règle le pin 3 en output

  Serial.begin(9600);          // initialise la comm.

  dht.begin();                 // allume le capteur

  lcd.begin(16, 2);

  lcd.setCursor(1, 0);

  lcd.write("Temperature =");

  lcd.setCursor(6, 1);

   lcd.write(" C");

  
}





void loop() {



  delay(2000);                       //attend un peu entre chaque mesures

  float t = dht.readTemperature();   // lit la température exterieur et l'associe à la variable t=température

  lcd.setCursor(0, 1);

  lcd.print(dht.readTemperature());
 


  if ( t <= 25 ) {                    // si la temérature est au dessus de 35°C

    digitalWrite(Relai, HIGH);      // le relai se ferme => le ventilateur s'allume

    Serial.println("closed");

  }

  else {                            // la température est a 35°C ou moins

    digitalWrite(Relai, LOW);       // le relai s'ouvre => le ventilateur s'arrête

    Serial.println("open");

  }

  if (isnan(t)) {

    Serial.println("x(");           // verifie le bon fonctionnement du capteur

  }

  Serial.println(t);

  

  }

Paul SPIRCKEL : J'ai finalisé le code pour 1 ventilateur, avec un delta de température de 3°C et un potentiomètre permettant de choisir le seuil de température à ne pas dépasser. Le LCD ne fonctionne toujours pas correctement. Il peut s'agir d'un problème matériel donc je n'ai rien changé tant que le circuit ne sera pas posé sur une platine. Aussi, il faut faire attention à ne pas allumer le circuit avec le potentiomètre réglé pour une température en dessous de la température ambiante sinon le ventilateur ne s'arrêtera jamais de tourner. Si c'est le cas, il faut juste éteindre le circuit, remonté le potentiomètre et tout rallumer.

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2             // pin2 devient le pin du DHT11

#define Relai 3                // pin3 devient le pin du relai

#define DHTTYPE DHT22          // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int poten = 0;                  // poten est la variable modifiée par le potentiomètre

void setup() {

  pinMode(DHTpin, INPUT);       // règle le pin 2 en input

  pinMode(Relai, OUTPUT);      // règle le pin 3 en output

  pinMode(adcPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

  Serial.begin(9600);          // initialise la comm.

  dht.begin();                 // allume le capteur
  
  lcd.begin(16, 2);

  lcd.setCursor(0, 0);

  lcd.println("Temp =");

  lcd.setCursor(0, 1);

  lcd.println("Set  = ");

  
}

void loop() {

  delay(2000);                       //attend un peu entre chaque mesures

  poten = (analogRead(adcPin)/10);   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C

  Serial.println(3+poten);           // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

  lcd.setCursor(6, 1);

  lcd.println(3+poten);

  if ( dht.readTemperature() >= (3+poten) ) {                    // si la température est au dessus de (3+poten)

    while (dht.readTemperature() >= (poten)) {                   // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

    delay(2000);
  
    digitalWrite(Relai, LOW);      // le relai se ferme => le ventilateur s'allume

    Serial.println(dht.readTemperature());
    
    Serial.println("closed");

    lcd.setCursor(7, 0);

    lcd.write(dht.readTemperature());

    }

  }

  else {                            // la température est a 35°C ou moins

    digitalWrite(Relai, HIGH);       // le relai s'ouvre => le ventilateur s'arrête

    Serial.println(dht.readTemperature());

    Serial.println("open");

    lcd.setCursor(7, 0);

    lcd.write(dht.readTemperature());

  }

}

Avec 2 relais

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2             // pin2 devient le pin du DHT11

#define Relai_1 3                // pin3 devient le pin du relai 1

#define Relai_2 4               // pin4 devient le pin du relai 2

#define DHTTYPE DHT22          // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int poten = 0;                  // poten est la variable modifiée par le potentiomètre

void setup() {

  pinMode(DHTpin, INPUT);       // règle le pin 2 en input

  pinMode(Relai_1, OUTPUT);      // règle le pin 3 en output

  pinMode(Relai_2, OUTPUT);      // règle le pin 4 en output

  pinMode(adcPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

  Serial.begin(9600);          // initialise la comm.

  dht.begin();                 // allume le capteur
  
  lcd.begin(16, 2);

  lcd.setCursor(0, 0);

  lcd.println("Temp =");

  lcd.setCursor(0, 1);

  lcd.println("Set  = ");

  
}

void loop() {

  delay(2000);                       //attend un peu entre chaque mesures

  poten = (analogRead(adcPin)/10);   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C

  Serial.println(3+poten);           // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

  lcd.setCursor(6, 1);

  lcd.println(3+poten);

  if ( dht.readTemperature() >= (3+poten) ) {                    // si la température est au dessus de (3+poten)

    while (dht.readTemperature() >= (poten)) {                   // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

    delay(2000);
  
    digitalWrite(Relai_1, LOW);      // le relai se ferme => le ventilateur s'allume

    Serial.println(dht.readTemperature());
    
    Serial.println("closed 1");

    lcd.setCursor(7, 0);

    lcd.write(dht.readTemperature());

       while (dht.readTemperature() >= (poten+2)) {                   // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

       delay(2000);
   
       digitalWrite(Relai_2, LOW);      // le relai se ferme => le ventilateur s'allume

       Serial.println(dht.readTemperature());
    
       Serial.println("closed 2");

       }

    }

  }

  else {                            // la température est a 35°C ou moins

    digitalWrite(Relai_1, HIGH);       // le relai s'ouvre => le ventilateur s'arrête

    Serial.println(dht.readTemperature());

    Serial.println("open");

    lcd.setCursor(7, 0);

    lcd.write(dht.readTemperature());

  }

}

Miro Von der Borch : J'ai aujourd'hui tenté de résoudre certains problèmes de la version précédente du code et du montage :

-Des bugs d'affichage sur l'écran LDC

-La communication serial qui ne renvoie rien

-La valeur des potentiomètres qui se fige si elle est en dessous de la température

Une première modification que j'ai apporté a été de brancher le file de contraste directement à la masse pour se débarrasser d'un des potentiomètres inutile. Ensuite, j'ai modifier le code à deux relais en ajoutant des espaces à la fin de chaque print du LCD ce qui a corrigé l'un des bugs d'affichage, mais pas le second qui fait que la première valeur de température du capteur DHT est un caractère étrange. J'ai aussi ajouté des actualisation au sein de chaque "while" de la valeur "poten" :

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2             // pin2 devient le pin du DHT11

#define Relai_1 3                // pin3 devient le pin du relai 1

#define Relai_2 4               // pin4 devient le pin du relai 2

#define DHTTYPE DHT22          // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int adcPinfine = A1;            // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin
int poten = 0;                  // poten est la variable modifiée par les potentiomètres

void setup() {

  pinMode(DHTpin, INPUT);       // règle le pin 2 en input

  pinMode(Relai_1, OUTPUT);      // règle le pin 3 en output

  pinMode(Relai_2, OUTPUT);      // règle le pin 4 en output

  pinMode(adcPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

  Serial.begin(9600);          // initialise la comm.

  dht.begin();                 // allume le capteur
  
  lcd.begin(16, 2);

  lcd.setCursor(0, 0);

  lcd.println("Temp =          ");

  lcd.setCursor(0, 1);

  lcd.println("Set  =          ");

  
}

void loop() {

  delay(2000);                       //attend un peu entre chaque mesures

  poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

  Serial.println(3+poten);           // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

  lcd.setCursor(7, 0);

  lcd.println(dht.readTemperature());

  lcd.setCursor (12, 0);

  lcd.println(" C  ");

  lcd.setCursor (7, 1);

  lcd.println(3+poten);

  lcd.setCursor (9, 1);

  lcd.println (" C     ");

  if ( dht.readTemperature() >= (3+poten) ) {                    // si la température est au dessus de (3+poten)

    while (dht.readTemperature() >= (poten)) {                   // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

    delay(2000);
  
    digitalWrite(Relai_1, LOW);      // le relai se ferme => le ventilateur s'allume

    Serial.println(dht.readTemperature());
    
    Serial.println("closed 1");

    lcd.setCursor(7, 0);

    lcd.println(dht.readTemperature());

    lcd.setCursor (12, 0);

    lcd.println(" C  ");  // après chaque print de l'écran LCD j'ai rajouter une instruction pour afficher d'une part l'unité mais aussi pour se débarrasser les symboles étranges qui apparraissaient à la fin des print

    poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));  // Ici j'ai ajouté une actualisation de la valeure poten afin d'éviter que la valeur ne se fige

    lcd.setCursor (7, 1);

    lcd.println(3+poten);

    lcd.setCursor (9, 1);

    lcd.println (" C     ");

       while (dht.readTemperature() >= (poten+2)) {                   // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

       delay(2000);
   
       digitalWrite(Relai_2, LOW);      // le relai se ferme => le ventilateur s'allume

       Serial.println(dht.readTemperature());
    
       Serial.println("closed 2");
       
        lcd.setCursor(7, 0);

        lcd.println(dht.readTemperature());

        lcd.setCursor (12, 0);

        lcd.println(" C  ");

        poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));

        lcd.setCursor (7, 1);

        lcd.println(3+poten);

        lcd.setCursor (9, 1);

        lcd.println (" C     ");

       }

    }

  }

  else {                            // la température est a 35°C ou moins

    digitalWrite(Relai_1, HIGH);       // le relai s'ouvre => le ventilateur s'arrête

    Serial.println(dht.readTemperature());

    Serial.println("open");

    lcd.setCursor(7, 0);

    lcd.write(dht.readTemperature());

  }

}

Je n'ai cependant pas réussi à faire fonctionner la communication sérial.

Pour le bug d'affichage de la valeur de température du DHT, il n'est pas toujours présent, notamment, l'affichage se fait correctement si les relais sont éteint (le circuit est fermé). Je suspect donc que le problème viens du fait que les relais sont sur la même alimentation que l'écran. Piste à creuser...

Paul SPIRCKEL :

J'ai continué à améliorer le code. J'ai notamment essayé de modifier les boucles while car lorsque la condition n'est plus valide, les signaux déclarés en LOW ne repassent pas en HIGH. Pour ce faire il faut écrire quelque part "digitalWrite(Relai_..., HIGH)". Ainsi plutôt que d'imbriquer 2 boucles while, j'ai essayé de faire démarrer les deux ventilateurs tant que la température n'était pas redescendue en dessous de (2+poten) et une fois sorti de la boucle, que le relai 2 s'ouvre mais que le premier reste bien fermé jusqu'à ce que le if ne soit plus vrai. Un deuxième problème s'est alors posé, la sortie d'une boucle while comprise dans un if renvoie immédiatement au else. Même en essayant de mettre un deuxième while dans le if (pour T < (2+poten), les deux ventilateurs s'éteignent immédiatement.

Ce code n'est clairement pas abouti

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2             // pin2 devient le pin du DHT11

#define Relai_1 4                // pin3 devient le pin du relai 1

#define Relai_2 5               // pin4 devient le pin du relai 2

#define DHTTYPE DHT22          // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int adcPinfine = A1;            // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin
int poten = 0;                  // poten est la variable modifiée par les potentiomètres

void setup() {

  pinMode(DHTpin, INPUT);       // règle le pin 2 en input

  pinMode(Relai_1, OUTPUT);      // règle le pin 3 en output

  pinMode(Relai_2, OUTPUT);      // règle le pin 4 en output

  pinMode(adcPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

  Serial.begin(9600);          // initialise la comm.

  dht.begin();                 // allume le capteur
  
  lcd.begin(16, 2);

  lcd.setCursor(0, 0);

  lcd.println("Temp =          ");

  lcd.setCursor(0, 1);

  lcd.println("Set  =          ");

  
}

void loop() {

  delay(2000);                       //attend un peu entre chaque mesures

  poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

  Serial.println(3+poten);           // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

  lcd.setCursor(7, 0);

  lcd.println(dht.readTemperature());

  lcd.setCursor (12, 0);

  lcd.println(" C  ");

  lcd.setCursor (7, 1);

  lcd.println(3+poten);

  lcd.setCursor (9, 1);

  lcd.println (" C     ");

  if ( dht.readTemperature() >= (3+poten) ) {                    // si la température est au dessus de (3+poten)

       delay(2000);   

       Serial.println(dht.readTemperature());
    
       Serial.println("closed 1");
       
        lcd.setCursor(7, 0);

        lcd.println(dht.readTemperature());

        lcd.setCursor (12, 0);

        lcd.println(" C  ");

        poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));

        lcd.setCursor (7, 1);

        lcd.println(3+poten);

        lcd.setCursor (9, 1);

        lcd.println (" C     ");

        do {
        
            delay(2000);
          
            digitalWrite(Relai_1, LOW);
            digitalWrite(Relai_2, LOW);
                    
            Serial.println(dht.readTemperature());
            
            Serial.println("closed 1 & 2");
        
            lcd.setCursor(7, 0);
        
            lcd.println(dht.readTemperature());
        
            lcd.setCursor (12, 0);
        
            lcd.println(" C  ");  // après chaque print de l'écran LCD j'ai rajouter une instruction pour afficher d'une part l'unité mais aussi pour se débarrasser des symboles étranges qui apparraissaient à la fin des print
        
            poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));  // Ici j'ai ajouté une actualisation de la valeure poten afin d'éviter que la valeur ne se fige
        
            lcd.setCursor (7, 1);
        
            lcd.println(3+poten);
        
            lcd.setCursor (9, 1);
        
            lcd.println (" C     ");

      }
            while (dht.readTemperature() >= (2+poten));  // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

      do {
        
          delay(2000);
          
            digitalWrite(Relai_2, HIGH);
                    
            Serial.println(dht.readTemperature());
            
            Serial.println("closed 1 & open 2");
        
            lcd.setCursor(7, 0);
        
            lcd.println(dht.readTemperature());
        
            lcd.setCursor (12, 0);
        
            lcd.println(" C  ");  // après chaque print de l'écran LCD j'ai rajouter une instruction pour afficher d'une part l'unité mais aussi pour se débarrasser des symboles étranges qui apparraissaient à la fin des print
        
            poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));  // Ici j'ai ajouté une actualisation de la valeure poten afin d'éviter que la valeur ne se fige
        
            lcd.setCursor (7, 1);
        
            lcd.println(3+poten);
        
            lcd.setCursor (9, 1);
        
            lcd.println (" C     ");
        
      }

      while (dht.readTemperature() < (2+poten));  // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

  }

  else {                            // la température est à (3+poten) ou moins

    digitalWrite(Relai_1, HIGH);       // le relai 1 s'ouvre => le ventilateur 1 s'arrête
    digitalWrite(Relai_2, HIGH);       // le relai 2 s'ouvre => le ventilateur 2 s'arrête

    Serial.println(dht.readTemperature());

    Serial.println("open");

    lcd.setCursor(7, 0);

    lcd.write(dht.readTemperature());

  }

}

Miro VON DER BORCH (24/11/2023) :

J'ai reproduit le circuit à l'identique dans l'espace prototypage pour pouvoir continuer à avancer dessus. Je l'ai mis dans un des grands bacs en plastique en bas de l'étagère des projets. J'ai ainsi apporté les modifications suivantes au circuit :

J'ai aussi fait un premier aperçut du circuit imprimé que l'on pourrais faire pour ce montage avec toute les modifications que j'ai mentionné plus haut incluse dedans :

Capture d'écran 2023-11-24 201305.png

Le schéma du circuit sur KiCad

Capture d'écran 2023-11-24 195806.png

La PCB

J'ai joins le fichier de la PCB

Pour ce qui est du code :

Lors de mes essais pour régler le problème d'affichage qui survenait lorsque les relais s'allumait (Le premier chiffre de la valeur de température lut par le capteur était remplacé par un caractère étrange), je pensai d'abords qu'ils en étaient la cause, mais après quelques essais, les boucles "while", pour une raison que j'ignore, semblent être en cause, en effet le problème survient même si les relais sont déconnectés. Cependant peut-être qu'avec la nouvelle version du code il n'est plus présent.

Miro VON DER BORCH (25/11/23) :

J'ai revus un peu la PCB ce matin afin d'ajouter deux potentiomètres en plus sur le circuit actuel, ces potentiomètres devrais servir à controler l'humidité souhaité à terme. Je les ai donc branché au pins analogue suivant :

A2 -> Potentiomètre d'humidité

A3 -> Potentiomètre d'humidité fin

Voici les captures d'écran de ce que ça donne et j'ai joins le fichier KiCad :

Capture d'écran 2023-11-25 130909.png

Le schéma mis à jour

Capture d'écran 2023-11-25 130922.png

La PCB mis à jour

Paul SPIRCKEL (29/11/2023) :

Après avoir consulté les modifications faites par Miro, je me suis lancé dans l'écriture du programme. Je n'avais pas accès au nouveau circuit donc j'ai programmé à l'aveugle. Afin d'être sûr que toutes les conditions sont lues, j'ai préféré décrire 4 if (trop chaud, trop froid, trop humide, top sec)  avec des deltas (centrés sur la valeur voulue) adaptés à chaque situation (on préférera trop froid plutôt que trop chaud et trop humide plutôt que trop sec). Je propose également d'ajouter au circuit un switch à 3 pins pour choisir entre le refroidissement par ventilation ou par cooler. Je propose les deux codes ci-dessous :

Ventilation et cooler séparés
#include <Adafruit_Sensor.h>

#include <DHT.h>
#include <LiquidCrystal.h>
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_SHT31.h"
//#include <Adafruit_I2CDevice.h>

#define SHTpin 

#define Relai_1 3              // pin3 devient le pin du relai 1 (Ventilateur 1)
#define Relai_2 4              // pin4 devient le pin du relai 2 (Ventilateur 2)
#define Relai_3 5              // pin5 devient le pin du relai 3 (Résistance de chauffe)
#define Relai_4 6              // pin6 devient le pin du relai 4 (Cooler)
#define Relai_5 13             // pin13 devient le pin du relai 5 (Système d'humidification)

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcTempPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre de température
int adcTempPinfine = A1;            // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin de température
int Temp_poten = 0;                  // Temp_poten est la variable modifiée par les potentiomètres liés à la température
int adcHumPin = A2;                // attribution du pin analogique A2 comme entrée du signal du potentiomètre d'humidité
int adcHumPinfine = A3;            // attribution du pin analogique A3 comme entrée su signal du potentiomètre de réglage fin d'humidité
int Hum_poten = 0;                  // Hum_poten est la variable modifiée par les potentiomètres liés à l'humidité




void setup() {

pinMode(Relai_1, OUTPUT);      // règle le pin 3 en output
pinMode(Relai_2, OUTPUT);      // règle le pin 4 en output
pinMode(Relai_3, OUTPUT);      // règle le pin 5 en output
pinMode(Relai_4, OUTPUT);      // règle le pin 6 en output
pinMode(Relai_5, OUTPUT);      // règle le pin 13 en output

pinMode(adcTempPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre Temp
pinMode(adcTempPinfine, INPUT);      // règle le pin A1 (analogique) comme entrée du signal du potentiomètre Tempfine
pinMode(adcHumPin, INPUT);      // règle le pin A2 (analogique) comme entrée du signal du potentiomètre Hum
pinMode(adcHumPinfine, INPUT);      // règle le pin A3 (analogique) comme entrée du signal du potentiomètre Humfine

Serial.begin(9600);          // initialise la comm.

//Section consacrée à l'affichage vouée à évoluer en fonction du système d'affichage choisi

 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp =          ");

 lcd.setCursor(0, 1);

 lcd.println("Set  =          ");

}




void loop() {

delay(2000);                       //attend un peu entre chaque mesures

Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision
Hum_poten = ((7+analogRead(adcHumPin)/40)+(analogRead(adcHumPinfine)/125));      // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

serial.print(Temp_poten);

//  ---- CONTROLE DE LA TEMPERATURE ----

//  Température trop élevée (max 1°C ou dessus de la température souhaitée)

if (sht31.readTemperature() > (1+Temp_poten) ){ // Si la température est supérieure à 1°C au dessus de la température souhaitée

    while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop élevée");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
       digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

    }

}

else {

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Conditions atteintes");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 en arrêt)
       digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 en arrêt)

}


//  La température est trop faible (Maximum 3°C en dessous de la température souhaitée, ne pas monter plus haut que la température souhaitée)

if (sht31.readTemperature() < (Temp_poten-3) ){ // Si la température est inférieure à 3°C en dessous de la température souhaitée

    while (sht31.readTemperature() < (Temp_poten) { // Le système de chauffage se met en marche tant que la température n'est pas remontée à Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop faible");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_3, LOW); // Le Relai_3 se ferme (Chauffage en fonctionnement)

    }
}

else {

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Conditions atteintes");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_3, HIGH); // Le Relai_3 s'ouvre (Chauffage en arrêt) 
}

//  Température trop élevée MALGRE LA VENTILATION (plutôt un cas d'été) (max 5°C ou dessus de la température souhaitée)

if (sht31.readTemperature() > (5+Temp_poten) ){ // Si la température est supérieure à 5°C au dessus de la température souhaitée

    while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop élevée");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_4, LOW); // Le Relai_4 se ferme (Cooler en fonctionnement)

    }

}

else {

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Conditions atteintes");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_4, HIGH); // Le Relai_4 s'ouvre (Cooler en arrêt)

}

//    ---- CONTROLE DE L'HUMIDITE ----

// Humidité trop élevée

if (sht31.readHumidity() > (Hum_poten+10) ){ // Si l'humidité est 10% au dessus de celle souhaitée

    while (sht31.readHumidity() > (Hum_poten) { // Le système de ventilation se met en marche tant que l'humidité n'est pas redescuendue jusqu'à Hum_poten

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Humidité trop élevée");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
       digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

    }
}

else {

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Conditions atteintes");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 en arrêt)
       digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 en arrêt)

}

// Humidité trop faible

if (sht31.readHumidity() < (Hum_poten-5) ){ // Si l'humidité est 5% en dessous de celle souhaitée

    while (sht31.readHumidity() <= (Hum_poten) { // Le système d'humidification se met en marche tant que l'humidité n'est pas remontée à Hum_poten

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Humidité trop faible");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_5, LOW); // Le Relai_5 se ferme (Système d'humidification en fonctionnement)

    }
}

else {

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Conditions atteintes");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_5, HIGH); // Le Relai_5 s'ouvre (Système d'humidification à l'arrêt)

}

}

 

Ventilation ou cooler
#include <Adafruit_Sensor.h>

#include <DHT.h>
#include <LiquidCrystal.h>
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_SHT31.h"
//#include <Adafruit_I2CDevice.h>

#define SHTpin 

#define cooling 6              // pin6 devient le pin du qui commande soit la paire de ventilateurs soit le cooler en fonction de la position de l'interrupteur
#define Relai_1 3              // pin3 devient le pin du relai 1 (Ventilateur 1)
#define Relai_2 4              // pin4 devient le pin du relai 2 (Ventilateur 2)
#define Relai_3 5              // pin5 devient le pin du relai 3 (Résistance de chauffe)
#define Relai_5 13             // pin13 devient le pin du relai 5 (Système d'humidification)

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcTempPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre de température
int adcTempPinfine = A1;            // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin de température
int Temp_poten = 0;                  // Temp_poten est la variable modifiée par les potentiomètres liés à la température
int adcHumPin = A2;                // attribution du pin analogique A2 comme entrée du signal du potentiomètre d'humidité
int adcHumPinfine = A3;            // attribution du pin analogique A3 comme entrée su signal du potentiomètre de réglage fin d'humidité
int Hum_poten = 0;                  // Hum_poten est la variable modifiée par les potentiomètres liés à l'humidité




void setup() {

pinMode(cooling, OUTPUT);      // règle le pin 6 en output
pinMode(Relai_1, OUTPUT);      // règle le pin 3 en output
pinMode(Relai_2, OUTPUT);      // règle le pin 4 en output
pinMode(Relai_3, OUTPUT);      // règle le pin 5 en output
pinMode(Relai_5, OUTPUT);      // règle le pin 13 en output

pinMode(adcTempPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre Temp
pinMode(adcTempPinfine, INPUT);      // règle le pin A1 (analogique) comme entrée du signal du potentiomètre Tempfine
pinMode(adcHumPin, INPUT);      // règle le pin A2 (analogique) comme entrée du signal du potentiomètre Hum
pinMode(adcHumPinfine, INPUT);      // règle le pin A3 (analogique) comme entrée du signal du potentiomètre Humfine

Serial.begin(9600);          // initialise la comm.

//Section consacrée à l'affichage vouée à évoluer en fonction du système d'affichage choisi

 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp =          ");

 lcd.setCursor(0, 1);

 lcd.println("Set  =          ");

}




void loop() {

delay(2000);                       //attend un peu entre chaque mesures

Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision
Hum_poten = ((7+analogRead(adcHumPin)/40)+(analogRead(adcHumPinfine)/125));      // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

serial.print(Temp_poten);

//  ---- CONTROLE DE LA TEMPERATURE ----

//  Température trop élevée (max 1°C ou dessus de la température souhaitée)

if (sht31.readTemperature() > (1+Temp_poten) ){ // Si la température est supérieure à 1°C au dessus de la température souhaitée

    while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop élevée");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(cooling, LOW); // Le système de refroidissement sélectionné se met en marche

    }

}

else {

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Conditions atteintes");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(cooling, HIGH); // Le système de refroidissement sélectionné s'arrête

}


//  La température est trop faible (Maximum 3°C en dessous de la température souhaitée, ne pas monter plus haut que la température souhaitée)

if (sht31.readTemperature() < (Temp_poten-3) ){ // Si la température est inférieure à 3°C en dessous de la température souhaitée

    while (sht31.readTemperature() < (Temp_poten) { // Le système de chauffage se met en marche tant que la température n'est pas remontée à Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop faible");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_3, LOW); // Le Relai_3 se ferme (Chauffage en fonctionnement)

    }
}

else {

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Conditions atteintes");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_3, HIGH); // Le Relai_3 s'ouvre (Chauffage en arrêt) 
}

//    ---- CONTROLE DE L'HUMIDITE ----

// Humidité trop élevée

if (sht31.readHumidity() > (Hum_poten+10) ){ // Si l'humidité est 10% au dessus de celle souhaitée

    while (sht31.readHumidity() > (Hum_poten) { // Le système de ventilation se met en marche tant que l'humidité n'est pas redescuendue jusqu'à Hum_poten

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Humidité trop élevée");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
       digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

    }
}

else {

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Conditions atteintes");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 en arrêt)
       digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 en arrêt)

}

// Humidité trop faible

if (sht31.readHumidity() < (Hum_poten-5) ){ // Si l'humidité est 5% en dessous de celle souhaitée

    while (sht31.readHumidity() <= (Hum_poten) { // Le système d'humidification se met en marche tant que l'humidité n'est pas remontée à Hum_poten

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Humidité trop faible");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_5, LOW); // Le Relai_5 se ferme (Système d'humidification en fonctionnement)

    }
}

else {

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Conditions atteintes");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_5, HIGH); // Le Relai_5 s'ouvre (Système d'humidification à l'arrêt)

}

}

 

Quelques modifications sont à apporter puisque je n'avais pas le matériel :

Paul SPIRCKEL (13/12/2023) :

Je n'avais toujours pas le matériel à ma disposition. Je me suis penché sur la possibilité de récupérer le signal I2C du capteur directement en analogique sur la carte Arduino. Ceci ne semble pas possible car une connexion I2C requiert une communication entre 2 composants, typiquement le capteur et le contrôleur Arduino. Il faudra donc probablement ajouter un shield ou autre extension comportant des connexions I2C. Il faudra faire attention à ce que certains pins utilisés pour d'autres fonctions ne gênent pas des connexions du shield, sinon il ne fonctionnera pas. Idem si on utilise le "Wireless SD Shield" pour ajouter de la mémoire. D'ailleurs je me suis renseigné et il semblerait que la carte SD ne puisse être utilisée que pour stocker des données et pas du code. Il doit être possible de faire cela mais avec d'autres composants que je ne connais pas. C'est donc toujours un aspect à développer si un Arduino simple est un peu trop juste (quelques solutions ici ?). Sinon peut-être serait-il intéressant d'utiliser deux cartes (une pour la température, une pour l'humidité) reliées au même capteur.

J'ai essayé d'écrire le programme avec des else if :

#include <Adafruit_Sensor.h>

#include <DHT.h>
#include <LiquidCrystal.h>
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_SHT31.h"
//#include <Adafruit_I2CDevice.h>

#define SHTpin 

#define Relai_1 3              // pin3 devient le pin du relai 1 (Ventilateur 1)
#define Relai_2 4              // pin4 devient le pin du relai 2 (Ventilateur 2)
#define Relai_3 5              // pin5 devient le pin du relai 3 (Résistance de chauffe)
#define Relai_4 6              // pin6 devient le pin du relai 4 (Cooler)
#define Relai_5 13             // pin13 devient le pin du relai 5 (Système d'humidification)

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    // connexion des ports de l'écran LCD

int adcTempPin = A0;                // attribution du pin analogique A0 comme entrée du signal du potentiomètre de température
int adcTempPinfine = A1;            // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin de température
int Temp_poten = 0;                  // Temp_poten est la variable modifiée par les potentiomètres liés à la température
int adcHumPin = A2;                // attribution du pin analogique A2 comme entrée du signal du potentiomètre d'humidité
int adcHumPinfine = A3;            // attribution du pin analogique A3 comme entrée su signal du potentiomètre de réglage fin d'humidité
int Hum_poten = 0;                  // Hum_poten est la variable modifiée par les potentiomètres liés à l'humidité




void setup() {

pinMode(Relai_1, OUTPUT);      // règle le pin 3 en output
pinMode(Relai_2, OUTPUT);      // règle le pin 4 en output
pinMode(Relai_3, OUTPUT);      // règle le pin 5 en output
pinMode(Relai_4, OUTPUT);      // règle le pin 6 en output
pinMode(Relai_5, OUTPUT);      // règle le pin 13 en output

pinMode(adcTempPin, INPUT);      // règle le pin A0 (analogique) comme entrée du signal du potentiomètre Temp
pinMode(adcTempPinfine, INPUT);      // règle le pin A1 (analogique) comme entrée du signal du potentiomètre Tempfine
pinMode(adcHumPin, INPUT);      // règle le pin A2 (analogique) comme entrée du signal du potentiomètre Hum
pinMode(adcHumPinfine, INPUT);      // règle le pin A3 (analogique) comme entrée du signal du potentiomètre Humfine

Serial.begin(9600);          // initialise la comm.

//Section consacrée à l'affichage vouée à évoluer en fonction du système d'affichage choisi

 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp =          ");

 lcd.setCursor(0, 1);

 lcd.println("Set  =          ");

}




void loop() {

delay(2000);                       //attend un peu entre chaque mesures

Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));   // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision
Hum_poten = ((7+analogRead(adcHumPin)/40)+(analogRead(adcHumPinfine)/125));      // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

serial.print(Temp_poten);

//  ---- CONTROLE DE LA TEMPERATURE ----

//  Température trop élevée (max 1°C ou dessus de la température souhaitée)

if ((sht31.readTemperature() > (1+Temp_poten)) and (sht31.readTemperature() < (5+Temp_poten))) { // Si la température est supérieure à 1°C au dessus de la température souhaité

    while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop élevée");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
       digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

    }

}

//  La température est trop faible (Maximum 3°C en dessous de la température souhaitée, ne pas monter plus haut que la température souhaitée)

else if (sht31.readTemperature() < (Temp_poten-3) ){ // Si la température est inférieure à 3°C en dessous de la température souhaitée

    while (sht31.readTemperature() < (Temp_poten) { // Le système de chauffage se met en marche tant que la température n'est pas remontée à Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop faible");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_3, LOW); // Le Relai_3 se ferme (Chauffage en fonctionnement)

    }
}

//  Température trop élevée MALGRE LA VENTILATION (plutôt un cas d'été) (max 5°C ou dessus de la température souhaitée)

else if (sht31.readTemperature() > (5+Temp_poten) ){ // Si la température est supérieure à 5°C au dessus de la température souhaitée

    while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println("Température trop élevée");
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_4, LOW); // Le Relai_4 se ferme (Cooler en fonctionnement)

    }

}

//    ---- CONTROLE DE L'HUMIDITE ----

// Humidité trop élevée

else if (sht31.readHumidity() > (Hum_poten+10) ){ // Si l'humidité est 10% au dessus de celle souhaitée

    while (sht31.readHumidity() > (Hum_poten) { // Le système de ventilation se met en marche tant que l'humidité n'est pas redescuendue jusqu'à Hum_poten

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Humidité trop élevée");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
       digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

    }
}

// Humidité trop faible

else if (sht31.readHumidity() < (Hum_poten-5) ){ // Si l'humidité est 5% en dessous de celle souhaitée

    while (sht31.readHumidity() <= (Hum_poten) { // Le système d'humidification se met en marche tant que l'humidité n'est pas remontée à Hum_poten

       delay(2000);   
       Serial.println(sht31.readHumidity());
       Serial.println("Humidité trop faible");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_5, LOW); // Le Relai_5 se ferme (Système d'humidification en fonctionnement)

    }
}

// Si aucune des conditions précédentes n'est remplie, tout les relais sont ouverts.

else {

       delay(2000);   
       Serial.println(sht31.readTemperature());
       Serial.println(sht31.readHumidity());
       Serial.println("Conditions atteintes");
       Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));
       Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

       digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 à l'arrêt)
       digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 à l'arrêt)
       digitalWrite(Relai_3, HIGH); // Le Relai_3 s'ouvre (Résistance de chauffe à l'arrêt)
       digitalWrite(Relai_4, HIGH); // Le Relai_4 s'ouvre (Cooler à l'arrêt)
       digitalWrite(Relai_5, HIGH); // Le Relai_5 s'ouvre (Système d'humidification à l'arrêt)


}

}

 

Il reste donc à faire : 

Paul SPIRCKEL (24/01/2024) :

Je n'avais pas le matériel donc je me suis penché sur l'organisation du boitier et de la PCB. L'idée est de rendre la PCB très compacte et certainement de désolidariser le LCD de la PCB. J'ai commencé à faire un dessin de découpe de boite (plexiglas de préférence) qui permet sur une face d'avoir le LCD avec les 4 potentiomètres, sur les tranches, il faudrait mettre des sortes de prises pour connecter les différents appareils que l'on souhaite utiliser (aussi bien pour le côté modulaire de l'appareil que pratique quand il va falloir l'installer). A l'arrière, j'ai prévu un emplacement pour l'alimentation de l'Arduino (à voir si on met un transfo dans le boitier ou pas, ce qui risque de l'alourdir et de le chauffer). On pourrait rajouter un crochet sur le dessus pour suspendre le boitier par exemple. Avoir les composants répartis sur différentes faces implique de les désolidariser de la PCB, mais donc de la rendre plus petite (à voir ce qui est le mieux puisque qu'on va devoir ajouter des fils à l'intérieur). 

J'aimerais si possible avoir accès aux dimensions des différents composants pour pouvoir finir ce modèle :)

Paul SPIRCKEL (31/01/2024) :

J'ai continué le patron du boitier. J'ai également réorganisé la PCB (fichier en pièce jointe). L'idée est de placer le LCD en haut, les potentiomètres alignés sur le côté, l'Arduino plus ou moins au centre et les relais alignés en bas. De cette manière on aura le plus de composants directement soudés sur la PCB. Il suffira d'adapter le patron du boitier aux bonnes dimensions. Il faudra aussi intégrer une alimentation 230V pour les relais et une dérivation de courant pour l'Arduino. Je n'ai jamais utilisé KiCad avant donc mon schéma est seulement visuel mais pas du tout fonctionnel. Si quelqu'un se sent de le faire proprement, ce serait super (je vais essayer d'apprendre d'ici là).

Paul SPIRCKEL (07/02.2024) :

Cette séance je me suis intéressé à la façon dont on pourrait faire varier la tension des panneaux LED. On pourrait utiliser un variateur de tension externe, sauf si l'on veut que la luminosité soit réglée automatiquement (mais est-ce que ça fait du sens ?). J'ai découvert une technique appelée PWM qui permet de générer des signaux analogiques réglables à partir de signaux numériques. Pour autant j'ai l'impression que ça ne génère que des sinusoïdes et pas des tensions constantes, mais la piste reste à creuser. Je n'ai pas pu le tester par manque de temps mais aussi parce que je n'ai jamais travaillé sur un ESP32 et je n'ai pas réussi à corriger des erreurs certainement causées par des problèmes de bibliothèques et autres. J'ai testé le capteur de luminosité, il fonctionne bien.

La boîte du projet est restée en Biologie / Chimie

Projet Greenduino

On cherche une solution pour construire un terrarium autonome. (Auteurs: SAMETOGLU Alper et VIVIEN Maël)

Solution envisagée

Alimentation à induction puissante pour alimenter la carte esp32, les LEDs, les capteurs et éventuellement la Mini pompe

Dans ce projet, les ESP32 et ESP8266 sont utilisés (fonctionne sur Wifi 2.5 GHz)

Les avantages d'utiliser un ESP32
  1. On peut facilement mettre un site web sur la carte pour la piloter à distance et il doit exister plein de tuto pour mettre en place un arrosage automatique avec cette carte.
  2. La carte possède un assez grand nombre d'entrée /sortie pour brancher différents capteurs.
Les désavantages d'utiliser un ESP32
  1. La logique des broches de la carte est en 3.5V, on doit donc ajuster les niveaux de tension de certains capteurs.
Le fonctionnement du projet

Screenshot_4.png

Liens qui peuvent être utiles

 


Sovol 3D (Lavage de résin) "Upgrade"

Dans ce projet, on cherche à trouver une solution à la machine de lavage Sovol 3D qui s'arrête après quelques essais. Pour cela, on envisage à changer la méchanisme de bouton (qui est actuellement faite avec une bouton de commutation) et la remplacer avec une système de bouton poussoire.

Sovol3DParties.jpg

Il y a deux composants principaux de la machine qui semblent défectueux :

SovolCarte.jpg

Le projet peut alors s'articuler autour de la recherche d'un moyen de tester les relais entre les boutons et le moteur, et peut-être d'un moyen de remplacer les boutons de type ressort par de véritables boutons cliquables.

Après quelques tests, on a confirmé que la machine s’arrête après même pas une minute (poir un réglage de 5 min) …

On utilise un Arduino Nano 328 comme base de notre projet, et pour le codage on se base sur des recherches conduites sur Internet et les forums de Github.

Première ébauche (22.3.2023)
const int startBouton = 2; // un bouton sur la broche 2
const int resetBouton = 3; // un bouton sur la broche 3
const int timerBouton = 4; // un bouton sur la broche 4
const int moteurPin = 5; // un moteur sur la broche 5

void setup()
{
    // on met le bouton en entrée
    pinMode(startBouton, INPUT_PULLUP);
    pinMode(resetBouton, INPUT_PULLUP);
    pinMode(timerBouton, INPUT_PULLUP);
    pinMode(moteurPin, OUTPUT);
    
}

int start_etat;
int reset_etat;
int timer_etat;
int t = 1;

void loop()
{
    start_etat = digitalRead(startBouton);
    reset_etat = digitalRead(resetBouton); 
    timer_etat = digitalRead(timerBouton);

    if(start_etat == HIGH)
        actionAppuiStart(); // le bouton est appuyé

    if(reset_etat == HIGH)
        break; // peut-être pas la meilleure solution : ajouter une fonction interrupt qui peut se faire même pendant le delay
    
    if(timer_etat == HIGH)
        actionAppuiTimer(); // le bouton est appuyé
      
    delay(10);
}

void actionAppuiTimer(){

  if (t = 3)
    t = 1;
  else
    t += 1;

}

void actionAppuiStart(){

  if (t = 1)
  digitalWrite(moteurPin,HIGH); // le moteur tourne pendant 5 minutes
  delay(300000);
  digitalWrite(moteurPin,LOW);

  if (t = 2)
  digitalWrite(moteurPin,HIGH); // le moteur tourne pendant 10 minutes
  delay(600000);
  digitalWrite(moteurPin,LOW);
  
  else
  digitalWrite(moteurPin,HIGH); // le moteur tourne pendant 15 minutes
  delay(900000);
  digitalWrite(moteurPin,LOW);

}
Réflexions

Ce code est relativement simple : on est allé chercher une algorithme de « comptage » sur Youtube. Nous nous sommes croisés avec un tutoriel d’Arduino qui permet de réaliser une programme qui effectue le comptage requise pour la partie « Timer » de la machine, car nous avons l’idée que c’est la fonction celui-ci qui pose problème pendant l’exécution de la session voulue (5,10,15 min).

Après avoir appris comment faire le code sur Arduino IDE, notre prochain étape était de trouver quels « ports » à utiliser sur la carte Arduino, car apparemment notre système requiert une module qui se connecte à la première sortie à droite de la carte. Dans le tutoriel, toutes les connections nécessaires sont introduites, et nous nous sommes débrouillés pour déterminer lesquels à utiliser dans notre cas. 

Dans le code, on a aussi traité le sujet de relier ce système de « Timer » avec les boutons poussoirs qu’on veut introduire a la machine. Comme précédemment évoqué, les boutons actuelles de la machine peuvent influencer le démarrage de la machine, car son approche d’un système « à distance » crée une problème de « mal connexion » quand on veut commencer la procédure. Pour ceci, on  a introduit une partie dans le code où, selon le bouton cliqué sur la machine, le « Timer » effectue des durées selon notre souhait.

Le code nécessite bien sûr des améliorations, il n’est pas du tout complet et il y a la possibilité qu’il soit moins complexe. Comme nous sommes toujours à L1, nos connaissances sont assez limitées, donc les autres réflexions sont à considérer.

Liens

https://youtu.be/hriSLWYOMyM

https://youtu.be/EGNBmjVzZBE

https://youtu.be/gd1DUXZ8H34

 

 


Interface Arduino éclairage

 

Informations

Contexte

J'ai récupéré une dizaine de très grands tube lumineux à LED et j'aimerais leur donner une nouvelle vie. J'ai donc pour projet de les relier à un microcontrôleur qui constituera une interface me permettant de les commander facilement pour tout usage possible (soirée, domotique...)

Objectifs

Objectif premier : simplement relier les LED à un microcontrôleur (type Arduino), l'interface en restera au code que j'implémenterai. Il faut pour celà trouver des MOSFET, des câbles pour la commande à distance, une source d'alimentation puissante et choisir l'arduino.

Objectif second : coder sur le microcontrôleur une communication série en USB avec un ordinateur pour le commander à partir du logiciel Touchdesigner et automatiser les processus.

Objectif troisième : réaliser une interface physique sous la forme d'un boîtier de commande qui permettrai de sélectionner différents "programmes" et "effets" ainsi que quelques valeurs sur des potentiomètres. Ces informations serviront à déclencher des effets codés au préalable dans le microcontrôleur. Un petit écran sera rajouté pour donner un retour sur le programme/effet/valeur sélectionné. Si l'écran comprend également un lecteur de carte SD un objectif bonus sera de permettre de lire/écrire des programmes sur et depuis cette carte.

interface-eclairage.jpg

(work in progress)

Matériel

Machines utilisées

Fer à souder

Multimètre/oscilloscope

Découpeuse laser/imprimante 3d ? Pour le boîtier 

Construction

Le plan :

Contraintes techniques : j'ai besoin de 10 sorties PWM sur mon microcontrôleur. Pour des raisons de coût j'ai donc acheté deux Arduino micro (6PWM chacune)

Étape 1

----

Étape 2

----

Étape 3

----

Journal de bord

Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)

13/10/2023

Test de la commande d'un tube à Led (consommant 22W en 24v) à partir d'une faible tension continue de 5v grâce au IRFZ44. Les premiers test se déroulent bien mais j'ai peut être cramé mon mosfet car il génère un courant de 30mA entre sa base et sa source. C'est 10mA de plus que ce peut supporter l'arduino donc impossible d'ignorer ce problème. Mais ça me fait penser à un autre problème : le PWM simule un signal analogique en faisant varier le rapport cyclique d'un signal carré à haute fréquence. Or si le mosfet n'est pas censé conduire par sa grille, un courant alternatif peut quand même passer par phénomène de capacitance. Donc dans tous les cas une résistance de faible valeur entre la sortie de mon Arduino et la grille d'un mosfet est nécessaire.

19/10/2023

Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.

20/10/2023

Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩

Nouvelle page

Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.
IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.
Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.
Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"

Informations

Contexte

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum. 

Objectifs

Nulla imperdiet mattis neque non vehicula. Aliquam aliquam ac lectus non euismod. Nulla facilisi. Fusce fermentum enim magna, vel consectetur sem malesuada eu. Integer ac iaculis magna, dictum posuere neque. Sed pretium dignissim arcu, vel maximus felis cursus in.


image-1653061695508.jpeg

Ajouter au moins une image de votre projet

Matériel

Machines utilisées

Trotec Speedy 100

Construction

(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)

Étape 1

----

Étape 2

----

Étape 3

----

Journal de bord

Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)

03/04/2022

Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.

11/04/2022

Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.

18/04/2022

Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩

Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.
IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.
Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.
Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"

Informations

Contexte

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum. 

Objectifs

Nulla imperdiet mattis neque non vehicula. Aliquam aliquam ac lectus non euismod. Nulla facilisi. Fusce fermentum enim magna, vel consectetur sem malesuada eu. Integer ac iaculis magna, dictum posuere neque. Sed pretium dignissim arcu, vel maximus felis cursus in.


image-1653061695508.jpeg

Ajouter au moins une image de votre projet

Matériel

Machines utilisées

Trotec Speedy 100

Construction

(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)

Étape 1

----

Étape 2

----

Étape 3

----

Journal de bord

Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)

03/04/2022

Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.

11/04/2022

Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.

18/04/2022

Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩

Arduino - Alina Pintea & Mehdi Chaabi & Mathias Benezeth

Objectif du projet :

Construire un programme sur Arduino permettant d'allumer une LED rouge si la température est supérieure à 25°C et une LED bleue si la température est inférieure à 25°C.

Étapes réalisées :

Étape 1 : Rassemblement des composants pour le circuit

Étape 2 : Montage du circuit avec démonstration

Le montage du circuit a été effectué conformément au schéma suivant :

 

Étape 3 : Programmation pour contrôler les LED en fonction de la température

Voici le code Arduino utilisé pour contrôler les LED en fonction de la température :

 

#define LEDBLEU 10 // définition de la led bleue

#define LEDROUGE 9 // définition de la led rouge

#define CapteurTemp A0 //définit le pin pour le capteur de la température

 

void setup(){

  pinMode(LEDROUGE, OUTPUT); //Configure le pin comme sortie pour la LED Rouge

  pinMode(LEDBLEU, OUTPUT); //Configure le pin comme sortie pour la LED Bleu

  pinMode(CapteurTemp, INPUT); //Configure le pin comme sortie pour le capteur de température

}

 

void loop(){

  int valeurCapteurTemp = analogRead(CapteurTemp);

  float tension = (valeurCapteurTemp/1023.0)*5.0; // Convertit la valeur analogique en tension (5V)

  float temperature = tension * 25.0; //Convertit la tension en température en degrés Celsius

 

  if (temperature < 25.0) {

    digitalWrite(LEDROUGE, LOW);

    digitalWrite(LEDBLEU, HIGH);

  } else {

    digitalWrite(LEDROUGE, HIGH);

    digitalWrite(LEDBLEU, LOW);

  }

}

Étape 4 : Présentation des résultats 

La LED Rouge s'allume car la température est supérieur à 25°C

image.png

-------------------------------------------------------------------------------------------------------------

La LED Bleu s'allume car la température est inférieur à 25°C 

 

image.png

Programmation d'un capteur sonore

Informations

Contexte

Ce projet a pour but d'intégrer et de programmer un capteur à un système électronique branché à une carte Arduino. Pour ce projet, nous avons choisi de programmer un capteur sonore. 

Objectif

L'objectif est de pouvoir allumer et éteindre une LED en claquant des mains grâce au capteur sonore. 

1606313189-gsk-06-soundsnsr-plug-in-module.png

Matériel

Principe physique

Le capteur sonore est composé d'une plaque de diaphragme. Lorsque des vibrations sonores sont produites des bruits forts, elles frappent la plaque du diaphragme, ce qui la fait vibrer. Lorsqu'elle vibre, elle modifie la capacité, ce qui entraîne une variation de la tension. La tension peut alors être lue à l'aide de la fonction analogRead().

1606313192-gsk-06-soundsnsr-understand.png

Construction

Étape 1

Nous avons d'abord effectué les branchements nécessaires. Le capteur sonore est branché sur un port analogique est la LED est branché sur les pins A et GND de la carte Arduino. 

image.png

Étape 2

Nous avons ensuite écris un programme dont le but est de lire les données du capteur et de commander la LED. Dans un premier temps, nous déclarons les Pins de la LED et du capteur de son. 

int sound_sensor = A2; //assign to pin A2
#define LED 12
bool etat_LED=false; 

void setup() 
{
  Serial.begin(9600); //begin Serial Communication
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
}
  

Notre fonction void loop() va ensuite lire les données du capteur en boucle. Les données du capteur sont des valeurs entre 0 et 1023 qui oscille en fonction du bruit ambiant. Nous avons donc fixé un seuil au delà duquel nous changeons la sortie de la LED. 

void loop()
{
  int soundValue = 0; //create variable to store many different readings
  soundValue = analogRead(sound_sensor)
 
  Serial.println(soundValue); //print the value of sound sensor
  
  if (soundValue > 150) { 
    if (etat_LED){          
     digitalWrite(LED, LOW);
     etat_LED = false;
     //Serial.println("Led off");
   }
   else{
     digitalWrite(LED,HIGH);
     etat_LED=true;
    // Serial.println("Led on");
     }     
  }
  delay(100); //a shorter delay between readings
}
Difficultés rencontrées 

La première difficulté de cette tache a été de définir un seuil adéquat. Pour un seuil trop élevé, la LED ne s'allume pas, pour un seuil trop faible, la LED s'allume et s'éteint trop souvent.  Nous avons donc mesuré le bruit ambiant afin de déterminer une valeur seuil suffisamment élevée pour déclencher le changement d'état de la LED. Nous avons également confondu les sorties analogiques et numériques, ce qui empêchait la LED de s'allumer. 

Résultats 

Après avoir uploadé notre programme, notre LED s'allume lorsqu'on émet prêt du capteur un bruit suffisamment fort comme un claquement de main.  

Améliorations

Nous pourrions intégrer à notre système un capteur de lumière ambiante pour ajouter une condition d'activation de la LED. 

Programmation d'un capteur sonore

Informations

Contexte

Ce projet a pour but d'intégrer et de programmer un capteur à un système électronique branché à une carte Arduino. Pour ce projet, nous avons choisi de programmer un capteur sonore. 

Objectif

L'objectif est de pouvoir allumer et éteindre une LED en claquant des mains grâce au capteur sonore. 

1606313189-gsk-06-soundsnsr-plug-in-module.png

Matériel

Principe physique

Le capteur sonore est composé d'une plaque de diaphragme. Lorsque des vibrations sonores sont produites des bruits forts, elles frappent la plaque du diaphragme, ce qui la fait vibrer. Lorsqu'elle vibre, elle modifie la capacité, ce qui entraîne une variation de la tension. La tension peut alors être lue à l'aide de la fonction analogRead().

1606313192-gsk-06-soundsnsr-understand.png

Construction

Étape 1

Nous avons d'abord effectué les branchements nécessaires. Le capteur sonore est branché sur un port analogique est la LED est branché sur les pins A et GND de la carte Arduino. 

image.png

Étape 2

Nous avons ensuite écris un programme dont le but est de lire les données du capteur et de commander la LED. Dans un premier temps, nous déclarons les Pins de la LED et du capteur de son. 

int sound_sensor = A2; //assign to pin A2
#define LED 12
bool etat_LED=false; 

void setup() 
{
  Serial.begin(9600); //begin Serial Communication
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
}
  

Notre fonction void loop() va ensuite lire les données du capteur en boucle. Les données du capteur sont des valeurs entre 0 et 1023 qui oscille en fonction du bruit ambiant. Nous avons donc fixé un seuil au delà duquel nous changeons la sortie de la LED. 

void loop()
{
  int soundValue = 0; //create variable to store many different readings
  soundValue = analogRead(sound_sensor)
 
  Serial.println(soundValue); //print the value of sound sensor
  
  if (soundValue > 150) { 
    if (etat_LED){          
     digitalWrite(LED, LOW);
     etat_LED = false;
     //Serial.println("Led off");
   }
   else{
     digitalWrite(LED,HIGH);
     etat_LED=true;
    // Serial.println("Led on");
     }     
  }
  delay(100); //a shorter delay between readings
}
Difficultés rencontrées 

La première difficulté de cette tache a été de définir un seuil adéquat. Pour un seuil trop élevé, la LED ne s'allume pas, pour un seuil trop faible, la LED s'allume et s'éteint trop souvent.  Nous avons donc mesuré le bruit ambiant afin de déterminer une valeur seuil suffisamment élevée pour déclencher le changement d'état de la LED. Nous avons également confondu les sorties analogiques et numériques, ce qui empêchait la LED de s'allumer. 

Résultats 

Après avoir uploadé notre programme, notre LED s'allume lorsqu'on émet prêt du capteur un bruit suffisamment fort comme un claquement de main.  

Améliorations

Nous pourrions intégrer à notre système un capteur de lumière ambiante pour ajouter une condition d'activation de la LED. 

Ajout d'une RAM 8Go sur un PC portable

NOM: Jacob-Piacentini | Dangremont Di Crescenzo

PRENOM: Amaury | Art

MAIL: Amaury_Francois.Jacob@etu.sorbonne-universite.fr Art.Dangremont_Di_Crescenzo@etu.sorbonne-universite.fr

Cursus: L2 EEA

Introduction

L'ajout de mémoire vive (RAM) supplémentaire à votre ordinateur portable peut améliorer ses performances en permettant l'exécution plus fluide de plusieurs applications simultanément. Cette documentation vous guidera à travers les étapes nécessaires pour installer 8 Go de RAM supplémentaires sur votre ordinateur portable.

Matériel nécessaire

Étapes d'installation

Étape 1: Vérification de la compatibilité

Assurez-vous que le module de mémoire RAM que vous avez acheté est compatible avec votre ordinateur portable en vérifiant les spécifications du fabricant ou en consultant le manuel de l'utilisateur.

 

Étape 1 : Dévissage

Utilisez un tournevis de précision pour dévisser les vis à l'arrière du PC portable.

Étape 2 : Séparation de la coque

Utilisez des médiators pour séparer délicatement la coque du PC portable.

Sans titre.jpg

Étape 3 : Débranchement de la batterie

Débranchez la batterie du PC portable.

Sans titre.jpg

Étape 4 : Ajout de RAM

Repérez l'emplacement de la RAM sur la carte mère du PC portable. (Voir Photo 5)
Insérez la nouvelle RAM dans l'emplacement prévu.

Sans titre.jpg

Vérification de la nouvelle RAM

Pour vérifier si la nouvelle RAM a été correctement reconnue, vous pouvez ouvrir le gestionnaire des tâches (Ctrl + Shift + Échap sous Windows) et accéder à l'onglet "Performance" pour afficher la quantité totale de RAM installée.

image.png

BARE METAL

Informations

Noé, ceci est censé être une surprise. Merci de ne pas lire la suite ! Pas de spoil !

Contexte

Noé est un guitariste de grand chemin et de grande taille, qui se balade souvent dans la fac avec son instrument électroacoustique. Ainsi, pour son anniversaire, j'ai décidé de lui fabriquer une pédale d'effets à l'ésthétique douteuse en me basant sur une de nos passions communes, le RTOS les barres de métal.

Objectifs

L'objectif ici est de réaliser une pédale d'effets pour guitare qui fait passer le son entrant dans un tuyau en métal avant de l'amplifier à la sortie.

Elle devra remplir tous les critères d'une vraie pédale :

Un objectif secondaire serait d'y ajouter un système qui jouerait certains sons (comme par exemple la fameuse chute d'une barre de fer sur le sol) sur l'appui d'un bouton, et qui l'ajouterait au signal sonore de la guitare.

Matériel

De plus, plusieurs résistances et capacités seront utilisés. Les tests seront grandement aidés par un Analog Discovery 2.

Machines utilisées

Pour l'instant, aucune. L'impression d'un PCB est prévue, ainsi que la peinture de la boîte en alu.

Construction

(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)

Étape 1 - Considérations acoustiques

S'il faut faire passer le signal sonore de la guitare dans une barre de métal, la meilleure solution est probablement d'utiliser des disques piézoélectriques. Ils se fixent facilement à une surface et résonnent très bien dans la bande du son audible (20 Hz ~ 20 kHz). De plus, ils jouent le rôle de transducteurs, c'est-à-dire qu'ils peuvent s'utiliser comme émetteurs de son ou comme récepteurs. J'ai donc choisi plusieurs piézos de tailles et de fréquences de résonance différentes.

Pour que la majorité de l'onde acoustique se propage dans la barre de métal et non dans l'air, j'ai utilisé des supports pour tuyau : un jeu en PVC, et un jeu en métal entouré de caoutchouc isophonique. J'ai également eu accès à deux barres de métal : une pleine et une creuse.

J'ai donc décidé d'utiliser la fonction Network de l'Analog Discovery 2, qui permet de dresser la réponse en fréquence d'un système, pour déterminer la configuration barre - support - piézo la plus intéressante pour la pédale. Cela me permet d'observer l'effet du passage du son dans la barre comme si c'était un filtre. Voici quelques résultats :

Barre creuse, support métallique, entre le DP035 et le DP035F

C-MANA-035-035F.png

Barre creuse, support PVC, entre le DP035F et le TVF

C-PVC-035F-TVF.png

Barre creuse, support PVC, entre le TVF et le DP035F

C-PVC-TVF-035F.png

On remarque déja que le système atténue grandement le signal sonore (-40 dB en moyenne), ce qui est compréhensible étant donné les pertes entre les disque et les support, les support et la barre métallique, et la perte dans l'air sous forme de son chez le disque et la barre (en effet, lors des tests, on entend faiblement le son entrant sortir de la barre). De plus, chacun des transducteurs et des matériaux ayant sa propre réponse fréquentielle, la réponse globale du système est chaotique, surtout vers les hautes fréquences.

Choisir une configuration ayant un bon gain en basses fréquences donnera un effet de type "Bass Boost" au son, un effet souvent souhaité en guitare électrique, mais au contrairement à un filtre ad hoc, les hautes fréquences ne seront pas "lissées" et risquent de se trouver déformées. Pour éviter de devoir filtrer le signal après coup, on choisira un système dont la réponse fréquentielle ne présente pas de grandes disparités d'atténuation. Cela m'oriente plutot sur les supports en PVC, même si ceux-ci présentent des difficultés : leur section est rectangulaire, contrairement aux supports métalliques qui sont cylindriques et donc plus facilement collables sur les disques.

L'intérêt principal de cet étape est d'estimer le gain nécéssaire en sortie de la barre de métal et de dresser une ébauche de l'effet créé par la BARE METAL. Cependant, l'acoustique étant un domaine complexe qui dépasse ce qui est observable à l'écran, je vais devoir tester les différentes configurations "à l'oreille" pour trouver la meilleure, avec un circuit sommaire, une fois que les composants audio commandés seront arrivés.

Étape 2 - Prototypage complet

----

Étape 3

----

Journal de bord

Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)

15/02/2024

Début du projet de manière sérieuse. Soudure des disques piézo, test approfondis de leurs caractéristiques acoustiques.

Lanceur de balle de ping pong

 

Ce projet a pour objectif la réalisation d'un lanceur de balle de ping pong qui peut projeter des balles selon plusieurs positions.

Décoration lumineuse : un petit lampadaire

Informations

Contexte et objectif

Je souhaite faire une petite décoration pour une boite qui serait un décor de rue avec un lampadaire qui s'allume avec un interrupteur. Mon idée initiale ressemble à ce schéma : 

image.png

Matériel

Machines et outils utilisés

Pages de wiki utilisées : soudure et bonnes pratiques de soudure 

Construction

souder : Dénuder le bout d'un fil électrique avec la pince à dénuder. Placer les deux éléments sur les pinces (photo 1 plus bas) de sorte que le fil et la patte se touchent. Allumer le fer à souder. Chauffer les deux éléments avec le fer à souder. Appliquer l'étain. Si besoin, nettoyer le bout du fer à souder sur l'éponge humide ou dans la maille métallique (dorée).

image.png pince à dénuder.

J'ai soudé les différents éléments en série un par un : pour mon circuit je veux pouvoir déplacer les fils, donc j'ai aligné les pattes de mes composants. C'est moins solide. Si on veut faire un objet électronique plus gros il faut que les éléments soient "fixés mécaniquement (repli) avant de souder. Mais dans mon cas, ça m'a semblé plus judicieux.
Avant de souder le deuxième bout d'un fil, j'ai passé des gaines thermo rétractables pour recouvrir les fils qui sont à nu. C'est d'autant plus important pour mon lampadaire puisqu'il est en fil de fer et toucher ferait surement un court-circuit. Les gaines sont resserrées grâce à la station à air chaud (un sèche cheveux d'électricien en somme).

         image.png                     image.png          image.png
1 : Pas une soudure pratique pour aligner les fils ; 2 : soudure alignée etre la patte et le fil; 3 : gaines de fil thermorétractables. 

Je ne savais pas si j'avais besoin d'ajouter une résistance. J'ai commencé par en brancher une de 1k.Ohm mais la luminosité de la led était trop réduite, j'ai enlevé a résistance. 

Résultat :

image.png  image.png

D'autres éléments du décors sont en cours de réalisation. J'ajouterai une photo une fois tout terminé (si je termine un jour).

Détecteur d'enveloppe et démodulation

Le circuit est conçu pour détecter les crêtes d'un signal électrique d'entrée et les extraire de manière précise en utilisant un détecteur de crête. Ensuite, ces crêtes sont démodulées pour récupérer les données modulées qui sont transportées par le signal d'entrée.

Les différentes parties du circuit:

  1. Filtre passe-bas :
    Pour éliminer les composantes haute fréquence du signal et ne laisser passer que le signal modulé de basse fréquence.
  2. Détecteur d'enveloppe:
    • Diode : pour détecter l'amplitude du signal.
    • Condensateur : Pour stocker la charge et lisser le signal détecté.
    • Résistance : Pour fournir une impédance de charge au condensateur.
    • Amplificateur Opérationnel (AOP) : Pour amplifier le signal détecté.
  3. Comparateur simple:
    Le comparateur produit une sortie logique en fonction de la relation entre le signal d'enveloppe et la tension de référence. Si le signal d'enveloppe dépasse la tension de référence, la sortie du comparateur est logique "1", sinon, elle est logique "0".