Aller au contenu

ZEUS-2: Gestion aquarium avec Arduino


Messages recommandés

Dans la vraie vie, OSEF.....  :tapechaise

 

Sinon, c'est parce que j'ai des petites manies..... et je suis radin..  :horreur

 

Lorsque tu écris : "const int niveau_bas = 3", tu déclares une variable.

Variable qui certe est une constante, mais cela prend quand même de la place en terme de mémoire.

Donc tu consommes de la mémoire juste parce que t'es pas foutu de te souvenir que ton pin pour le niveau bas, c'est le 3.

​Donc tu préfères écrire :

const int niveau_bas = 3

pinMode(niveau_bas, INPUT)

 

plutôt que directement pinMode (3, INPUT)

 

 

Comme je suis un radin, je fais autrement.

J'utilise define. Quand tu écris #define niveau_bas 3, tu dis au compilateur la chose suivante.

"Merci monsieur le compilateur de remplacer partout dans mon code le terme niveau_bas  par 3".

C'est ce qu'il fait et ensuite il envoie le code dans l'arduino.

Bilan, 0 mémoire consommée.

 

Le define n'est pas envoyé dans la carte, il ne sert que pour le compilateur.

Et dans m'a carte n'est envoyé que pinMode(3, INPUT)

Lien vers le commentaire
Partager sur d’autres sites

  • Réponses 455
  • Created
  • Dernière réponse

 

J'ai commencé à regarder dans le détail et du coup, j'ai lancé ma propre expérimentation avec le code qui sera légèrement différent puisque mes exigences sont légèrement différentes comme tu l'expliques.

 

 

Heu..atta, atta, c'est pas le code ça..  :bonjour

Là c'est juste pour faire un osmolateur tunze.

C'est la bidouille que j'ai utilisé ses dernières semaines pour avoir une osmolation pendant que je continuais à bricoler.

Ca ferait chier d'avoir un arduino et juste faire ça....  :D

C'était pour pas faire peur....

 

Je travaille principalement avec des classes, dans le code principal, ca donne ca :

#include "Log.h"
#include <RTClib.h>
#include <Wire.h>
#include <SD.h>
#include "Eclairage.h"
#include "Osmolation.h"
#include "Pins_mega.h"
RTC_DS3231 rtc;
EclairageClass rampe_led;
unsigned long dernier_milli = 0; // necessaire car reset du milli tous les 50 jours
int compteur_tempo_niveau = 0;
OsmolationClass niveau;
Log enr;
Pins les_pins;
void setup() {
	Serial.begin(9600);
	SD.begin(50);
	rtc.begin();
	enr.ini(rtc.now());
	les_pins.ini();
}

// the loop function runs over and over again until power down or reset
void loop() {
	//demarrage ecumeur après 1 minute de mise en route du systeme
	if (millis() > 60000) {
		digitalWrite(ecumeur, HIGH);
		enr.enregistre(rtc.now(), "mise en route ecumeur");
	}
	//test pour savoir si je dois lancer une procédure d'éclairage
	//milli repart ? 0 tous les 50 jours donc on teste si inf?rieur au dernier milli enregistr? (reboot)
	if ((millis() >= rampe_led.prochain_eclairage()) || (millis() < dernier_milli)) {
		String etat_ini = rampe_led.etat();
		rampe_led.test(rtc.now());
		dernier_milli = millis();
		if (rampe_led.etat() != etat_ini) {
			enr.enregistre(rtc.now, rampe_led.etat());
		}
	}
	//gestion des niveaux, des alertes, test si l'un des capteurs est d?clench?.
	//compteur de tempo sert à eviter les déclenchement intempestif 5 sec de délai
	if (compteur_tempo_niveau > 3000) {
		String etat_ini = niveau._alerte;
		compteur_tempo_niveau = 0;
		niveau.test_capteur();
		niveau.analyse_capteur();
		if (niveau._alerte != etat_ini) {
			enr.enregistre(rtc.now(), niveau._alerte);
		}
	}
	compteur_tempo_niveau++;
	
}

Et pour la partie osmolation donc,

Ca donne ca :

le .h


#ifndef _OSMOLATION_h
#define _OSMOLATION_h

