Je suis nessrine krouma, étudiante à iset sfax,département informatique,spécialité "3 ème année système embarqué ".

j'ai entraine de réaliser mon projet de fin d'étude .L'objectif de ce projet est donc de trouver une solution à les problème de Les accidents de chargeur de Smartphone . Ils sont laissés connectés pendant toute une période sans surveillance et parfois des incendies à domicile commencent,
 Nous sommes arrivés à une enquête intermédiaire entre le réseau et le chargeur. Ce média est automatiquement déconnecté lorsque le chargeur est vide ou lorsque le niveau de charge de la batterie atteint 100%.

les matrielles :

carte arduino

Capteur ACS712_30A

realis 5v

Bouton poussoir

j'ai réalise ce cablage :

avec ce code arduino:

#include <ACS712.h>

ACS712 sensor(ACS712_30A, A1);

float tabi[100];

int compteur = 1;

float tabe[100];

int i = 0;
float I;
float x;
float f;
float e;

int relais = 12;

void setup (){
	Serial.begin(9600);
	pinMode(12,OUTPUT);
	Serial.println("initialisation");
	sensor.calibrate();
	pinMode(relais, OUTPUT);
	pinMode(A1,INPUT) ;
	digitalWrite(relais,HIGH);
}


void loop (){

	digitalWrite(relais,LOW);
	analogRead(A0);
	x =  sensor. getCurrentDC();
	
	while(1) {
		
		I=abs(x);
		tabi[compteur]=I;
		f=tabi[compteur]-tabi[compteur-1];
		tabe[compteur]= abs(f);

		Serial.print("I =   ");
		Serial.print(I);
		Serial.print("    e=");

		Serial.println(tabe[compteur]);

		delay(3000);

		compteur++;

		if(tabe[compteur]<=0.03 ){
			Serial.print("ouvrir le relais");
			digitalWrite(relais,HIGH);
			delay(86400000);//24h
		}
	}
}

mais malheuresemnt j'ai n'oubtient aucun réponse .

normalement le battrie charger 100% ou bien le chargeur a vide le relais assure la déconnextion automatique de réseau électrique.

sil vous plait je besoin vous aide ,ma soutenance sera le 17/07/2020 

-
Edité par lorrio 9 juillet 2020 à 8:08:27

Ce n'est pas très étonnant que tu n'obtiennes rien avec ce code.

Ligne 34, tu fais une mesure de courant DC puis tu rentres dans un while (1) qui ne contient plus aucun appel de mesure de courant.

Donc ton programme va rester dans le while (1), sans jamais refaire de mesure...

Je ne vois pas vraiment l’intérêt de ce while (1) ni ce que tu espères faire avec tes tabi et tabe.

A noter qu'en France, le courant du secteur est alternatif à 50 Hz donc tu n'auras rien de bien pertinent avec getCurrentDC.

A moins que tu ne fasse une intégration de la racine carré de la somme de toutes tes messures DC au carré mais ce n'est pas le cas.

Tu ferais mieux d'utiliser getCurrentAC pour mesurer le courant.

Je vois aussi que tu fais un appel à calibrate au début de ton programme mais tu semble ne pas avoir lu la doc qui indique qu'il faut impérativement qu'il n'y ai pas de courant qui passe pendant le processus de calibration.

Il serait donc judiscieux d'ouvrir le relais pendant la calibration car si tu ne le fais pas, ton capteur sera calibré n'importe comment, ce qui est pire que de ne pas le calibrer.

-
Edité par lorrio 9 juillet 2020 à 8:18:55

Merci pour votre réponse,

S'il vous plaît monsieur, pouvez-vous suggérer un exemple de code,pourJe peux donc mieux te comprendre.

et merci beaucoup d'avance.

Une bonne chose à faire pour commencer serait de vérifier si le capteur marche.

Pour cela, un simple programme qui affiche le courant en boucle serait déjà pas mal.

#include <ACS712.h>

ACS712 sensor(ACS712_30A, A1);

int relais = 12;

