Quelquechose m' echappe dans le code

Bonjour , je ne comprends pas pourquoi cela ne fonctionne pas :

const bool TEST = 0;
#define RELAIS_ACTIF LOW
#define RELAIS_INACTIF HIGH

void activeRelais_A (uint8_t pin) {
	if (tableau_Pin_Relais[pin] == RELAIS_INACTIF) {
		if (!TEST) digitalWrite (tableau_Pin_Relais[pin] , RELAIS_ACTIF); //on effectue la mise à jour du pin
		if (DEBUG) {
			Serial.print (F("* activeRelais_A => numero "));
			Serial.print (pin);
			Serial.println (F(" active"));
		}
	}
}
activeRelais_A(45);

le relais ne s ' active pas , low et HIGH ne sont pas considérés comme true et false ?

Bonjour,
Où est ce que tableau_Pin_Relais est mis à jour ?

De plus tu n'as pas besoin de tester si le relais est actif avant de l'activer. Tu peux l'activer inconditionnellement, au pire si le relais était déjà actif il ne se passera rien.

un coup, tableau_Pin_Relais est considéré comme un état (LOW ou HIGH)
juste après, il est considéré comme un numéro de pin. ( digitalWrite(...) )
Il faut choisir !

Probablement, il suffit d'écrire
digitalWrite ( pin , RELAIS_ACTIF);

Bonjour , on ne peut pas avoir un seul tableau dont l' indice correspond au numero de pin et la valeur a l ' etat du relais ?

si j' ecris :
digitalWrite ( pin , RELAIS_ACTIF);
alors le tableau n ' est plus a jour ?
je ne peux plus faire par exemple :

if (tableau_Pin_Relais[pin] == RELAIS_INACTIF)

Pour info , avant j' avais 2 tableaux :
tableau_Pin_Relais[]
et
tableau_Etat_Relais[]
mais je ne comprends pas l ' utilité de ces 2 tableaux :nauseated_face: j ' essaie de simplifier le code .

Tu peux faire un seul tableau de structures.

oui , mais alors la condition debug est affichée , et je desire qu ' elle ne s ' affiche que lorsqu ' il y a un reel changement .

[quote="kamill, post:2, topic:1091771"]
Où est ce que tableau_Pin_Relais est mis à jour ?
[/quote] ben je pensais que justement ca le faisait là .

genre ca :

struct t_relais {
	uint8_t     	pinRelais;
	bool	        etat;
	const char* 	nom;
};

?
ce qui m' evite d' avoir 3 tableaux separés ( j utilise actuellement aussi un tableau pour les nom des relais ... ) .

OK , mais si je met un truc du style :
t_relais->etat == RELAIS_ACTIF
ca fonctionnera ?


Sinon , avec le code de depart , il faudrait que je mette par exemple :

if (!TEST) digitalWrite(pin, RELAIS_INACTIF); // commande a off
    tableau_Pin_Relais[pin] == RELAIS_INACTIF;

?

Oui, tu définis un tableau :
t_relais mesRelais[5];
et tu utilises les valeurs comme ça, par exemple :

for (int i = 0; i < nbRelais; ++i) digitalWrite(mesRelais[i].pinRelais, RELAIS_INACTIF);

bon , j ' ai testé cela :

struct t_relais {
	uint8_t     	pinRelais;
	bool	        etat;
	const char* 	nom;
};
t_relais lesRelais[] = {
{44, RELAIS_INACTIF, "Portail"},
{45, RELAIS_INACTIF, "Heures creuses"}
};
const uint8_t NOMBREDERELAIS = sizeof(lesRelais) / sizeof(t_relais);

mais il ne veut pas de mon LOW / HIGH en valeur de true false , c ' est chiant dans le code de toujours devoir jongler avec ces valeurs inverses ...

Si je met :

struct t_relais {
	uint8_t     	pinRelais;
	bool	        etat;
	const char* 	nom;
};
t_relais lesRelais[] = {
{44, true, "Portail"},
{45, true, "Heures creuses"}
};
const uint8_t NOMBREDERELAIS = sizeof(lesRelais) / sizeof(t_relais);

là ca passe ...

et avec :

#define RELAIS_ACTIF true
#define RELAIS_INACTIF false

?

je prends note de ton code pour l' initialisation :wink: merci .
juste une petite precision , quel est l ' interet de mettre ++i ? incrementation , je sais ce que ca fait mais je me rapelle plus ( ca fait longtemps que j' ai plus mis le nez dans le code en fait ... ) par rapport a la forme " classique " i++ ?

si je change , l ' initialisation des relais avec le code que tu as donné ci-dessus fonctionnera encore ?

C'est de la frime ! :stuck_out_tongue_winking_eye:

MDR .

une solution serait d' ajouter alors , par exemple

#define ETAT_ACTIF false
#define ETAT_INACTIF true

?

"Remplacer" : oui, je suppose.

Le ++ avant la variable incrémente sans créer de variable intermédiaire, le ++ après crée une variable temporaire donc occupe temporairement un peu plus de mémoire. Mais dans un indice de boucle, ça ne change pas vraiment... même possible que le compilateur fournisse le même code dans les deux cas.

Par contre il y a des cas où ça change (sauf erreur) :

i = 1;
x[i++] = i;

mettra 2 dans la case x[1], mais