#if defined(ARDUINO) && ARDUINO >= 100
	#include "arduino.h"
#else
	#include "WProgram.h"
#endif

#define event_osmolation  30000 //delai d'osmolation en milliseconde
#define delai_osmolation  300000 //delai entre deux osmolation 5 min
#define alerte1 "Niveau haut"
#define delai_alerte1 600000 //Trop d'eau, ne plus tenir compte durant 10 min, couper ecumeur
#define alerte2 "Niveau haut-Capteur travail bloqué"
#define delai_alerte2 3600000 //capteur travail bloqué haut, ne plus tenir compte durant 1 H
#define alerte3 "Niveau bas-Capteur bas bloqué bas"
#define delai_alerte3 600000;//capteur sécurité bas bloqué , ne plus tenir compte durant 10 min
#define alerte4 "Niveau bas-Niveau de travail bloqu? "
#define delai_alerte4 3600000;//capteur travail bloqué haut, ne plus tenir compte durant 1H
#define alerte5 "Niveau bas-Proc?dure de coupure de l'?quipement"
#define delai_alerte5 5000//delai avant coupure 5 sec (on a pu sortir quelque chose de la decantation
#define alerte6 "délai d'osmolation insuffisant"
#define alerte7 "osmolation normale"
#include "Pins_mega.h"

class OsmolationClass
{
 protected:
	 boolean _capteur_haut;
	 boolean _capteur_bas;
	 boolean _capteur_travail;
	 unsigned long _event_alarme;
	 int _alarme;
	 void gestion_alarme();
	 unsigned long dernier_event_osmolation = 0;

 public:
	void init();
	void test_capteur();
	void analyse_capteur();
	void osmolation(int delai);
	void alerte(int type_alerte);
	boolean capteur_haut() { return _capteur_haut; };
	boolean capteur_bas() { return _capteur_bas; };
	boolean capteur_travail() { return _capteur_travail; };
	unsigned long event_alarme() { return _event_alarme; };
	int alarme() { return _alarme; };
	String _alerte;
};

extern OsmolationClass Osmolation;

#endif

et le .cpp

#include "Osmolation.h"