void setup (void) {
    
	Serial.begin(9600);
    
	Serial.println("INIT");
	pinMode(12,OUTPUT);
	digitalWrite(relais,HIGH); // Ouvrir relais
	delay(200);
	sensor.calibrate();
	delay(200);
	digitalWrite(relais,LOW); // Fermer relais
	
	Serial.println("GO !!!");
	
}

void loop (void) {
	
	float current = sensor.getCurrentAC();
	
	Serial.print("Courant= ");
	Serial.print(current);
	Serial.print(" A");
	Serial.println();
	
	delay(1000);
	
}

Normalement, tu devrais voir la valeur du courant s'afficher toutes les secondes dans le terminal.

Profites en pour noter la valeur consommé pendant la charge et la valeur en fin de charge.

Si la mesure n'est pas stable, il te faudrait faire une mesure moyenne.

Pour cela, tu pourrais faire plusieurs appels à getCurrentAC dans une boucle pour en déduire la moyenne.

Restera ensuite à mettre une condition pour ouvrir le relais quand le courant est trop faible et le tour est joué.

Franchement, pour un projet de 3ème année, ça me parait extrêmement léger... à peine une centaine de ligne de code, c'est vraiment un petit projet.

Monsieur j'ai prend le note ,et j'applique ce code ,,

mais toujours j'ai obtient le valeur de courant =0,dans les deux conditions (si le chargeur est entrain de charger le téléphone et si le chargeur a vide) c'es grâce a quoi ???

-
Edité par NessrineKrouma 9 juillet 2020 à 16:51:50

Si tu as utilisé un capteur ACS712_30A, j'ai bien peur de devoir t'annoncer que tu ne pourras rien en tirer pour ton projet.

Comme son nom l'indique, ce capteur est prévu pour mesurer des courants allant jusqu'à 30A, ce qui est assez élevé.

Pour rappel, P = U * I donc 30A sous 230V représente une puissance de 6900 Watt.

Alors qu'un chargeur de téléphone ne dépasse probablement pas 10 Watt, voir peut-être 20 Watt pour un chargeur rapide.

Au final, tu n'exploites qu'une toute petite partie de ton capteur.

C'est écrit dans la doc, ce capteur a une sensibilité de 66mV par Ampère.

Tandis que l’Arduino est doté d'un ADC 10 bits (1024 points) avec une référence de 5V, soit 4.88mV par point.

Si on fait le ratio par rapport à ton capteur, on a : 1 point ADC = 1A * 4.88mV / 66mV = 0.07A.

Au final, vu la résolution de l'ADC de l'arduino, la précision de la mesure sera multiple de 0.07A.

C'est d'ailleurs pour ça que ton programme affiche 0.00A ou 0.07A car c'est la précision de l'ADC :

- soit l'ADC donne la valeur 0, ce qui correspond à 0.00A

- soit l'ADC donne la valeur 1, ce qui correspond à 0.07A

Mais en 230V, un courant de 0.07A représente 16 Watt, ce qui est déjà plus que ce que pourrais consommer un chargeur classique à pleine puissance.

Donc tu ne pourras clairement pas détecter que le chargeur commence à consommer moins dans le cas où il serait en fin de charge.

Essayes de remplacer ton chargeur de téléphone par un grille pain ou un autre appareil électronique qui consomme beaucoup plus, tu verras que ton programme marche et t'affiche un courant, mais ce n'est pas vraiment l'objectif du projet.

Bref... tout ça pour dire que ton capteur est inadapté pour ton projet.

Il te reste donc 8 jours pour trouver un autre capteur, ça aurait été bien de t'en rendre compte avant.

-
Edité par lorrio 9 juillet 2020 à 22:34:05

Cela devrait améliorer la chose mais ce n'est pas adapté non plus...

Le ACS712 est fait pour une pleine échelle de 5A, ce qui représente de 1150 Watt sous 230V.

Dans ton cas, tu veux mesurer le courant d'un chargeur de 10 Watt, donc tu ne vas exploiter que 1% de la pleine échelle du capteur.

