🎮 Électronique
- Redressement de tensions alternatifs
- robot qui saute à 30 m
- Régulateur solaire MPTT
- simulateur de panneau solaire
- Projet Ventilateur Grow Box
- Projet Greenduino
- Sovol 3D (Lavage de résin) "Upgrade"
- Interface Arduino éclairage
- Nouvelle page
- Arduino - Alina Pintea & Mehdi Chaabi & Mathias Benezeth
- Programmation d'un capteur sonore
- Programmation d'un capteur sonore
- Ajout d'une RAM 8Go sur un PC portable
- BARE METAL
- Lanceur de balle de ping pong
- Décoration lumineuse : un petit lampadaire
- Détecteur d'enveloppe et démodulation
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)
Schéma du montage : redresseur double alternance
(sans filtrage) (avec filtrage)
robot qui saute à 30 m
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:
- alimentation de laboratoire 10A (pour l'entrée solar_in)
- générateur de fonction, pour générer le signal PWM
- alimentation de laboratoire pour founir le 5V
- multimètre (pour mesure précise de la tension d'entrée)
- multimètre de table (pour mesure précise du courant d'entrée)
- charge fictive (pour consomer le courant en sortie, à courant constant)
- oscilloscope (pour visualiser les différent signaux)
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é.
Pour atténuer cette sur-oscillation, plusieurs modifications ont été apportées:
- Re-routage du circuit pour que les masses des condensateurs d'entrée (c3 à c7 sur le nouveau schema) soient du même coté que les masses des condensateurs de sortie et que le transistor bas du convertisseur (le chemin pour rejoindre la masse de ces condensateurs était beaucoup trop long !)
- ajout d'une resistance en série avec le condensateur boost pour ralentir le front montant du transistor haut (avec une diode en parallèle pour changer le condensateur plus rapidement si nécessaire)
- ajout d'un filtre RC sur le noeud SW
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:
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.
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.
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:
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 abandonné le capteur DHT trop peu précis (plusieurs degrés d'incertitude) pour un capteur SHT31 bien plus précis (incertitude de l'ordre du dixième de degré à présent). Cependant, il n'apparait pas dans le montage ci-dessous car il se branche pour l'instant sur un shield seeeduino via les port I2C. Mais s'il existe un moyen de contourner le shield je suis preneur.
- J'ai échangé les "slide potentiometer" de chez Arduino pour des potentiomètres rotatif plus précis (8 et 10kOHm) et plus esthétique aussi ! Seulement pour cela j'ai dût ajouter quelques résistances pour éviter tout risque de cours circuit.
- J'ai aussi ajouté trois relais supplémentaire.
- Un qui actionnerais une résistance de chauffe afin d'élever la température de la serre au dessus de la température ambiante.
- Un autre qui actionnerais un système de refroidissement (une pompe à eau par exemple).
- Un dernier qui actionnerais un système de brumisation afin de pouvoir contrôler l'hygrométrie à terme !
- J'ai aussi remis un tout petit potentiomètre pour la luminosité (c'est finalement plus agréable).
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 :
Le schéma du circuit sur KiCad
La PCB
J'ai joins le fichier de la PCB
Pour ce qui est du code :
- Il faudra maintenant apporter quelques modifications pour l'adapter à la librairie du capteur SHT31 (essentiellement changer les "dht.read" par des "sht.get").
- J'ai connecté
- "résistance de chauffe" -----> pin digitale 5
- "cooler" ---------------------> pin digitale 6
- "système d'humidification" -> pin digital 13
- Il faudrait établir des conditions d'allumage des nouveaux système lié à la régulation de la température, à savoir, le chauffage et le refroidissement actif.
- Il faudrait établir un système de régulation de l'humidité (quand allumer le brumisateur pour humidifier et quand allumer les ventilateurs pour sécher l'air).
- Peut-être aussi que centrer le delta d'allumage autour de la valeur demandé serais plus judicieux pour avoir une meilleur précision. Par ça j’entends, au lieu d'allumer les ventilateurs lorsque la température souhaité est atteinte et les éteindre trois degré en dessous, les allumer un degré au dessus de la valeurs souhaité et les éteindre un degré en dessous de la valeur souhaité
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 :
Le schéma mis à jour
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 :
- Redéfinir l'échelle des valeurs Temp_poten correspondant au nouveau potentiomètre
- Créer l'échelle des valeurs (%) Hum_poten correspondant au nouveau potentiomètre
- Ajouter toutes les lignes d'affichage sur écran
- Essayer d'utiliser des elsif avec une seule condition else qui permet de désactiver tous les relais
- Trouver un moyen de contourner la connexion I2C
- Ajouter toutes les bibliothèques nécessaires si elles n'y sont pas déjà
- Trouver un moyen de déconnecter tous les appareils chauffants si la température est trop élevée pendant trop longtemps
- Ajouter le shield de carte SD et faire en sorte que le programme soit lu dessus
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 :
- Redéfinir l'échelle des valeurs Temp_poten correspondant au nouveau potentiomètre
- Créer l'échelle des valeurs (%) Hum_poten correspondant au nouveau potentiomètre
- Ajouter toutes les lignes d'affichage sur écran
- Corriger le programme (je n'ai pour le moment pas pu me rendre compte de potentielles erreurs)
- Ajouter toutes les bibliothèques nécessaires si elles n'y sont pas déjà
- Trouver un moyen de déconnecter tous les appareils chauffants si la température est trop élevée pendant trop longtemps (fusible ou relai en plus)
- Tester d'empiler l'Arduino Uno + le shield I2C et changer certaines connections pour que rien n'interfère (voir ici les pins I2C sont ceux de la rangée du bas)
- Utiliser une autre carte ou augmenter la mémoire de programmation si celle de la carte ne suffit pas
- Essayer d'ajouter un switch à 3 pins pour choisir le mode de refroidissement
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
- 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.
- La carte possède un assez grand nombre d'entrée /sortie pour brancher différents capteurs.
Les désavantages d'utiliser un ESP32
- 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
- On peut envisager d’ajouter une batterie pour pouvoir faire fonctionner le système temporairement sans qu’il soit “branché” mais cela semble assez inutile et risque de rajouter des sources de pannes plus importantes.
- La carte hébergera un site web de type apache (probablement) à partir duquel on pourra faire varier l'hygrométrie, la température si on rajoute un chauffage (l’alimentation devrait le permettre, surtout dans la mesure ou en enceinte fermée un petit chauffage devrait suffire)
- (il faudra aussi déterminer si un chauffage est utile au vue de la chaleur dégagée par les différents composants)
- Il faut donc acheter le chargeur à induction, les connecteurs étanches et éventuellement la mini pompe. Il faut trouver une alimentation externe suffisamment puissante ou l’acheter à défaut.
- Trouver un relais (le piquer au fablab si besoin) pour les leds.
- Réfléchir au câblage global, déterminer la liste exacte des capteurs à intégrer et trouver une personne capable de coder un joli site web.
- Dessiner un boîtier à imprimer en résine pour accueillir l’ensemble de l'électronique ou acheter un boîtier étanche.
- Il existe déjà un code source et des explications pour un arrosage automatique connecté qu’on a trouvé en ligne : Lien.
Liens qui peuvent être utiles
- Alimentation à induction puissante
- Mini carte de contrôle avec faible consommation énergétique
- Mini pompe
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.
- Tension : 110V/220V 50/60HZ
- Tension de sortie : 24 V
- Courant du produit : 0,3 A
- Puissance maximale : 7,2 W
Il y a deux composants principaux de la machine qui semblent défectueux :
- Le moteur, au centre, qui est activé via le "bouton" de démarrage fixé à droite de la machine.
- Après de multiples essais, il semble que le mécanisme moteur fonctionne bien, même s'il se met parfois à tourner sans même appuyer sur le bouton de démarrage...
- Soit, le deuxième composant est la carte fixée sous les "boutons" externes,
- Cela semble être le composant qui cause réellement le problème, car il semble y avoir un mécanisme non naturel de boutons "sans contact" qui activent certaines fonctionnalités de la machine, à savoir les boutons de démarrage, de réinitialisation et de minuterie. Le système de bouton en général semble être composé d'un ressort qui détecte le mouvement (destiné à un doigt mais semble que tout fonctionne vraiment) pour activer ladite fonction.
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
Interface Arduino éclairage
Informations
- Abel Coiffard
- coiffard.abel@gmail.com
- L2 DC EEA+Philosophie
- 13-27 oct
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.
(work in progress)
Matériel
- 10 MOSFET IRFZ44
- 10*5 mètres de câble (double câble)
- 10 résistances (valeur à calculer)
- 10 résistances 220ohm
- 2 Arduino nano
- 10 borniers à vis 2 pôles
- 10 led témoins
- Quelques câbles internes au système
- 10 alimentations 24v1A (ou 1 * 24v10A)
- Quelques chutes de plaques à trous
- Du contreplaqué et du PLA
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
- Prénom et nom
- Adresse mail
- Cursus / Laboratoire / Association
- Date de début - Date de fin estimée (ou réelle)
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.
Ajouter au moins une image de votre projet
Matériel
- 1 planche de CP peuplier 3mm (dimensions 300*600mm)
- scotch de peintre
- colle à bois
- cutter
- papier de verre grain moyen (80-100)
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
- Prénom et nom
- Adresse mail
- Cursus / Laboratoire / Association
- Date de début - Date de fin estimée (ou réelle)
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.
Ajouter au moins une image de votre projet
Matériel
- 1 planche de CP peuplier 3mm (dimensions 300*600mm)
- scotch de peintre
- colle à bois
- cutter
- papier de verre grain moyen (80-100)
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
- 4 câbles
- Capteur de température
- 2 LED (rouge et bleue)
- 2 résistances
- Un câble reliant l'ordinateur au circuit
- Une plaquette
É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
-------------------------------------------------------------------------------------------------------------
La LED Bleu s'allume car la température est inférieur à 25°C
Programmation d'un capteur sonore
Informations
- Cyrine DHOUIB , Rouaa TLAYSS, Rayane MEKOUAR
- cyrine.dhouib@etu.sorbonne-universite.fr, rouaa.tlayss@etu.sorbonne-universite.fr, rayane.mekouar@etu.sorbonne-universite.fr
- M2 Management de l'innovation
- 2023/2024
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.
Matériel
- Carte Arduino Uno
- Capteur Sonore
- Arduino Shield
- LED et résistance
- BreadBoard
- Fils
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().
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.
É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
- Cyrine DHOUIB , Rouaa TLAYSS, Rayane MEKOUAR
- cyrine.dhouib@etu.sorbonne-universite.fr, rouaa.tlayss@etu.sorbonne-universite.fr, rayane.mekouar@etu.sorbonne-universite.fr
- M2 Management de l'innovation
- 2023/2024
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.
Matériel
- Carte Arduino Uno
- Capteur Sonore
- Arduino Shield
- LED et résistance
- BreadBoard
- Fils
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().
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.
É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
- Module de mémoire RAM DDR4 8 Go SO-DIMM (vérifiez la compatibilité avec votre ordinateur portable)
- Tournevis (généralement un tournevis cruciforme)
- Médiator
É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.
Étape 3 : Débranchement de la batterie
Débranchez la batterie du PC portable.
É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.
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.
BARE METAL
Informations
- Réalisé par SEIGNOLE Nathan
- nathan.seignole@etu.sorbonne-universite.fr
- Profil GitHub : Perigorac
- En EISE4 à Polytech Sorbonne
- Durée du projet : 01/12/2023 ~ 01/04/2024
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 :
- Bonnes impédances d'entrée de sortie, pour pouvoir être insérée dans une chaîne d'effets, un pedalboard, ou branchée directement sur un ampli
- Allumage-extinction par footswitch, avec un bypass total du signal si éteinte
- Contrôle du gain
- Faible bruit (excepté le bruit induit par la barre métallique)
- Alimentation en 9V, de préférence sur batterie
- Robustesse à la saturation sonore
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
- 1 Adafruit Audio FX Sound Board - 2MB Flash
- 6 disques piézoélectriques (buzzers / transducteurs, voir le fichier ODS joint pour plus de détails)
- 1 Boîtier en aluminium nu type BC
- 1 Interrupteur rotatif 12 positions
- 2 potentiomètres Alpha : 100k et 1M
- 3 boutons : 2 pour potentiomètres et 1 pour switch rotatif
- 2 footswitch : latché 3PDT et temporaire 2PDT
- 1 interrupteur flick
- 2 connecteurs Jack 6.3mm
- 1 connecteur pour batterie 9V
- 1 connecteur DC 9V
- 1 LED rouge
- 1 support LED chromé
- 4 amplificateur bas bruit LM386
- 4 sockets pour circuit intégré 8 pins
- 1 régulateur de tension 5V 78L05
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
Barre creuse, support PVC, entre le DP035F et le TVF
Barre creuse, support PVC, entre le TVF et le DP035F
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
- Louise CHORFI, louise.ch@orange.fr, M2 BMC, du 13.03.23 au 15.03.23
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 :
Matériel
- Fil de fer
- interrupteur
- support de piles
- 2 piles AAA
- led orange
- fil électrique
- gaines de fil thermo rétractables
Machines et outils utilisés
- Fer à souder et pinces
- Station d'air chaud
- Pince à dénuder
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).
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).
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 :
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:
-
Filtre passe-bas :
Pour éliminer les composantes haute fréquence du signal et ne laisser passer que le signal modulé de basse fréquence. -
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é.
-
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".