void OsmolationClass::init()
{
	_capteur_haut = false;
	_capteur_bas = false;
	_capteur_travail = false;
	_event_alarme=0;
	String _alerte ="";
	_alarme = 0;
}
void OsmolationClass::test_capteur(){
	if (digitalRead(niveau_haut) == HIGH) { _capteur_haut = true; }
	if (digitalRead(niveau_travail) == HIGH) { _capteur_travail = true; }
	if (digitalRead(niveau_bas) == HIGH) { _capteur_bas = true; }
}
void OsmolationClass::analyse_capteur() {
	if (_alarme == 5) { return; }// on est en arrêt niveau bas.
	if (_alarme != 0) { // nous sommes en mode alarme
		if (_event_alarme < millis()) {// le delai d'alarme est dépasse
			//on reinitialise
			alerte(0);
		}
		else {
			gestion_alarme();
		}
	}
	if (_capteur_haut) {//capteur niveau haut d?clench?
		if (!_capteur_travail) {
			// ne plus en tenir compte du capteur travail durant 1 H
			alerte(2);
		}
		else {
			// ne plus tenir compte de l'alerte durant 10 min (2 capteurs haut)
			alerte(1);
			;
		}
		return;
	}
	if (_capteur_bas) {//capteur securit? bas d?clench?
		if (!_capteur_travail) {
			// on peut en d?duire que le capteur de travail est bloqu? ou qu'un truc vient de monter sur le capteur bas
			//lancer une osmolation pour tester
			digitalWrite(relais_osmolation, HIGH);// ouvrir le relais de la pompe d'osmolation
			delay(event_osmolation);
			digitalWrite(relais_osmolation, LOW); // fermer le relais
			//si suite ? cette osmolation le capteur bas reste actif ne plus tenir compte de ce capteur durant 30 minutes
			if (digitalRead(niveau_bas == HIGH)) {
				alerte(3);
			}
			else {
				// si suite ? cette osmolation le capteur se d?sactive
				// lancer une alerte et utiliser le capteur bas pour une osmolation
				alerte(4);
			}
		}
		else {
			// faire une alerte niveau bas, les deux capteurs sont activ?s
			alerte(5);
			//couper pompe de remont?e, osmolation et ?cumeur d?finitivement et mode alerte permanente
		}
		return;
	}
	if (_capteur_travail) {//osmolation normale
		osmolation(event_osmolation);
	}

}
void OsmolationClass::osmolation(int delai) {
	digitalWrite(relais_osmolation, HIGH);// ouvrir le relais de la pompe d'osmolation
	delay(delai);
	digitalWrite(relais_osmolation, LOW); // fermer le relais
	alerte(7);
	// verifie qu'il n'y a pas d'osmolation rapproch?e (5 minutes)
	if ((millis() - dernier_event_osmolation) < delai_osmolation) {
		//seconde osmolation en moins de 1 minute
		if (digitalRead(niveau_travail) == LOW) {
			//le niveau de travail est ok donc temps d'osmolation insuffisant
			alerte(6);
		}
	}
	//enregistre le moment de l'osmolation
	dernier_event_osmolation = millis();
	// faire un enregistrement dans la SD
}
void OsmolationClass::alerte(int type_alerte) {
	switch (type_alerte)
	{
	case 0:
		_alerte = "";
		_event_alarme = 0;
		break;
	case 1:
		_alerte = alerte1;
		_event_alarme = delai_alerte1;
		digitalWrite(ecumeur, LOW); // coupure ecumeur
		break;
	case 2:
		_alerte = alerte2;
		_event_alarme = delai_alerte2;
		digitalWrite(ecumeur, LOW);// coupure ecumeur
		break;
	case 3:
		_alerte = alerte3;
		_event_alarme = delai_alerte3;
		break;
	case 4:
		_alerte = alerte4;
		_event_alarme = delai_alerte4;
		break;
	case 5:
		digitalWrite(relais_osmolation, HIGH);// ouvrir le relais de la pompe d'osmolation
		delay(delai_alerte5);
		digitalWrite(relais_osmolation, LOW); // fermer le relais
		_alerte = alerte5;
		_event_alarme = 0; 
		digitalWrite(pompe_remontee1, HIGH); // coupre des pompes
		digitalWrite(pompe_remontee2, HIGH);
		digitalWrite(ecumeur, LOW); // coupure ecumeur
		break;
	case 6:
		_alerte = alerte6;
		break;
	case 7:
		_alerte = alerte7;
		break;
	}

	_event_alarme = _event_alarme + millis();
	_alarme = type_alerte;
}
void OsmolationClass::gestion_alarme() {
	switch (_alarme)
	{
	case 0:
		_alerte = "";
		_alarme = 0;
		_event_alarme = 0;
		break;
	case 1:
		_capteur_haut = false;
		break;
	case 2:
		_capteur_haut = false;
		_capteur_travail = false;
		break;
	case 3:
		_capteur_bas = false;
		break;
	case 4:
		if (_capteur_bas){// pour eviter la coupure ou le remet haut et on allume le travail
			_capteur_bas = false;
			_capteur_travail = true;
		}
		break;
	case 5:
		break;
	case 6:
		break;
	case 7:
		break;
	}
}

Lien vers le commentaire
Partager sur d’autres sites

Ok, merci.

J'avais lu que l'instruction #define pour déclarer une constante pouvait, dans certains cas relatifs à l'interprétation des noms, générer des erreurs, donc j'évitais ;)

 

Super merci aussi pour le code complété. Ca devient vite plus hard. J'ai du pain sur la Breadboard, mais rien que cette première lecture m'a fait découvrir pas mal de notions   :prosterne

 

Puisque tu travailles avec des modules indépendants/esclaves mais suivis et paramétrables à partir d'un module maitre, confirme moi :

Le code principal... C'est le code du module maitre ?

Je commence à saisir la création/utilisation de bibliothèques personnelles, mais quel code est finalement versé dans le module Osmolation ?

Lien vers le commentaire
Partager sur d’autres sites

Ok, merci.

J'avais lu que l'instruction #define pour déclarer une constante pouvait, dans certains cas relatifs à l'interprétation des noms, générer des erreurs, donc j'évitais ;)

 