D'après la doc, ce capteur a une sensibilité de 185mV/A, ce qui te donnera une mesure multiple de 0.026 Ampères et donc une précision d'environ 6 Watt.

On aurait donc :

- Si ADC=0, alors I=0 et P=0, soit un chargeur éteint

- Si ADC=1, alors I=0.026 et P=6Watt, soit un chargeur à mi-puissance

- Si ADC=2, alors I=0.052 et P=12Watt, soit un chargeur à pleine puissance

Autant dire que tu ne vas pas aller beaucoup plus loin.

D'autant plus que l'ADC de l'arduino n'est pas vraiment très précis et peu très bien dériver de quelques unités.

A noter qu'il existe des capteurs de courant à un trou au milieux dans lequel on fait passer un fils avec le courant à mesurer, ce serait plus adapté.

Si tu fais passer plusieurs fois le fils dans le trou (en faisant des boucles), cela permet de décupler le courant mesurer et donc d'augmenter la résolution et réduire l'échelle de mesure.

Ou alors, une autre solution serait de garder ton capteur ACS mais de l'utiliser en sortie de chargeur plutôt que sur l'entrée 230V.

Pour rappel, un chargeur classique sort du 5V avec un courant de 1A, voir 2 à 3A pour les chargeurs rapide, ce qui est parfaitement mesurable par un ACS.

(Ou alors, une autre solution serait de garder ton capteur ACS mais de l'utiliser en sortie de chargeur plutôt que sur l'entrée 230V)

Mais quand je choisi cette solution le projet perde l'objective de son cahier de charge  (système de protection d'un chargeur téléphonique) le but de ce projet c'est de réalise un intermédiaire électrique entre le chargeur et le réseau électrique (220v)

Oui, je sais, cela implique de se placer après le chargeur donc ça ne répond pas entièrement au cahier des charges mais ça permet au moins de présenter quelque chose au jury, c'est toujours mieux que rien.

La sécurité sera quand même assurée vu que ton relais pourras couper le 230V.

A toi de voir si tu peux commander ou non un autre capteur et le recevoir avant la date fatidique.

Mais si tu ne peux pas le recevoir à temps, je te conseille d'envisager cette solution.

Pour faire une mesure coté 230V, il te faut impérativement un capteur avec une plage de courant très faible vu que la consommation d'un chargeur de téléphone est très faible.

On pourrait par exemple citer le CSLW6B200M.

Il s’alimente en 5V et sort une tension qui oscille autours de 2.5V, exactement comme le ACS.

Sauf qu'au lieux d'avoir une sensibilité de 66mV/A pour mesurer des courants de 30A, il a une sensibilité de 5100mV/A pour mesurer des courants de 0.2A maxi, ce qui est beaucoup plus adapté à ton cas.

https://fr.farnell.com/honeywell/cslw6b200m/capteur-de-courant-0-2a-4-5v-10/dp/2396419?ost=CSLW6B200M

-
Edité par lorrio 9 juillet 2020 à 23:37:12

-
Edité par NessrineKrouma 10 juillet 2020 à 8:03:37

Ne souhaiterais tu pas aussi que je vienne présenter le projet à ta place devant le jury ? Ce serait beaucoup plus simple non ?

Il ne faudrait peut-être pas abuser non plus... tu comptes faire comment plus tard si tu obtiens ton diplôme en recopiant le travail d'un autre ?

Le but d'un projet de fin d'étude est justement de te permettre d'apprendre à te débrouiller seul (ou en groupe) pour être autonome lorsque tu seras embauché dans une entreprise plus tard.

Ce serait bien que tu avances un peu par toi même maintenant plutôt que de me demander de tout faire à ta place.

J'ai déjà pris soin de :

- te donner un code exploitant l'ACS

- t'expliquer pourquoi ça ne marchait pas

- te proposer des solutions

- te donner la référence d'un capteur plus approprié (CSLW6B200M)

En plus d'être plus approprié à ton projet, ce capteur se comporte exactement comme un ACS, il est donc compatible avec arduino ainsi que la lib ACS712 que tu utilises.