i = 1;
x[++i] = i;

mettra 2 dans la case x[2]

Une structure peut te permettre d'avoir un seul tableau pour l'état et le nom, ainsi que limiter la taille de ton tableau, si tu ne veux pas forcément maintenir l'information pour toutes le broches.

Par contre sinon tu utilise tableau_Pin_Relais[pin] pour tester ton état.
Tu stocke immédiatement après ton test le changement de valeur, puis digitale.write avec la variable pin

Il suffit de tester l'état de la sortie

void activeRelais_A(uint8_t pin) {
  if (digitalRead(tableau_Pin_Relais[pin]) == RELAIS_INACTIF) {
    if (!TEST)
      digitalWrite(tableau_Pin_Relais[pin], RELAIS_ACTIF);  //on effectue la mise à jour du pin
    if (DEBUG) {
      Serial.print(F("* activeRelais_A => numero "));
      Serial.print(pin);
      Serial.println(F(" active"));
    }
  }
}

Bonsoir , est ce que je peux attribuer le numero de pin au numero de tableau de la structure ?

je suppose que oui , mais comment peux t on faire assez simplement ?

soit je m' y prends mal pour coder ma fonction , soit je ne sais pas trop ...

Avec la structure decrite plus haut , a travers un serveur web qui gere donc par l' adresse les numerso de pin pour les actions a effectués , j' essaie de coder une fonction qui me permette d ' activer le relais , j' ai ecris ca , mais ca n ' acive pas le relais puisque pin vaut 44 et que dans ma structure c ' est pinRelais ...

const bool TEST = 0; // active ou desactive les digitalWrite sur pin

struct t_relais {
	uint8_t     	pinRelais;
	bool	        etatRelais;
	const char* 	nomRelais;
};

t_relais lesRelais[] = {
{44, RELAIS_INACTIF, "Portail"},
{45, RELAIS_INACTIF, "Heures creuses"}
};
const uint8_t NOMBREDERELAIS = sizeof(lesRelais) / sizeof(t_relais);


void activeRelaisTimer (uint8_t pin) {
  if (lesRelais[pin].etatRelais != RELAIS_ACTIF) {
    lesRelais[pin].etatRelais = RELAIS_ACTIF;
    if (! TEST) digitalWrite (lesRelais[pin].pinRelais , RELAIS_ACTIF);
    activTimer (pin);
		if (DEBUG) {
			Serial.print (F("* activeRelaisTimer => numero "));
			Serial.print (lesRelais[pin].pinRelais);
			Serial.println (F(" active ."));
    }
  }
}

ma fonction recois comme parametre pin=44 .
mais je n' arrive pas a ecrire le digitalwrite correctement :nauseated_face:

Je n'ai pas compris ce que tu appel une adresse.
Ton tableau est remplis comment.
Il y a au moins 44 éléments ?
Si le numéro de l'élément de ton tableau correspond au numéro de ta broche, cela ne sert à rien d'avoir la propriété pinRelais dans ta structure.

Montre ton code en entier, car là on ne vois pas comment tu initialise ton tableau.

J'ai dis de bêtises, on vois très bien :rofl:
Ce que tu appel pin est le numéro de l'élément dans ton tableau, donc 0 pour la broche 44 et 1 pour la broche 45

une adresse internet ou URI qu ' on tape dans un navigateur web , par exemple cela : http://192.168.1.111/VG=-4
ou dans le cas que je cherche a resoudre , la veritable adresse est :
http://192.168.1.111/P=44

le tableau es rempli avec le code depart , puis j ' utilise la fonction suivante pour initialiser:

void init_Relais () { // t_relais lesRelais
  for (uint8_t i = 0; i < NOMBREDERELAIS; ++i) {
    pinMode (lesRelais[i].pinRelais, OUTPUT);
    digitalWrite(lesRelais[i].pinRelais, RELAIS_INACTIF);
    if(DEBUG) {
      Serial.print (F("* initRelais => Pin_Relais "));
      Serial.print (lesRelais[i].pinRelais);
      Serial.println (F(" initialise !"));
    }
  }
}

il n ' y a que 2 elements actuellement dans ce tableau .

si je montre le code entier , tu vas partir en courant :stuck_out_tongue:

ok je peux changer pour initialiser le tableau avec 44 au depart , du genre :

void init_Relais () { // t_relais lesRelais
  for (uint8_t i = 44; i < 44+NOMBREDERELAIS; ++i) {
    pinMode (lesRelais[i].pinRelais, OUTPUT);
    digitalWrite(lesRelais[i].pinRelais, RELAIS_INACTIF);
    if(DEBUG) {
      Serial.print (F("* initRelais => Pin_Relais "));
      Serial.print (lesRelais[i].pinRelais);
      Serial.println (F(" initialise !"));
    }
  }
}

ce qui resoudrait mon probleme non ?

je suis assez d' accord ... justement , mais je ne trouve pas comment ecrire correctement la ligne du digital write correctement pour que le relais 44 s ' enclenche lorsque je lui demande .

le compilateur ne renvoie aucune erreur .

et la sortie du moniteur me renvoie evidemment un truc bidon pour la ligne correspondante :

Serial.print (lesRelais[i].pinRelais);

en l' occurence j' ai 223 , qui correspond a rien .
mon code ( sur mega ) gere environ 50 pin .