Et tu as bien raison.... !

 

Puisque tu travailles avec des modules indépendants/esclaves mais suivis et paramétrables à partir d'un module maitre, confirme moi :

Le code principal... C'est le code du module maitre ?

 

Il faut qu'on se mette d'accord sur le terme Maitre/esclave, déjà...

Je n'arrête pas de le dire à ma femme d'ailleurs. :$

En fait, je n'utilise aucun Maitre et aucun esclave....  :tapemur

 

Maitre/esclave, cela signifie qu'une carte va piloter une autre carte.

Ce qui ne sera pas mon cas.

J'aurais une carte "automate", une Mega, qui fera les détections (ex: les capteurs de niveau) et conduira les actions (ex : déclencher l'osmolation).

J'aurais une carte d'interface, une Uno avec un ecran tactile, qui me permettra de visualiser les paramètres (ex: la valeur pH) que la carte "automate" lui donnera et de passer les demandes à la carte automate (ne tient pas compte des capteurs de niveau, je vais nettoyer ma décantation).

 

 

Pour le code posté, il correspond au code pour la carte Mega et je t'ai juste mis la partie osmolation ensuite.

Heu, attention, je n'ai pas fini de débuggé hein...!

 

Plutôt que de faire un code interminable de milliers de ligne ou tu ne retrouves plus rien, je l'ai scindé en différents fichiers.

Eclairage, osmolation, enregistrement, etc.

Et je dis dans le code principal "include Osmolotion.h", ca va dire mets moi le contenu du fichier Osmolation.

A terme après la compilation, tu auras un seul "fichier" unique de milliers de ligne.

C'est juste une facilité pour écrire le code pour l'humain.

 

Par exemple, je dis :

#include "Pins_mega.h"

Ben c'est bêtement le fichier d'initialisation de mes pins.

Cela contient :

#define relais_eclairage_1  22
#define relais_eclairage_2  23
//pin d'éclairage en PWM
#define eclairage_bleu 2
#define eclairage_blanc 3
// pin pour osmolation
#define niveau_bas  24
#define niveau_travail 25
#define niveau_haut 26
#define relais_osmolation  27
#define pompe_remontee1 28 //ferme au repos
#define pompe_remontee2 29 //ferme au repos
#define ecumeur 30

et puis :

void Pins::ini() {
	pinMode(relais_eclairage_1, OUTPUT);
	pinMode(relais_eclairage_2, OUTPUT);
	pinMode(niveau_bas, INPUT);
	pinMode(niveau_travail, INPUT);
	pinMode(niveau_haut, INPUT);
	pinMode(relais_osmolation, OUTPUT);
	pinMode(pompe_remontee1, OUTPUT);
	pinMode(pompe_remontee2, OUTPUT);
	pinMode(ecumeur, OUTPUT);
}

Donc des trucs que tu aurais pu mettre au début du code habituel et dans le set up.

Cela revenait au même et d'ailleurs quand tu compiles pour envoyer sur la carte, c'est bien ce que fait le compilateur.

Lien vers le commentaire
Partager sur d’autres sites

Il faut qu'on se mette d'accord sur le terme Maitre/esclave, déjà...

 

Ce qui ne sera pas mon cas.

J'aurais une carte "automate", une Mega, qui fera les détections (ex: les capteurs de niveau) et conduira les actions (ex : déclencher l'osmolation).

J'aurais une carte d'interface, une Uno avec un ecran tactile, qui me permettra de visualiser les paramètres (ex: la valeur pH) que la carte "automate" lui donnera et de passer les demandes à la carte automate (ne tient pas compte des capteurs de niveau, je vais nettoyer ma décantation).

 

Ok, au temps pour moi, j'étais parti sur la fausse idée de modules dédiés à chaque fonction (éclairage, osmolation...) et un autre centralisé pour lectures et commandes. 

 

Ni maître ni esclave. Un fonctionnement transversal comme on dit aujourd'hui. Tu ne crains pas que ça dérive vite à la pagaille dans le code, avec des variables trop aléatoires et des instructions contestataires. Je préfère une bonne démocratie hiérarchisée, bien ficelée à la Romaine : vous discutez, je décide, vous exécutez  :D 