Tout ce qu'il te faut ajouter, c'est un appel à la fonction setSensitivity pour que la sensibilité de la lib soit en adéquation avec celle du capteur.

Il y aura aussi un peu de câblage à faire mais c'est exactement comme sur l'ACS :

- 3 fils vers l'arduino : GND / OUTPUT / VCC

- 2 fils de puissance dans lesquels passent le courant

-
Edité par NessrineKrouma 10 juillet 2020 à 8:26:13

salut ,

c'est possible de remplacer le capteur ACS712_30A par ACS712_05b ???

et on peut ajouter une circuit de puissance ???

Je t'ai déjà répondu à ce sujet : le ACS712_05 sera forcément un peu mieux que le ACS712_30 car il dispose d'une plage de mesure plus faible.

Mais cette plage de mesure reste clairement inadaptée par rapport à ce que consomme un chargeur de téléphone donc tu ne pourras pas détecter la fin de charge avec.

A moins de mesurer le courant coté 5V mais comme tu le dis, ça ne respecte pas le cahier des charges.

Quand à ajouter ton circuit de puissance, je ne vois pas trop l’intérêt, tu as déjà un relais pour couper le 230V alors pourquoi ajouter un contacteur ???

-
Edité par lorrio 11 juillet 2020 à 17:29:44

bien monsieur,

J'ai convenu avec mes encadreure de remplacer mon capteur ACS712_30A  après le chargeur , 

Dans ce cas de figure, le capteur ACS712_30A pourrait convenir.

Sa plage de mesure 30A est un peu surdimensionnée pour mesurer un courant de charge mais ça reste faisable.

Un chargeur rapide ne dépassera jamais 2 à 3 Ampères en sortie donc tu n'exploiteras que 10% de la pleine échelle du capteur mais c'est suffisant pour ton projet.

Ce serait encore mieux avec un ACS712_05 mais si tu n'as que le ACS712_30 de disponible, tu devrais pouvoir t'en sortir quand même.

A noter que le courant en sortie de chargeur est un courant continu et non un courant alternatif comme sur le 230V donc tu devras utiliser la fonction getCurrentDC et non getCurrentAC.

-
Edité par lorrio 11 juillet 2020 à 18:15:35

sil vous plait ,,,j'ai besoin vous aide très urgent 

comment assure le câblage entre un capteur ACS712 5A +relais 5v+Arduino+un Bouton poussoir 

(Lorsque appuie sur le bouton poussoir le téléphone se met en charge et quand le chargeur à

vide ou bien la batterie atteint 100%  le  relais assure la déconnexion. )

si

Ah? C'est nouveau le bouton poussoir ? (tu n'en parlais pas il y a 2 mois)

Sur quoi bloques tu exactement ?

Aurais tu des petits bouts de code que tu as testé mais qui ne marchent pas ? (on pourrait t'expliquer pourquoi ça ne marche pas et te guider dans les corrections à apporter)

En utilisant le bouton poussoir Arduino pour pousser le relais ON et Push OFF, lorsque j'active le bouton poussoir, le relais se ferme et le chargeur se charge, et la deuxième pression sur le bouton, pour, ouvre le relais.

mon probléme c'est comment cabler le buton avec le relais ,le capteur ACS712 et l'adruino

voila j'ai écris ce code :

ACS712 sensor(ACS712_05B, A1);

int pbuttonPin =11;// connect output to push button
int relais = 9;// Connected to relay 

int val = 0; // push value from pin 2
int pushed = 0;//push status

void setup (){
	Serial.begin(9600);
	pinMode(pbuttonPin, INPUT_PULLUP); 
	Serial.println("INIT");
	pinMode(9,OUTPUT);
	digitalWrite(relais,HIGH); 
	delay(200);
	sensor.calibrate();
	delay(200);
	Serial.println("GO !!!");
}


void loop (void) {

	val = digitalRead(pbuttonPin);// read the push button value

	if(val == HIGH ){
		pushed = 1-pushed;
		delay(100);
	}    

	if(pushed == HIGH){
		digitalWrite(relais, LOW); 
	}else{
		digitalWrite(relais,HIGH);
		float current = sensor.getCurrentAC();
		Serial.print("Courant= ");
		Serial.print(current);
		Serial.print(" A");
		Serial.println();
		delay(1000);
		if(current<=0.16){
			digitalWrite(relais,LOW);
			Serial.print("ouvrir la realis");
			delay(86400000);//24h
		}
	}
}

-
Edité par lorrio 12 septembre 2020 à 17:04:32

J'ai l'impression qu'on tourne en rond et que tu prends en compte aucune de mes remarques...

Je t'ai déjà dis plusieurs choses :

- pendant la calibration, il faut impérativement qu'il n'y ai pas de courant, donc que le relais soit ouvert, ce qui semble ne pas être le cas

- si tu mets le capteur en sortie de chargeur (coté 5V et non 230V), la tension et le courant son continu et non alternatif donc il te faut utiliser la fonction getCurrentDC et non getCurrentAC

Je veux bien aider mais il ne faut pas non plus me prendre pour un con qui va faire tout le projet à ta place.

Cela fait 2 mois que le sujet est ouvert et je n'ai pas l'impression que tu ai pris le temps de réfléchir au problème.

Si tu es encore là, j'en dédis que ta soutenance qui devait avoir lieux mis juillet à été reportée pour cause de Covid 19 donc tu devrais en profiter pour bosser à fond dessus avant qu'il ne soit trop tard.

*****

Pour ce qui est du câblage de l'ACS, il n'y a pas de grande difficulté à ça, il y a 3 pins à connecter :

- Les 2 pins d'alimentation du capteur à relier sur GND et 5V

- La pins de sortie à relier sur une pin analogique de l'arduino

Le câblage du bouton n'est pas bien dure non plus :

- Un coté sur GND

- l'autre coté sur une pin digital de l'arduino

Il faudra ensuite mettre cette pin en INPUT_PULLUP et lire la valeur avec digitalRead sachant que l'état LOW correspondra à l'état enfoncé.

Et pour finir, le câblage du relais dépend du shield que tu utilises mais il y a très certainement que 3 pins à relier :

- Les 2 pins d'alimentation du shield à relier sur GND et 5V

- La pins de commande sur une pin digital que de l'arduino

Tous ces éléments sont à câbler indépendamment les uns des autres.

C'est ensuite le code que tu développeras qui fera la liaison logique entre chacun de sorte que la lecture de l'état LOW du bouton active le relais qui sera ensuite désactivée lorsque le courant sera faible.

-
Edité par lorrio 12 septembre 2020 à 17:15:12

Bonjour, c bon j'ai ressui au câblage de mon application et le code aussi, mais Monsieur, si j'ai testé avec un chargeur de PC j'ai obtenu : - Si ADC=0, alors I=0 et P=0, soit un chargeur éteint- Si ADC=1, alors I=0.026 et P=6 Watt, soit un chargeur à mi-puissance- Si ADC=2, alors I=0.052 et P=12 Watt, soit un chargeur à pleine puissance

mais quand j'ai testé avec un chargeur téléphonique, toujours j'ai obtient des valeurs entre 0 et 0.08

pourquoi???

-
Edité par NessrineKrouma 13 septembre 2020 à 11:49:59

Parce que le capteur ACS712 n'est pas fait pour mesurer un courant aussi faible que celui que consomme un chargeur de téléphone sur son entrée 230V.

On en a déjà parlé ! (on tourne vraiment en rond là)

Si tu veux utiliser l'ACS, il te faut le placer sur la sortie 5V du chargeur et non sur l'entrée 230V.

Si tu tiens absolument à mesurer le courant en entrée 230V, il te faut un capteur avec une plage de mesure beaucoup plus faible que celle de l'ACS712.

-
Edité par lorrio 13 septembre 2020 à 16:29:56

Bonne nouvelle

Du coup, je t'invite à cliquer sur le bouton "sujet résolu" en haut de ce sujet.