Lien vers le commentaire
Partager sur d’autres sites

Ok, au temps pour moi, j'étais parti sur la fausse idée de modules dédiés à chaque fonction (éclairage, osmolation...) et un autre centralisé pour lectures et commandes. 

 

Ni maître ni esclave. Un fonctionnement transversal comme on dit aujourd'hui. Tu ne crains pas que ça dérive vite à la pagaille dans le code, avec des variables trop aléatoires et des instructions contestataires. Je préfère une bonne démocratie hiérarchisée, bien ficelée à la Romaine : vous discutez, je décide, vous exécutez   :D

 

Il y en aura bien plusieurs.

C'est à cause de l'éloignement.

Par exemple, il y aura un module pour les mesures pH/orp.

Je triche quand je dis que la Mega fera tout.. ;-)

Lien vers le commentaire
Partager sur d’autres sites

Yes

 

 

Ca va douiller... :-)

Perso, le bocal, je ne ferai pas. Un peu inutile je pense.

Et pour l'eau fraîchement préparée, je pense utiliser une sonde de base.

Je prélève de l'eau, je mesure, je rince.

Du coup, plus besoin d'une sonde industrielle en continue.

Ca devrait couter bcp moins cher.

Lien vers le commentaire
Partager sur d’autres sites

J'ai dit des conneries pour l'ecran Nextion.

Il se flash avec une carte SD, c plus simple.

Je n'avais pas vu :

 

Flash Project firmware from SD card

1. Open the bin folder and copy the project firmware in two ways:

1.Open Nextion Editor→File→Build Folder

2. Open the computer path like this: Open Computer→ Local Disk(C:)→ User→User's Computer(User's Computer name)→ AppData→ Roaming→ Nextion Editor→ bianyi,you will see the project file in tft format.

Note1: Only this tft format file could work. Copy the tft file to SD card, then insert SD card in the Nextion SD card slot(make sure there is only one tft file in SD card), power up Nextion, and then the project installation will be automatically proceeded.

Note2: Store only one tft file in the SD card, and the resolution of tft file must be in accordance with the resolution of Nextion TFT.

Note3: The SD card should be in FAT32 format and less than 32G.

 

 

Je viens de le faire, ca fonctionne nickel

Lien vers le commentaire
Partager sur d’autres sites

Pour revenir à l'osmolation, je vois bien le relais (pour une pompe de mise à niveau) mais point de capteur dans la réserve d'eau : capteurs de niveau haut (débordement) et capteur de niveau bas (marche à sec). C'est volontaire ?

 

Oups, pardon.... Ce chat est tellement actif que j'avais omis ce post...  :horreur

Oui, c'est normal, il n'y a pas de réserve d'eau.

C'est un autre binz qui va me gérer le remplissage des réserves d'eau et la fabrication de l'eau de mer.

C'est un peu trop loin pour tirer autant de fils, du coup, c'est un autre module.

 

Pour le moment ça fonctionne avec deux capteurs et une electrovanne en série.

Enfin, ca fait 5 ans que ca fonctionne comme ca, c'est le systeme le plus simple et le plus sécurisant que je conseille...

A mon avis, je ne vais pas y toucher à celui là...

3 min de bricolage, 15 euros d'achat grand max..... Peu pas tomber en panne.... Le top... Tiens je vais breveter le systeme.. :-)

Lien vers le commentaire
Partager sur d’autres sites

Oui, c'est normal, il n'y a pas de réserve d'eau.

C'est un autre binz qui va me gérer le remplissage des réserves d'eau et la fabrication de l'eau de mer.

 

OK pour le remplissage de l'eau dans la réserve.

Mais pour rester sur le sujet de la mise à niveau dans le bac (osmolation), qu'as-tu prévu pour éviter que la pompe de mise à niveau tourne à sec ?

Lien vers le commentaire
Partager sur d’autres sites

Ben si tu pars du principe que ma réserve ne peut pas être vide.. La pompe ne peut donc pas se retrouver à tourner à vide.. :-)

 

En fait, je m'en cogne complètement de cette pompe.

C'est une petite pompe 12V qui doit avoir 20 ans.

Elle peut cramer si elle veut, elle a fait son temps...

 

Mais par contre tu viens de me donner une idée...

Atta, je code, je reviens.

Lien vers le commentaire
Partager sur d’autres sites

Bon,

j'avais un peu oublier dans mes histoires que le capteur de travail pouvait être bloqué ou que l'osmolation pouvait ne plus fonctionner (pompe grillée ou plus d'eau dans la réserve).

 

Donc j'ai pris en compte ces situations et je fais un test en coupant les pompes de remontée afin de différencier un capteur de travail coincé d'une panne d'osmolation.

 

Je te mets les fichiers en attaché.

Attention, ce n'est pas du tout débogué.... !

Surtout il faudra que je reprenne tout et que je réécrive, c'est devenu imbitable.

Faut que je scinde en différentes fonctions.

 

Ah ben le site refuse.... Problème de sécurité...;

Donc les codes :

// Osmolation.h

#ifndef _OSMOLATION_h
#define _OSMOLATION_h

#if defined(ARDUINO) && ARDUINO >= 100
	#include "arduino.h"
#else
	#include "WProgram.h"
#endif

#define event_osmolation  30000 //delai d'osmolation en milliseconde
#define delai_osmolation  300000 //delai entre deux osmolation 5 min
#define alerte1 "Niveau haut"
#define delai_alerte1 600000 //Trop d'eau, ne plus tenir compte durant 10 min, couper ecumeur
#define alerte2 "Niveau haut-Capteur travail bloqué"
#define delai_alerte2 3600000 //capteur travail bloqué haut, ne plus tenir compte durant 1 H
#define alerte3 "Niveau bas-Capteur bas bloqué bas"
#define delai_alerte3 600000;//capteur sécurité bas bloqué , ne plus tenir compte durant 10 min
#define alerte4 "Niveau bas-Niveau de travail bloqu? "
#define delai_alerte4 3600000;//capteur travail bloqué haut, ne plus tenir compte durant 1H
#define alerte5 "Niveau bas-Proc?dure de coupure de l'?quipement"
#define delai_alerte5 5000//delai avant coupure 5 sec (on a pu sortir quelque chose de la decantation
#define alerte6 "délai d'osmolation insuffisant"
#define alerte7 "osmolation normale"
#define alerte8 "capteur de travail bloqué"
#define delai_alerte8 3600000 // inactivé le capteur de travail durant 1 heure
#define alerte9 "osmolation ne fonctionne plus"
#define delai_alerte9 43200000 // inactivé le capteur de travail durant 12 heure
#include "Pins_mega.h"

class OsmolationClass
{
 protected:
	 boolean _capteur_haut;
	 boolean _capteur_bas;
	 boolean _capteur_travail;
	 unsigned long _event_alarme;
	 int _alarme;
	 void gestion_alarme();
	 unsigned long dernier_event_osmolation = 0;

 public:
	void init();
	void test_capteur();
	void analyse_capteur();
	void osmolation(int delai);
	void alerte(int type_alerte);
	boolean capteur_haut() { return _capteur_haut; };
	boolean capteur_bas() { return _capteur_bas; };
	boolean capteur_travail() { return _capteur_travail; };
	unsigned long event_alarme() { return _event_alarme; };
	int alarme() { return _alarme; };
	String _alerte;
};

extern OsmolationClass Osmolation;

#endif


// 
// 
// 

#include "Osmolation.h"

void OsmolationClass::init()
{
	_capteur_haut = false;
	_capteur_bas = false;
	_capteur_travail = false;
	_event_alarme = 0;
	String _alerte = "";
	_alarme = 0;
}
void OsmolationClass::test_capteur() {
	if (digitalRead(niveau_haut) == HIGH) { _capteur_haut = true; }
	if (digitalRead(niveau_travail) == HIGH) { _capteur_travail = true; }
	if (digitalRead(niveau_bas) == HIGH) { _capteur_bas = true; }
}
void OsmolationClass::analyse_capteur() {
	if (_alarme == 5) { return; }// on est en arrêt niveau bas.
	if (_alarme != 0) { // nous sommes en mode alarme
		if (_event_alarme < millis()) {// le delai d'alarme est dépasse
			//on reinitialise
			alerte(0);
		}
		else {
			gestion_alarme();
		}
	}
	if (_capteur_haut) {//capteur niveau haut d?clench?
		if (!_capteur_travail) {
			// ne plus en tenir compte du capteur travail durant 1 H
			alerte(2);
		}
		else {
			// ne plus tenir compte de l'alerte durant 10 min (2 capteurs haut)
			alerte(1);
			;
		}
		return;
	}
	if (_capteur_bas) {//capteur securit? bas d?clench?
		if (_alarme == 9){
			alerte(5);// on sait déjà que l'osmolation ne foctionnait plus. donc tout couper
			return;
		}
		if (!_capteur_travail) {
			// on peut en d?duire que le capteur de travail est bloqu? ou qu'un truc vient de monter sur le capteur bas
			//lancer une osmolation pour tester
			digitalWrite(relais_osmolation, HIGH);// ouvrir le relais de la pompe d'osmolation
			delay(event_osmolation);
			digitalWrite(relais_osmolation, LOW); // fermer le relais
			//si suite ? cette osmolation le capteur bas reste actif ne plus tenir compte de ce capteur durant 30 minutes
			if (digitalRead(niveau_bas == HIGH)) {
				alerte(3);
			}
			else {
				// si suite ? cette osmolation le capteur se d?sactive
				// lancer une alerte et utiliser le capteur bas pour une osmolation
				alerte(4);
			}
		}
		else {
			// faire une alerte niveau bas, les deux capteurs sont activ?s
			alerte(5);
			//couper pompe de remont?e, osmolation et ?cumeur d?finitivement et mode alerte permanente
		}
		return;
	}
	if (_capteur_travail) {//osmolation normale
		osmolation(event_osmolation);
	}
	/// redemarrer écumeur le cas échéant	
	digitalWrite(ecumeur, HIGH);
}
void OsmolationClass::osmolation(int delai) {
	digitalWrite(relais_osmolation, HIGH);// ouvrir le relais de la pompe d'osmolation
	delay(delai);
	digitalWrite(relais_osmolation, LOW); // fermer le relais
	alerte(7);
	// verifie qu'il n'y a pas d'osmolation rapproch?e (5 minutes)
	if ((millis() - dernier_event_osmolation) < delai_osmolation) {
		//seconde osmolation en moins de 1 minute
		if (digitalRead(niveau_travail) == LOW) {
			//le niveau de travail est ok donc temps d'osmolation insuffisant
			alerte(6);
		}
		else { // osmolation en panne ou capteur bloqué
			// on va tester en coupant les pompe de remontée
			digitalWrite(ecumeur, LOW);
			digitalWrite(pompe_remontee1, HIGH);
			digitalWrite(pompe_remontee2, HIGH);
			delay(30000);
			if (digitalRead(niveau_travail) == HIGH){// le capteur de travail est tjrs bloqué
				alerte(;
			}
			else {
				// c'est l'osmolation qui est en panne
				alerte(9);// osmolation en panne.
			}			
			digitalWrite(pompe_remontee1, LOW);
			digitalWrite(pompe_remontee2, LOW);
			delay(30000);
			digitalWrite(ecumeur, HIGH);
		}
	}
	//enregistre le moment de l'osmolation
	dernier_event_osmolation = millis();
	// faire un enregistrement dans la SD
}
void OsmolationClass::alerte(int type_alerte) {
	_alarme = type_alerte;
	switch (type_alerte)
	{
	case 0:
		_alerte = "";
		_event_alarme = 0;
		break;
	case 1:
		_alerte = alerte1;
		_event_alarme = delai_alerte1;
		digitalWrite(ecumeur, LOW); // coupure ecumeur
		break;
	case 2:
		_alerte = alerte2;
		_event_alarme = delai_alerte2;
		digitalWrite(ecumeur, LOW);// coupure ecumeur
		break;
	case 3:
		_alerte = alerte3;
		_event_alarme = delai_alerte3;
		break;
	case 4:
		_alerte = alerte4;
		_event_alarme = delai_alerte4;
		break;
	case 5:
		digitalWrite(relais_osmolation, HIGH);// ouvrir le relais de la pompe d'osmolation
		delay(delai_alerte5);
		digitalWrite(relais_osmolation, LOW); // fermer le relais
		_alerte = alerte5;
		_event_alarme = 0; 
		digitalWrite(pompe_remontee1, HIGH); // coupre des pompes
		digitalWrite(pompe_remontee2, HIGH);
		digitalWrite(ecumeur, LOW); // coupure ecumeur
		break;
	case 6:
		_alerte = alerte6;
		break;
	case 7:
		_alerte = alerte7;
		break;
	case 8: //capteur de travail bloqué
		_alerte = alerte8;
		_event_alarme = delai_alerte8;
		break;
	case 9://osmolation en panne
		_alerte = alerte9;
		_event_alarme = delai_alerte9;

	}
	_event_alarme = _event_alarme + millis();
}
void OsmolationClass::gestion_alarme() {
	switch (_alarme)
	{
	case 0:
		_alerte = "";
		_alarme = 0;
		_event_alarme = 0;
		break;
	case 1:
		_capteur_haut = false;
		break;
	case 2:
		_capteur_haut = false;
		_capteur_travail = false;
		break;
	case 3:
		_capteur_bas = false;
		break;
	case 4:
		if (_capteur_bas){// pour eviter la coupure ou le remet haut et on allume le travail
			_capteur_bas = false;
			_capteur_travail = true;
		}
		break;
	case 5:
		break;
	case 6:
		break;
	case 7:
		break;
	case 8:
		_capteur_travail = false; // on desactive le capteur de travail duran 1 heure
		break;
	case 9:
		_capteur_travail = false; // l'osmolation est en panne
		break;
	}
}

Lien vers le commentaire
Partager sur d’autres sites

Je galère grave avec les modules de com sans fil. :-(

J'ai pris des modules qui utilisent le bus I2C, mais impossible d'avoir une communication stable ou même pérenne...

C'est ça : https://www.aliexpress.com/item/NRF24L01-wireless-data-transmission-module-2-4G-ATMEGA48-NRF24L01-Arduino-compatible/1387904044.html

 

Ben je déconseille... En tout cas en version bus série.

Lien vers le commentaire
Partager sur d’autres sites

Le composant nrf24l01 est en bus spi, ce n est ni du bus i2c ni du bus série

 

Cet IC radio a d'excellente performance (je l utilise dans des équipements médicaux )

 

A quel débit réalisé tu t'es essais ?

Es tu sûre de la lib arduino ?

 

Ton module ou son implémentation hardware ont peut être un problème ...

 

Je pense que a vaut le coup de persévérer avec cet ic

Lien vers le commentaire
Partager sur d’autres sites

Ben, la, il est censé fonctionner en I2C.

En spi de toute manière, tu n'as pas assez de broche.

Je teste à 9600. J'arrive parfois à passer un truc durant 5 min et ensuite terminé.

Ça fait 4 jours que je suis dessus.

J'ai 4 cartes et 4 modules, j'ai fait toutes les permutation sur possible.

Même punition.

 

Le mieux que j'ai eu, c l'un qui pouvait émettre et recevoir et l'autre jusque recevoir.

Ça, durant 30 minutes, puis plus rien...

Lien vers le commentaire
Partager sur d’autres sites

C est bien un nrf24l01 ?

http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01

 

Il est bien en spi, je le connais bien ...

Il y a des libs arduino qui le pilote en direct, tu as un adaptateur avec ?? Pour qu il soit en série

 

Regarde la :

 

https://www.google.fr/amp/s/itechnofrance.wordpress.com/2013/05/24/utilisation-du-module-nrf24l01-avec-larduino/amp/

Lien vers le commentaire
Partager sur d’autres sites

Archivé

Ce sujet est désormais archivé et ne peut plus recevoir de nouvelles réponses.


×
×
  • Créer...

Information importante

En poursuivant votre navigation, vous acceptez l’utilisation des cookies pour vous proposer des contenus adaptés à vos centres d’intérêt et réaliser des mesures pour améliorer votre expérience sur le site. Pour en savoir plus et gérer vos paramètres, cliquez ici